CrystalSpace

Public API Reference

Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

Crystal Space Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
_csKeyModifiersFlags for all currently pressed modifiers
ADDRESS64
awsEmbeddedComponentClass used to create new AWS components
awsEmbeddedComponentFactoryFactory for custom AWS component
CrystalSpace::ConditionAdd< T1, T2 >
csAlphaModeDescribes how to deal with alpha values in textures
csAnimatedPixmapA pixmap with a 2d animation
csAnimationTemplateA 2d animation template. This class is used to create animated pixmaps
csAnsiParserHelper to parse a string for ANSI codes
csAnsiParser::CommandParamsParameters to ANSI command
csApplicationFrameworkApplication framework class
csApplicationRunner< T >Helper template to run a csApplicationFramework-derived application class
csArchiveThis class can be used to work with standard ZIP archives
csArray< T, ElementHandler, MemoryAllocator >A templated array class
csArray< T, ElementHandler, MemoryAllocator >::IteratorIterator for the Array<> class
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
csArrayMemoryAllocator< T >The default allocator for csArray
csAudioStreamDescriptionAudio stream description structure
csBakeKeyColorFunctions to bake keycolor into the alpha channel of images
csBaseEventHandlerBase implementation of a generic event handler
csBaseRenderStepLoader
csBaseRenderStepType
csBaseTextureFactoryBase class for texture factories, with support for common parameters
csBitArrayA one-dimensional array of bits, similar to STL bitset
csBitArray::BitProxy
csBitmapMetricsMetrics for a glyph that are dependent from whether a simple or antialiased image is used
csBitmaskToStringSmall helper to get a "pretty" string for a combination of bit masks
csBitmaskToString::MaskNamesStructure containing a name for possible bit masks
csBlockAllocator< T, BlockPolicy >This class implements a memory allocator which can efficiently allocate objects that all have the same size
csBlockAllocator< T, BlockPolicy >::BlockKey
csBlockAllocator< T, BlockPolicy >::FreeNode
csBlockAllocatorAlignPolicy< A >This class implements a per-block allocating policy which aligns the first element on given byte boundary
csBlockAllocatorNormalBlockPolicyThis class implements the normal per block allocating policy
csBox2A bounding box in 2D space
csBox2IntA 2D bounding box with integer coordinates
csBox3A bounding box in 3D space
csBox3::bEdge
csBoxClipperAble to clip convex polygons to a rectangle (such as the screen)
csBSplineA B-spline
csBSPTreeThis BSP-tree is a binary tree that organizes a triangle mesh
csCallStack
csCallStackHelper
csCatmullRomSplineA CatmullRom spline
csChainHull2DThis is Andrew's monotone chain 2D convex hull algorithm
csClipInfoStructure for use with ClipToPlane
csClipperAbstract parent to all 2D clipping objects
csCLQAttenuationConstant, Linear, Quadratic attenuation Out = in /(const + distance*lin + distance^2*quad)
csCodecDescriptionCodec description structure
csColliderActorWith csColliderActor you can more easily manage collision detection of a player or character model with gravity handling
csColliderHelperThis is a class containing a few static member functions to help work with csColliderWrapper and collision detection in general
csColliderWrapperThis is a convenience object that you can use in your own games to attach an iCollider object (from the CD plugin system) to any other csObject (including CS entities)
csCollisionPairA structure used to return collision pairs
csColorA class used to represent a color in RGB space
csColor4A class used to represent a color in RGBA space
csColorQuantizerColor quantizer
csCommandEventDataStructure that collects the data a command event carries
csCommandEventHelperHelper class to conveniently deal with command events
csCommandLineHelperThis class can be used to help parsing the commandline
csCommandLineOptionRepresentation of a commandline option
csCommandLineParserUtility class that makes it easier to parse the command line
csCommonImageFileA base class for image loader plugin iImage implementations
csCommonImageFile::LoaderJob
csCommonImageFileLoaderBase image loader implementation
csComparator< T1, T2 >A template providing various comparison and ordering functions
csComparator< const char *, const char * >CsComparator<> specialization for strings that uses strcmp()
csComparator< csBitArray, csBitArray >CsComparator<> specialization for csBitArray to allow its use as e.g
csComparator< csInputDefinition, csInputDefinition >CsComparator<> specialization for csInputDefinition to allow its use as e.g
csComparator< csString, csString >CsComparator<> specialization for csString that uses strcmp()
csComparator< csStringBase, csStringBase >
csComparator< csStrKey, csStrKey >CsComparator<> specialization for csStrKey that uses strcmp()
csComparatorString< T >Template that can be used as a base class for comparators for string types
csComparatorStruct< T >Template that can be used as a base class for comparators for POD (plain old data) types
csCompressVertexThis structure is used by csVector3Array::CompressVertices()
csConditionA condition object
csConfigAccessThis is a simple convenience class that can be used to deal with the sytem config manager
csConfigDocumentIConfigFile implementation for configurations stored in documents
csConfigFileConfiguration file which implements the iConfigFile SCF interface
csConfigManagerA configuration manager makes a number of individual iConfigFile objects appear to be a single configuration object
csCoreRenderMeshData required by the renderer to draw a mesh
csCoverageTileCoverage tile
csCtoWHelper class to convert char* (UTF-8 encoded )to wchar_t* strings for use as function parameters
csCubicSplineA cubic spline
csCursorConverterHelper class to convert images into data formats suitable for mouse cursor creation on various platforms and toolkits
csDataBufferThis is a implementation of iDataBuffer interface
csDataStreamThis class can be used as a wrapper around a data buffer for easy stream-like access
csDebuggingGraphThis is a static class that helps with debugging
csDebugImageWriterHelper class allowing in debug builds for to quickly dump an iImage object onto disk for visual inspection
csDIntersect3Some functions to perform various intersection calculations with 3D line segments
csDirectionalLightProc< AttenuationProc >Preform directional light lighting calculation without shadowing
csDirtyAccessArray< T >A templated array class
csDMath3Various assorted 3D mathematical functions
csDMatrix3A 3x3 matrix
csDocumentAttributeCommonPartial iDocumentAttribute implementation with commonly duplicated logic
csDocumentNodeCommonPartial iDocumentNode implementation with commonly duplicated logic
csDocumentNodeReadOnlyPartial iDocumentNode implementation with commonly duplicated logic and dummy implementations for manipulation methods
csDPlaneA plane in 3D space
csDSquaredDistSome functions to perform squared distance calculations
csDVector3A 3D vector
csDVector4A 4D vector with "double" components
csEllipsoidThis class represents an ellipsoid
csEmptyDocumentAttributeIteratorDocument attribute iterator does not return any attributes
csEmptyDocumentNodeIteratorDocument node iterator does not return any nodes
csEndianSwap4
csEndianSwap8
csEngineToolsThis is a class with static helper functions for working on engine data
csEventThis class represents a system event
csEventAttributeIterator
csEventCordEvent cord
csEventCord::PluginData
csEventFlattenerStandard event flattener(also known as serializer)
csEventOutletA class which implements the iEventOutlet interface
csEventQueueThis class represents a general event queue
csEventTimerThis class implements a timer
csFIFO< T, ElementHandler, MemoryAllocator >A FIFO implemented on top of csArray<>, but faster than using just a single array
csFileTimeFile time structure - used to query and set the last-modification time of a file
csFlagsSet of flags which can be accessed through masks
csFmtDefaultReader< T >Standard format string source for csPrintfFormatter
csFmtDefaultWriter< T >Standard formatted string destination for csPrintfFormatter
csFogFog structure
csFogInfoInformation for vertex based fog
csFogMathFog math utilities
csFoliageVertexVertex data for the foliage mesh
csFontCacheA cache for font glyphs
csFontCache::FontDeleteNotifyFont deletion callback
csFontCache::GlyphCacheDataSome basic data associated with a glyph
csFontCache::KnownFontA font known to the cache
csFontCache::LRUEntryAn entry in the LRU list
csFontCache::PlaneGlyphElementHandler
csFontCache::PlaneGlyphsArray of a number of glyphs
csFrameDataHolder< T >Helper template to retrieve an instance of some type that has not yet been used in a frame
csFrustumA general frustum
csFrustumContextThis structure keeps track of the current frustum context
csG2DDrawBox< Tpixel, Tpixmixer >Draw a box to a (software) canvas
csG2DDrawLine< Tpixel, Tpixmixer >Class to draw a line
csG2DDrawText< Tpixel, Tpixmixer1, Tpixmixer2, Tpixmixer3 >Class to write some text
csGenerateImageThis class will compute a texture for a terrain
csGenerateImageLayerThis class is used to store the layers of textures per value
csGenerateImageTextureA base class which represents a texture that can be displayed on the terrain
csGenerateImageTextureBlendClass for a texture that is made by blending together other textures based on a value
csGenerateImageTextureSingleA class for a single texture
csGenerateImageTextureSolidA class for a solid coloured texture
csGenerateImageValueA base class which represents a value that can be computed for blending purposes for each pixel
csGenerateImageValueFuncThis class will generate a value using a given function
csGenerateImageValueFuncConstThis class will generate a constant value
csGenerateImageValueFuncTexThis class will generate a value using a texture
csGeomDebugHelperThis is a class that does unit testing (and other debug stuff) for most of csgeom classes
csGLDriverDatabase
csGLExtensionFlagsStruct containing all GL extension test flags
csGLExtensionFunctionsStruct containing all GL extension functions
csGLExtensionManagerGL extensions manager
csGLFontCache
csGLScreenShot
csGLStateCacheSince this class is passed directly between plugins the code in this class cannot do memory allocations or deallocations
csGLStateCacheContext
csGlyphMetricsMetrics for a glyph that are independent from whether a simple or antialiased image is used
csGradientA simple color gradient
csGradientShadeAn entry in a csGradient gradient
csGraphics2DThis is the base class for 2D canvases
csGraphics2D::EventHandler
csGraphics2DGLCommonBasic OpenGL version of the 2D driver class You can look at the openGLX graphics class as an example of how to inherit and use this class
csGraphics2DGLCommon::csGLPixelFormatPicker
csGraphics3DCapsInformation about 3d renderer capabilities
csHash< T, K >A generic hash table class, which grows dynamically and whose buckets are unsorted arrays
csHash< T, K >::Element
csHash< T, K >::GlobalIteratorAn iterator class for the hash
csHash< T, K >::IteratorAn iterator class for the hash
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< double >
csHashComputer< float >
csHashComputer< int >
csHashComputer< long >
csHashComputer< longlong >
csHashComputer< ulonglong >
csHashComputer< unsigned int >
csHashComputer< unsigned long >
csHashComputer< void * >CsHashComputer<> specialization for an integral type
csHashComputerIntegral< T >Template for hash value computing, suitable for integral types and types that can be casted to such
csHashComputerString< T >Template that can be used as a base class for hash computers for string types (must support cast to const char*)
csHashComputerStruct< T >Template that can be used as a base class for hash computers for POD structs
csHashReversible< T, K >A csHash<> that maintains a reverse hash for indexing keys by values
csHitBeamResultReturn structure for the iMeshWrapper->HitBeam() routines
csIdentStringsHelper class that contains a list of identifiers and their names
csIdentStrings::csIdentString
csImageAreaThis structure is used for saving/restoring areas of screen
csImageBaseBase class for iImage implementations
csImageCubeMapMakerWrapper class to create a cube map from a number of 2D images as the cube faces
csImageIOFileFormatDescriptionDescription for a file format supported by an image loader
csImageLoaderOptionsParserHelper class to parse options strings passed to iImageIO::Save()
csImageManipulateHelper class to manipulate iImage objects
csImageMemoryMemory image
csImageToolsSome helper functions to deal with iImage objects
csImageVector
csImageVolumeMakerWrapper class to create a volume aka 3D texture from a number of 2D images as the volume slices
csInitializerThis class contains several static member functions that can help setup an application
csInputBinderUse this class to bind input events (keypress, button press, mouse move, etc
csInputBinder::eiEventHandler
csInputDefinitionThis class holds a description of a physical source of input events, such as a keyboard key, mouse or joystick button, or a mouse or joystick axis
csInputDriverSuperclass of all the generic input drivers
csInstallationPathsHelperA helper class containing a number of functions to deal with Crystal Space installation paths
csInterleavedSubBufferOptionsStructure describing the properties of the individual buffers to be interleaved
csIntersect2Some functions to perform various intersection calculations with 2D line segments
csIntersect3Some functions to perform various intersection calculations with 3D line segments
csIntersectingTriangleAn intersection triangle for CollideRay
csInverseAttenuationInverse linear attenuation
csJoystickDriverGeneric Joystick driver
csJoystickDriver::eiEventHandlerIEventHandler implementation
csJoystickEventDataStructure that collects the data a joystick event carries
csJoystickEventHelperHelper class to conveniently deal with joystick events
csKDTreeA KD-tree
csKDTreeChildA child in the KD-tree (usually some object)
csKeyboardDriverGeneric Keyboard Driver
csKeyboardDriver::eiEventHandlerIEventHandler implementation
csKeyComposer
csKeyEventDataStructure that collects the data a keyboard event carries
csKeyEventHelperHelper class to conveniently deal with keyboard events
csKeyValuePairA Key Value pair
csLightPropertiesLight properties, as needed by the attenuation and lighting functors
csLightShaderVarCacheHelper to cache names of shader variables relevant to lighting
csLinearAttenuationLinear attenuation
csLineOperation
csList< T >A lightweight double-linked list template
csList< T >::csListElementTemplate which describes the data stored in the linked list For example a list of ints uses csListElement<int>
csList< T >::IteratorIterator for the list
csMapNodeA node
csMath2Various functions in 2D, such as 2D vector functions
csMath3Various assorted 3D mathematical functions
csMatrix2A 2x2 matrix
csMatrix3A 3x3 matrix
csMD5This is an encapsulation of a C-implementation of MD5 digest algorithm by Peter Deutsch <ghost@aladdin.com>
csMD5::DigestAn MD5 digest is 16 unsigned characters (not 0-terminated)
csMD5::md5_state_t
csMemFileEssentially a raw memory buffer which implements the abstract iFile interface
csMemoryMappedIODefines a simple memory-mapped IO class that is portable
csMemoryMappingMemory mapping, as returned by csMemoryMappedIO::GetData()
csMemoryPoolA quick-allocation pool for storage of arbitrary data
csMeshedPolygonA polygon
csMeshFactoryThis is the abstract implementation of iMeshObjectFactory
csMeshObjectThis is an abstract implementation of iMeshObject
csMeshObject::eiObjectModel
csMeshTypeThis is the abstract implementation of iMeshObjectType
csMeshType::eiComponentIComponent implementation
csModelConverterFormatStructure describing a single format supported by a model converter
csModelData
csModelDataActionDocument me!@@
csModelDataCameraDocument me!@@
csModelDataLightDocument me!@@
csModelDataMaterialDocument me!@@
csModelDataObjectDocument me!@@
csModelDataPolygonDocument me!@@
csModelDataTextureDocument me!@@
csModelDataToolsA set of utility functions to deal with model data components
csModelDataVertexMapMapping table, used by csModelDataTools::CopyVerticesMapped()
csModelDataVerticesDocument me!@@
csMouseDriverGeneric Mouse Driver
csMouseDriver::eiEventHandlerIEventHandler implementation
csMouseEventDataStructure that collects the data a mouse event carries
csMouseEventHelperHelper class to conveniently deal with mouse events
csMutexA mutual-exclusion object
csNewParticleSystemThis is an abstract implementation of a particle system mesh object
csNewParticleSystem::eiParticleState
csNewParticleSystem::PerFrameData
csNewtonianParticleSystemThis class has a set of particles that behave with phsyics
csNoAttenuationNo attenuation
csNodeIteratorA node iterator
csNormalizationCubeAccessorShader variable accessor for a normalization cubemap
csNormalMappingToolsSome helpers for stuff related to normal maps
csNullCacheManagerThis is a general cache that doesn't cache anything at all
csOBBOriented bounding box (OBB)
csOBBFrozenVersion of the csOBB with frozen corners (for optimization purposes)
csObjectA generic csObject class
csObjectModelHelper class to make it easier to implement iObjectModel in mesh objects
csObjectRegistryThis is an implementation of iObjectRegistry
csOptionDescriptionConfiguration option description
csOrthoTransformA class which defines a reversible transformation from one coordinate system to another by maintaining an inverse transformation matrix
csPackRGBRGB data packing
csPackRGBARGBA data packing
csParasiticDataBufferA databuffer pointing into another databuffer
csParasiticDataBufferBase
csParasiticDataBufferPooledA databuffer pointing into another databuffer, pooled version
csParticlesDataRepresentational information of a particle
csParticleSystemThis class represents a particle system
csParticleSystem::ObjectModel
csParticleSystem::ParticleState
csParticleSystem::PerFrameData
csPathA path in 3D
csPathsListClass to manage a list of paths
csPathsList::EntryThis structure contains information about a plugin path
csPathsUtilitiesA helper class with path-related utilities
csPDelArray< T >An array of pointers
csPDelArrayElementHandler< T >
csPenA pen specialized for CS
csPhysicalFileAn implementation of the abstract iFile interface for real files within the physical filesystem
csPixelCoordSimple 2D pixel coordinate
csPixelFormatStructure describing the pixel format
csPixmapThis class is an simple set of inline routines good as an abstraction for simple 2D sprites
csPixMixerCopy< Tpixel >PixMixer that ignores alpha
csPixMixerNoop< Tpixel >PixMixer that doesn't do anything
csPixMixerRGBA< Tpixel >PixMixer that mixes the pixel into the background with alpha
csPlane2A plane in 2D space
csPlane3A plane in 3D space
csPlatformMemoryMappingDummyMemory mapping for platforms without memory mapping support - it does nothing, so the software emulation kicks in when csMemoryMappedIO is used
csPlatformMemoryMappingDummy::PlatformMemoryMapping
csPlatformMemoryMappingPosixMemory mapping for platforms with POSIX mmap() support
csPlatformMemoryMappingPosix::PlatformMemoryMapping
csPlatformMemoryMappingWin32Memory mapping for Win32
csPlatformMemoryMappingWin32::PlatformMemoryMapping
csPluginList
csPluginLoaderThis utility class helps to load plugins based on request, config file, and commandline
csPluginLoadRec
csPluginManagerThis is the standard implementation of the plugin manager
csPluginRequestThis class represents a single plugin request for csInitializer::RequestPlugins()
csPointLightProc< AttenuationProc >Preform pointlight lighting calculation without shadowing
csPoly2DThe following class represents a general 2D polygon
csPoly2DEdgesThe following class represents a general 2D polygon represented with edges instead of vertices
csPoly2DEdgesPoolThis is an object pool which holds objects of type csPoly2DEdges
csPoly2DFactoryThis factory is responsible for creating csPoly2D objects or subclasses of csPoly2D
csPoly2DPoolThis is an object pool which holds objects of type csPoly2D
csPoly3DThe following class represents a general 3D polygon
csPolygonClipperCan be used for clipping any polygon against any other convex polygon
csPolygonMeshA convenience polygon mesh implementation that you can feed with vertices and polygons from another source
csPolygonMeshBoxA convenience polygon mesh implementation that represents a cube
csPolygonMeshEdgeA definition of one edge
csPolygonMeshToolsA set of tools to work with iPolygonMesh instances
csPolygonRangeA range structure for specifing polygon ranges
csPolygonRenderDataThis structure is used for communicating polygon information to the polygon renderer
csPolyIndexedThe following class represents a general polygon
csPolyTextureMappingThis structure holds mapping information to map the texture and lightmap on a polygon
csPoolEventThis class is a system event designed for the pool system
csPrefixConfigThis is an implementation of iConfigFile that stores an ID string at construction, which it then prepends to all config keys on read/write operations
csPrintfFormatter< Twriter, Treader >Templated class for printf()-style string formatting
csProcAnimatedA procedural texture for animated images
csProcessorCapabilityThis class is used to identify capabilities in the processor such as support for MMX and SSE
csProcTextureGeneric superclass for procedural textures
csProcTexture::eiProcTexture
csProcTexture::eiTextureWrapper
csProgressPulseSimple 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
csQuaternionClass for a quaternion
csRadixSorterAn in-place radix-sorter for a raw array of 32-bit unsigned integers
csRandomFloatGenFast simple random number generator for a floating point values
csRandomGenPortable random number generator class
csRealisticAttenuationInverse quadratic attenuation
csRectRectangle class: simple class for manipulating 2D rectangles
csRectRegionA rect region is a class that implements splittable 2d rectangles
csRedBlackTree< K >A red-black-tree
csRedBlackTree< K >::NodeA node in the tree
csRedBlackTreeMap< K, T >Key-value-map, backed by csRedBlackTree
csRedBlackTreePayload< K, T >Helper template to allow storage of a payload together with a key in a csRedBlackTree
csRef< T >A smart pointer
csRefArray< T >An array of smart pointers
csRefArrayElementHandler< T >
csRefArrayObject< T >This class implements a typed array that correctly keeps track of reference count and also is able to find by name
csRefCountThis is a class which provides basic reference-counting semantics
csRefTrackerAccessHelper to facilitate access to the global reference tracker
csRegExpMatchInformation about (sub)expression matches
csRegExpMatcherMatcher for regular expressions
csRenderBufferBasic renderbuffer for OpenGL renderer
csRenderBufferHolderHolder of standard renderbuffers
csRenderBufferLock< T >Helper class for convenient locking/unlocking of an iRenderBuffer
csRenderContextThis structure keeps track of the current render context
csRenderMeshMesh data as returned by mesh plugins
csRenderMeshHolderHelper class to retrieve an unused csRenderMesh
csRenderMeshListThis class is used when we need to store, sort and then render a list of rendermeshes
csRenderMeshModesMesh render mode information
csRenderStepParser
csReporterHelperHelper class for csReport()
csReversibleTransformA class which defines a reversible transformation from one coordinate system to another by maintaining an inverse transformation matrix
csRGBcolorAn RGB color
csRGBpixelAn RGB pixel
csRGBVectorThis is a vector class that expects you to push csRGBcolor structs onto it
csRunnableAbstract interface for objects which can be run in a thread
csSafeCopyArray< T >Convenience class to make a version of csArray<> that does a safe-copy in case of reallocation of the array
csSafeCopyArrayMemoryAllocator< T, ElementHandler >Special allocator for csArray that makes sure that when the array is reallocated that the objects are properly constructed and destructed at their new position
csScfStringSetThe string set is a collection of unique strings
csScheduleEasy way to get timers in applications
csScopedMutexLockThis is a utility class for locking a Mutex
csScreenBoxResultReturn structure for iMeshWrapper->GetScreenBoundingBox()
csScreenShotSimple iImage implementation for canvas screenshots
csSegment2A 2D line segment
csSegment3A 3D line segment
csSemaphoreA semaphore object
csSequenceOp
csSet< T >This class implements a basic set for objects
csSet< T >::GlobalIteratorAn iterator class for the set
csShaderExpressionAn evaluable expression attached to a shader variable
csShaderExpression::oper
csShaderExpression::oper_arg
csShaderExpressionAccessorShader variable accessor that evaluates a shader expression when the SV value is queried
csShaderMetadataShader metadata
csShaderProgramBaseclass for iShaderProgram plugins
csShaderProgram::ProgramParamProgram parameter, either a SV reference or a const value
csShaderProgram::VariableMapEntryHolder of variable mapping
csShaderVarBlockAllocA block allocator for shader variables
csShaderVariableStorage class for "shader vars", inheritable variables in the shader system
csShaderVariableContextSimple implementation for iShaderVariableContext
csShaderVariableFrameHolderHelper class to obtain a shader variable that was guaranteedly not used in a frame yet
csShaderVarMapping
csSimplePixmapThis is the simple implementation of csPixmap that uses a single texture
csSimpleRenderMeshA simple render mesh
csSingleIndexVertexSetThis class can be used to construct objects which use a single index for vertex
csSndFunc
csSoftFontCacheFont cache base class for software canvases
csSoftFontCache::SoftGlyphCacheData
csSoftFontCacheImpl< Tpixel, Tpixmixer >An actual implementation of a font cache for software canvases
csSolidSpaceThis structure keeps track of solid space
csSoundDataRaw
csSoundFormatThe sound format
csSoundHandle
csSoundListener
csSoundWrapperDocument me and possible move me to some sound manager! @@
csSoundWrapper::SoundWrapper
csSparse3DGeneral 3D sparse matrix class
csSphereThis class represents a sphere
csSplineA spline superclass
csSpotLightProc< AttenuationProc >Perform spotlight lighting calculation without shadowing
csSprite2DVertexA single 2D Sprite vertex
csSpriteBuilderThis is a generic sprite builder interface
csSpriteBuilderFileThis sprite builder writes the data to a buffer
csSpriteBuilderMeshThis sprite builder takes a sprite factory and adds the input information
csSpriteCal3DActiveAnim
csSquaredDistSome functions to perform squared distance calculations
csStreamDescriptionStream description structure
csStringThin wrapper around csStringFast<> with its default buffer size
csStringArrayAn array of strings
csStringArrayElementHandler
csStringBaseThis is a string class with a range of useful operators and type-safe overloads
csStringFast< LEN >Subclass of csStringBase that contains an internal buffer which is faster than the always dynamically allocated buffer of csStringBase
csStringFast< 0 >
csStringHashA string-to-ID hash table
csStringReaderThis is a convenience class that reads an input buffer line by line
csStringSetThe string set is a collection of unique strings
csStrKeyThis is a simple helper class to make a copy of a const char*
csSubRectanglesA class managing allocations of sub-rectangles
csSubRectangles::SubRectSub-rectangle
csSubRectangles::SubRect::AllocInfo
csTestRectDataA structure used by TestRectangle() and initialized by PrepareTestRectangle()
csTextProgressMeterDisplays a simple percentage-style textual progress meter
csTextureA simple texture
csTextureHandleThis class is the top-level representation of a texture
csTextureManagerGeneral version of the texture manager
csTextureTransThis is a static class which encapsulates a few functions that can transform texture information into a texture matrix/vector
csThreadRepresentation of a thread of executation
csThreadJobQueueIJobQueue implementation that lets the jobs run in a thread
csTiledCoverageBufferThe tiled coverage Buffer
csTinyDocumentSystemThis is an SCF compatible wrapper for the TinyXml parser in csutil
csTraceBeamResultReturn structure for the csColliderHelper::TraceBeam() method
csTransformA class which defines a transformation from one coordinate system to another
csTree< T >A generic binary search tree
csTriangleA triangle
csTriangleLODAlgoAlgorithm class that calculates the cost of a vertex
csTriangleLODAlgoEdgeThis subclass of csTriangleLODAlgo uses a very simple cost metric to calculate the vertex cost
csTriangleMeshA mesh of triangles
csTriangleMeshLODA static class which performs the calculation of the best order to do the collapsing
csTriangleMinMaxA triangle with minimum/maximum information on x
csTriangleVertexThe representation of a vertex in a triangle mesh
csTriangleVertexCostThe representation of a vertex in a triangle mesh
csTriangleVerticesA class which holds vertices and connectivity information for a triangle mesh
csTriangleVerticesCostA class which holds vertices and connectivity information for a triangle mesh
csTriangleVerticesSortedThis class works closely with csTriangleVerticesCost and maintains a sorted (on cost) view of the vertices
csTypedObjectIterator< T >Typed object iterator class
csUnicodeTransformContains functions to convert between several UTF encodings
csUserRenderBufferManagerHelper class to manage multiple render buffers, usually provided by the user
csVariantVariant, means that type of contained data is set at runtime
csVector2A 2D vector
csVector3A 3D vector
csVector3ArrayThis is actually the same class as csPoly3D
csVector4A 4D vector with "float" components
csVerbosityManagerDefault iVerbosityManager implementation
csVerbosityParserUtility for parsing verbosity flags such as those provided by the --verbose=flags command-line option
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< T >Helper class to make it easier to access single elements from renderbuffers (with stride)
csVertexStatusThe clipper can output additional information about each vertex in output polygon
csVfsCacheManagerThis is a general cache that can cache data on VFS
csVfsDirectoryChangerHelper class to change the current VFS directory and restore the previous directory when an instance goes out of scope
csVideoPreferencesThis class is a video preference editor
csVideoStreamDescriptionVideo stream description structure
csViewEncapsulates the top-level Crystal Space renderer interface
csVirtualClockThis is an implementation of a virtual clock
csWeakRef< T >A weak reference
csWeakRefArray< T >An array of weak references
csWideSparse3DThis implementation of csSparse3D is very suited where the accesses will be very widely spaced (for example: one element at (-1000,0,0) and one at (1000,0,0))
csWin32CustomCursors
csWin32RegistryConfigAn iConfigFile, storing the settings in the Windows registry
csWin32RegistryIteratorIterates over a registry key subkeys and values
cswinCallStackHelperCall stack creation helper (Win32-specific)
cswinCtoASmall helper to convert an UTF-8 to an ANSI string, useful when passing arguments to a function
cswinMinidumpWriterHelper to write minidumps on Win32
cswinWtoASmall helper to convert a wide to an ANSI string, useful when passing arguments to a function
csWtoCHelper class to convert wchar_t* to char* (UTF-8 encoded) strings for use as function parameters
csXRotMatrix3An instance of csMatrix3 that is initialized as a rotation about X
csXScaleMatrix3An instance of csMatrix3 that is initialized to scale the X dimension
csYRotMatrix3An instance of csMatrix3 that is initialized as a rotation about Y
csYScaleMatrix3An instance of csMatrix3 that is initialized to scale the Y dimension
csZRotMatrix3An instance of csMatrix3 that is initialized as a rotation about Z
csZScaleMatrix3An instance of csMatrix3 that is initialized to scale the Z dimension
DirectDetection
DirectDetectionDeviceDescription of DirectDraw device
dirent
CrystalSpace::DocumentHelper::Implementation::FilterDocumentNodeIterator< T >Filtering iDocumentNodeIterator
getopt_optionDescribe the long-named options requested by the application
iAnimatedImageIf an image file has animation capabilities, this interface is exhibited
iAnimTimeUpdateHandlerBy default, csSpriteCal3DMeshObject::Advance() updates the model's via CalModel::update() with the elapsed time since the last advancement
iAudioStreamAn audio stream
iAwsInterface for the window manager
iAwsCanvasProvider for AWS 2D / 3D Driver
iAwsComponentInterface that is the base of ALL components
iAwsComponentFactoryInterface for component factories
iAwsComponentNodeDocument me!@@
iAwsConnectionKeyDocument me!@@
iAwsConnectionNodeFactoryInterface for connection node factories
iAwsDockableWindowDocument me! @@
iAwsDockSiteDocument me! @@
iAwsFloatKeyDocument me!@@
iAwsIntKeyDocument me!@@
iAwsKeyDocument me!@@
iAwsKeyContainerDocument me!@@
iAwsKeyFactoryInterface for key factories
iAwsLayoutManagerDocument me!@@
iAwsParmListProvides support for safely passing named parameters through to different functions in a portable manner
iAwsPointKeyDocument me!@@
iAwsPrefManagerInterface for the preferences manager (window manager needs one.)
iAwsRectKeyDocument me!@@
iAwsRGBKeyDocument me!@@
iAwsRGBKey::RGB
iAwsSinkInterface for sinks
iAwsSinkManagerInterface for the sink manager
iAwsSlotInterface for signal slots (conduits)
iAwsSourceInterface for signal sources
iAwsStringKeyDocument me!@@
iAwsWindow
iBallStateThis interface describes the API for the ball mesh object
iBaseThis is the basic interface: all other interfaces should be derived from this one, this will allow us to always use at least some minimal functionality given any interface pointer
iBaseHaloThis is the basic interface for all types of halos
iBezierFactoryStateThis is the state interface to access the internals of a bezier mesh factory
iBezierStateThis is the state interface to access the internals of a thing mesh object
iBinaryLoaderPluginThis is a binary plugin for the loader
iBinarySaverPluginThis is a binary plugin to save with
iBodyGroupBody Group is a collection of bodies which don't collide with each other
iBugPlugUsing this interface you can communicate with the BugPlug plugin
iBugPlugRenderObjectAn application/module can implement this interface to render something
iCacheManagerA generic cache system
iCameraCamera class
iCameraPositionA camera position
iCameraPositionListA list of camera position objects
iCameraSectorListenerImplement this interface if you are interested in learning when the camera changes sector
iClipper2DThis interfaces represents a 2D clipper for polygons
iCollectionA collection object is for convenience of the script language
iCollectionListICollection list
iColliderA mesh collider
iCollideSystemThis is the Collide plug-in
iCommandLineParserA utility class that makes it easier to parse the command line
iComponentThis interface describes a generic component in Crystal Space
iConfigFileConfiguration file interface
iConfigIteratorIterator which allows sequential access to configuration information contained in an iConfigFile object
iConfigManagerThe configuration manager is used to make a number of iConfigFile object appear like a single object
iConsoleExecCallbackCommand execution callback
iConsoleInputThis is a plugin that can handle keyboard input and display it on an associated console
iConsoleOutputThis is the Crystal Space Console interface
iConsoleWatcherThis interface is implemented by objects interested in knowing when the console's visibility status has changed
iCrossBuilderThe crossbuilder can be used to build things and sprite factories from single objects of imported model files (iModelDataObject)
iCrossHaloThis is a halo which resembles a cross
iCursorThis interface is used to access the custom cursor plugin, which handles processing for displaying pixmaps as cursors
iCurveThis is the interface for a curve
iDataBufferThe iDataBuffer interface can be used to exchange buffers with abstract data between plugins
iDebugHelperSome object that wants to implement unit testing, debugging and/or benchmarking can implement this interface
iDocumentRepresentation of a document containing a hierarchical structure of nodes
iDocumentAttributeAn attribute for an iDocumentNode
iDocumentAttributeIteratorAn iterator over iDocumentNode attributes
iDocumentNodeRepresentation of a node in a document
iDocumentNodeIteratorAn iterator over iDocumentNode
iDocumentSystemAn iDocument factory
iDynamicsThis is the interface for the actual plugin
iDynamicsCollisionCallbackThis is the interface for attaching a collider callback to the body
iDynamicsMoveCallbackThis is the interface for a dynamics move callback
iDynamicsSystemColliderThis is the interface for a dynamics system collider
iDynamicSystemThis is the interface for the dynamics core
iEmitBoxBox value emitter - returns points in an (axis aligned) box
iEmitConeCone value emitter - returns points in a cone
iEmitCylinderCylinder value emitter - returns values in a cylinder
iEmitCylinderTangentCylinder tangential value emitter - gives direction tangential to cylinder Uses the given point, gives a tangential direction for that
iEmitFactoryStateThis interface describes the API for the emitter mesh factory object
iEmitFixedFixed value emitter - returns a particular point value
iEmitGen3DThis interface is for objects that can generate 3d vectors, which are used for emitting
iEmitLineLine value emitter - returns values on the line between start and end
iEmitMixMix value emitter - returns a weighted random mix of other emitters
iEmitSphereSphere value emitter - returns points in a sphere
iEmitSphereTangentSphere tangential value emitter - gives direction tangential to sphere Uses the given point, gives a tangential direction for that
iEmitStateThis interface describes the API for the emitter mesh object
iEngineThis interface is the main interface to the 3D engine
iEngineSectorCallbackA callback that will be fired whenever a sector is created or removed from the engine
iEngineSequenceManagerSequence manager specifically designed for working on the engine
iEngineSequenceParametersAn interface for passing on parameters to the engine sequence manager
iEventThis interface describes any system event
iEventAttributeIteratorEvent attribute iterator
iEventCordThe iEventCord is an interface provided by an event queue to any event handlers wanting to receive some subclasses of events ASAP in a specified priority, bypassing the queue itself
iEventHandlerThis interface describes an entity that can receive events
iEventOutletThe iEventOutlet is the interface to an object that is provided by an event queue to every event plug when it registers itself
iEventPlugEvent plug interface, also referred as "event source"
iEventQueueThis interface represents a general event queue
iEventTimerA timer
iExplosionStateThis interface describes the API for the explosion mesh object
iFactoryIFactory is an interface that is used to create instances of shared classes
iFileA replacement for FILE type in the virtual file space
iFireStateThis interface describes the API for the fire mesh object
iFireTextureInterface to the 'fire' procedural texture
iFlareHaloThis is a halo which resembles a (solar) flare
iFoliageFactoryStateThe foliage mesh can be used to make foliage (plants, boulders,
iFoliageGeometryGeometrical data for the foliage object
iFoliageMeshStateThis interface describes the API for the foliage mesh object
iFoliageObjectA representation of an object in the foliage mesh
iFontA font object
iFontDeleteNotifyCalled before a font is deleted
iFontServerA font server interface
iFountainStateThis interface describes the API for the fountain mesh object
iFrustumViewThis structure represents all information needed for the frustum visibility calculator
iFrustumViewUserdataUser data which can be attached to iFrustumView
iGeneralFactoryStateThis interface describes the API for the general mesh factory
iGeneralMeshCommonStateThe common interface between genmesh meshes and factories
iGeneralMeshStateThis interface describes the API for the general mesh object
iGenerateImageFunctionThis class represents a function for csGenerateImageValueFunc
iGenericRenderStepA generic render step
iGenMeshAnimationControlImplementing this class allows the creation of classes that control animation of vertex, texel, normal, and color data right before it is being used
iGenMeshAnimationControlFactoryThis class is a factory for creating animation controls
iGenMeshAnimationControlStateThis interface describes the API for setting up the animation control as implemented by the 'gmeshanim' plugin
iGenMeshAnimationControlTypeThis class is the animation control type
iGenMeshSkeletonBone
iGenMeshSkeletonBoneUpdateCallback
iGenMeshSkeletonControlFactory
iGenMeshSkeletonControlStateThis interface describes the API for setting up the skeleton animation control as implemented by the 'gmeshskelanim' plugin
iGenMeshSkeletonScript
iGLDriverDatabaseInterface to read custom GL driver databases
iGraphics2DThis is the interface for 2D renderer
iGraphics3DThis is the standard 3D graphics interface
iGraphicsMemoryThis is the interface used to access the csGraphicsMemory plugin
iHaloIHalo: used to render halos (aka "light globes")
iHazeFactoryStateThis interface describes the API for the sprite factory mesh object
iHazeHullA mesh specially meant for use by the haze
iHazeHullBoxA predefined hull
iHazeHullConeA predefined hull
iHazeHullCreationThis interface is implemented by the haze factory in order to be able to create the predefined haze hulls
iHazeStateThis interface describes the API for the sprite factory mesh object
iImageThe iImage interface is used to work with image objects
iImageFileLoaderAn image file loader
iImageIOThe iImageIO interface is used to save and load graphic files
iImageVector
iImposterIImposter defines the interface a mesh (or other) class must implement to be used as imposter mesh by the engine
iInputBinderSCF interface for csInputBinder, used to bind input events (keypress, button press, mouse move, etc
iJobA unit of work passed to iJobQueue
iJobQueueInterface to simple job management
iJointThis is the interface for a joint
iJoystickDriverGeneric Joystick driver
iKeyboardDriverGeneric Keyboard Driver
iKeyComposerKeyboard input handler
iKeyValuePairA Key Value pair
iLightThe iLight interface is the SCF interface for the csLight class
iLightCallbackSet a callback which is called when this light color is changed
iLightingInfoThis interface is implemented by mesh objects that have some kind of lighting system
iLightingManager
iLightingProcessDataThe iLightingProcessData interface can be implemented by a mesh object so that it can attach additional information for the lighting process
iLightingProcessInfoThe iLightingProcessInfo interface holds information for the lighting system
iLightIteratorIterator to iterate over all static lights in the engine
iLightIterRenderStepDocument me!@@
iLightListThis structure represents a list of lights
iLightManagerAn engine (3D or iso) can implement this interface for the benefit of mesh objects so that they can request lighting information from the engine
iLightningFactoryStateDocument me! @@
iLightningState
iLightRenderStepDocument me!@@
iLoaderThis interface represents the map loader
iLoaderContextThis interface gives the context for the loader
iLoaderPluginThis is a plugin for the loader based on document tree
iLoaderStatusAn object to query about the status of the threaded loader
iLODControlThe iLODControl interface represents an object that has controllable LOD features
IMAGEHLP_LINE64
IMAGEHLP_MODULE64
IMAGEHLP_STACK_FRAME
iMapNodeA node
iMaterialThis class represents a material as seen from the engine view
iMaterialEngineThis interface represents the engine part of the material definition
iMaterialListThis class represents a list of materials
iMaterialWrapperA material wrapper is an engine-level object that wraps around an actual material (iMaterial)
iMemoryTrackerThis interface is used with CS_MEMORY_TRACKER
iMeshDrawCallbackSet a callback which is called just before the object is drawn
iMeshFactoryListA list of mesh factories
iMeshFactoryWrapperA mesh factory wrapper is an engine-level object that wraps around a mesh object factory (iMeshObjectFactory)
iMeshListA list of meshes
iMeshObjectThis is a general mesh object that the engine can interact with
iMeshObjectDrawCallbackSet a callback which is called just before the object is drawn
iMeshObjectFactoryThis object is a factory which can generate mesh objects of a certain type
iMeshObjectTypeThis plugin describes a specific type of mesh objects
iMeshWrapperA mesh wrapper is an engine-level object that wraps around an actual mesh object (iMeshObject)
iMeshWrapperIteratorThis is an iterator mesh wrappers
iModelConverterModel converter
iModelDataThis structure represents a complete scene with objects, light sources, cameras etc
iModelDataActionAn action
iModelDataCameraA camera in the scene
iModelDataLightA light source in the scene
iModelDataMaterialThis structure contains the information about a material for an imported model
iModelDataObjectOne object in the scene
iModelDataPolygonOne polygon in a model
iModelDataTextureThis structure contains the information about a texture for an imported model
iModelDataVerticesA set of vertices, including position, normal, color and texture coordinates
iMouseDriverGeneric Mouse Driver
iMovableThis interface represents the position and orientation of an object relative to its parent (this is the transformation between local object space of the model and world space (i.e
iMovableListenerImplement this class if you're interested in hearing about movable changes
iMovieRecorderUsing this interface you can communicate with the MovieRecorder plugin
CrystalSpace::ImportKitCrystal Space Import Kit
CrystalSpace::ImportKit::ContainerContains multiple models
CrystalSpace::ImportKit::Container::MaterialA material for a mesh
CrystalSpace::ImportKit::Container::ModelA model
CrystalSpace::ImportKit::Container::Model::MeshModel mesh, contains actual geometry
iNativeWindowThis interface represents a native window
iNativeWindowManagerThis interface represents the native window manager system
iNovaHaloThis is a halo which resembles a nova
iNullFactoryStateThis interface describes the API for the null mesh object factory
iNullMeshStateThis interface describes the API for the null mesh object
aws::autom::iObjectBase class for all Keila objects
iObjectThis interface is an SCF interface for encapsulating csObject
iObjectIteratorThis is an iterator for child objects of a csObject
iObjectModelThis interface represents data related to some geometry in object space
iObjectModelListenerImplement this class if you're interested in hearing about when the object model changes
iObjectNameChangeListenerA callback that you can implement to get notified of name changes in an iObject
iObjectRegistryThis interface serves as a registry of other objects
iObjectRegistryIteratorUse an instance of this class to iterate over objects in the object registry
iObjectWatcherThis is a generic object watcher
iObjectWatcherListenerImplement this class if you're interested in hearing about object watcher events
iODEAMotorJointODE AMotor joint
iODEBallJointODE ball and socket joint (contrainted translation and free rotation)
iODEDynamicStateThis class exposes parameters specific to odedynam as an implementation of iDynamics
iODEDynamicSystemStateThis class exposes parameters specific to odedynam as an implementation of iDynamics
iODEFrameUpdateCallbackThis class can be passed in as a callback during the physics update it is only called if FrameRate is enabled
iODEGeneralJointStateGeneral joint state
iODEHingeJointODE hinge joint (contrainted translation and 1 free rotation axis)
iODEJointStateGeneral joint state
iODESliderJoint
iODEUniversalJointA universal joint is like a ball and socket joint that constrains an extra degree of rotational freedom
iOffscreenCanvasCallbackWhen you create an offscreen canvas (CreateOffscreenCanvas()) then you can use this callback to get informed when the texture has been modified (FinishDraw() called) or a palette entry is modified
iOpenGLInterfaceA common interface to be implemented by the platform specific opengl canvases
iOSXAssistantThis is an interface for an object which provides assistance to MacOS/X-specific canvases and Objective-C bridging code for application run-loop support
iParameterESMThis interface is a parameter resolver
iParticleA iParticle can be used in particle Systems
iParticlesColorCallbackParticles state can be set up to retrieve color via a callback
iParticlesFactoryStateParticles factory state
iParticlesObjectStateParticles state object
iParticlesPhysicsParticles physics interface
iParticlesStateBaseParticles shared state interface
iParticleStateThis interface describes the API for the particle mesh object
iPathA path in 3D
iPenA pen is used to draw vector shapes
iPluginConfigInterface to a configurator object
iPluginIteratorAn iterator to iterate over all plugins in the plugin manager
iPluginManagerThis is the plugin manager
iPolygonHandleThis is an interface that can be used to represent a polygon in situations where a SCF object is required
iPolygonMeshThis interface reprents a mesh of polygons
iPolygonRenderer
iPortalThis is the interface to the Portal objects
iPortalCallbackWhen a sector is missing this callback will be called
iPortalContainerA container for portals
iProcTexCallbackA callback for when a iTextureWrapper is used
iProcTextureInterface to a texture factory
iProgressMeterThis is a general interface for a progress meter
iProtoFactoryStateThe proto mesh is a demonstration or tutorial mesh
iProtoMeshStateThis interface describes the API for the proto mesh object
iPVSCullerThis interface is implemented by the PVS visibility culler
iRainStateThis interface describes the API for the rain mesh object
iRefTrackerThe reference tracker interface
iRegionA region
iRegionListA list of region objects
iRenderBufferThis is a general buffer
iRenderBufferAccessorInterface for renderbuffer accessor
iRendererLightmapA lightmap registered with a renderer
iRenderLoopRender loop
iRenderLoopManagerRender loop manager
iRenderStepDocument me!@@
iRenderStepContainerContainer for render steps
iRenderStepFactoryInterface to a render step factory
iRenderStepTypeRender step type
iRenderViewThis interface represents all information needed to render some object in a current draw context
iReporterThis is the interface for the error/message reporter plugin
iReporterIteratorAn iterator to iterate over all messages in the reporter
iReporterListenerImplement this interface if you're interested in hearing about new messages on the reporter
iRigidBodyThis is the interface for a rigid body
iSaverThis interface is used to serialize the engine contents
iSaverPluginThis is a plugin to save with
iSCFISCF is the interface that allows using SCF functions from shared classes
iScriptThis provides the interface to a scripting language interpreter
iScriptObjectThis provides the interface to an object in an object-oriented scripting language
iSectorThe iSector interface is used to work with "sectors"
iSectorCallbackSet a callback which is called when this sector is traversed
iSectorIteratorAn iterator to iterate over sectors
iSectorListA list of sectors
iSectorMeshCallbackSet a callback which is called when a mesh is added or removed from this sector
iSequenceA sequence of operations tagged with relative time information
iSequenceConditionA sequence condition
iSequenceManagerThe sequence manager
iSequenceOperationA sequence operation
iSequenceTimedOperationA timed operation for the engine sequence manager
iSequenceTriggerA sequence trigger
iSequenceWrapperA sequence wrapper
iShaderSpecific shader
iShaderCompilerCompiler of shaders
iShaderManagerA manager for all shaders
iShaderPriorityListA list of priorities as returned by iShaderCompiler->GetPriorities()
iShaderProgramA helper for shaders that which to use the general plugins
iShaderProgramPluginPlugins which provide iShaderProgram should implement this as a factory for iShaderProgram
iShaderRenderInterfaceDocument me!@@
iShaderTUResolverInterface to allow resolution of friendly TU names
iShaderVariableAccessorInterface to an accessorcallback for shadervariables
iShaderVariableContextThis is a baseclass for all interfaces which provides shadervariables both dynamically and static
iShadowBlockA block of shadows represent the shadows that are casted by one iShadowCaster object
iShadowBlockListThis is a list of shadow blocks
iShadowCasterAn object that can cast shadows
iShadowIteratorA shadow iterator allows someone to iterate over all shadows in a iShadowBlock or iShadowBlockList
iShadowReceiverAn object that is interested in getting shadow information
iSharedVariableISharedVariable implements a refcounted value which can be shared across many objects and updated efficiently
iSharedVariableListA list of shared variables
iSharedVariableListenerA listener so that you can get notified when a variable is changed
iSimpleFormerStateISimpleFormerState exposes implementation specific methods for the SimpleTerraformer plugin
iSnowStateThis interface describes the API for the snow mesh object
iSoundDataThe sound data is a template used to play sounds
iSoundDriverThis is the interface for the low-level, system-dependent sound driver that is used by the software sound renderer
iSoundHandleThe sound handle is a sound in the state that is needed by the sound renderer
iSoundListenerThe sound listener is a unique object created by the sound renderer
iSoundLoaderThe sound loader is used to load sound files given a raw input data stream
iSoundRenderThe sound renderer is used to play previously loaded sounds or music
iSoundSourceThe sound source is an instance of a sound
iSoundWrapperThis class is a csObject (iObject) wrapper for sound handles
iSpiralStateThis interface describes the API for the spiral mesh object
iSprite2DFactoryStateThis interface describes the API for the sprite factory mesh object
iSprite2DStateThis interface describes the API for the sprite factory mesh object
iSprite2DUVAnimationThe animation works by having all frames of an animation sequence in a texture at different (u,v) locations, hence the name
iSprite2DUVAnimationFrameThis is a single frame in a UV animation
iSprite3DFactoryStateThis interface describes the API for the 3D sprite factory mesh object
iSprite3DStateThis interface describes the API for the 3D sprite mesh object
iSpriteActionAn action frameset for 3D sprite animation
iSpriteCal3DFactoryStateThis interface describes the API for the 3D sprite factory mesh object
iSpriteCal3DSocketA socket for specifying where sprites can plug into other sprites
iSpriteCal3DStateThis interface describes the API for changing the Cal3D sprite mesh object's animations playing and other current traits
iSpriteFrameA frame for 3D sprite animation
iSpriteSocketA socket for specifying where sprites can plug into other sprites
iStandardReporterListenerInterface to control the settings of the reporter listener plugin
iStarsStateThis interface describes the API for the stars mesh object
iStaticPVSTreeThis interface allows someone to write the PVS data for the PVS visibility culler
iStreamA stream
iStreamFormatStream format
iStreamIterator
iStringThis is a SCF-compatible interface for csString
iStringArrayThis is an SCF-compatible interface for csStringArray
iStringSetThe string set is a collection of unique strings
iSuperLightmapA super light map
iSyntaxServiceThis component provides services for other loaders to easily parse properties of standard CS world syntax
iTerraFormerTerraFormer objects are used to retrieve terrain data
iTerrainFactoryStateAllows the setting of a set of generic terrain parameters outside any specific algorithm
iTerrainObjectStateThis will override the settings for material in the parent
iTerraSamplerTerraSampler objects are used for the actual queries of terrain data Sampler regions are requested from the iTerraFormer plugin, and sampled for data via the Sample methods
iTextureCallbackA callback for when a iTextureWrapper is used
iTextureFactoryInterface to a texture factory
iTextureHandleA texture handle as returned by iTextureManager
iTextureListThis class represents a list of texture wrappers
iTextureLoaderContextInterface passed to a texture loader, holding some common texture properties
iTextureManagerThis is the standard texture manager interface
iTextureTypeTexture type
iTextureWrapperA texture wrapper is an engine-level object that wraps around an actual texture (iTextureHandle)
iThingEnvironmentThis interface is implemented by the iObjectType for things
iThingFactoryStateThis is the state interface to access the internals of a thing mesh factory
iThingStateThis is the state interface to access the internals of a thing mesh object
iTimerEventA timer event
iUserRenderBufferIteratorInterface to iterate over all buffers stored in a csUserRenderBufferManager
iVerbosityManagerHelper interface which applications and plugins can use to determine whether they should be verbose
iVertexLightCalculatorInterface to calculate lighting for a number of vertices
iVFSThe Virtual Filesystem Class is intended to be the only way for Crystal Space engine to access the files
iVideoStreamA video stream
iViewEncapsulates the top-level Crystal Space renderer interface
iVirtualClockA virtual game clock
iVisibilityCullerThis interface represents a visibility culling system
iVisibilityCullerListenerImplement this interface when you want to get notified about visible objects detected by the visibility cullers
iVisibilityObjectAn object that wants to know if it is visible or not for some visibility culler needs to implement this interface
iVisibilityObjectIteratorIterator to iterate over some visibility objects
iVosA3DLThis is the initial component you retrieve from the registry to access the VOS A3DL plugin
iVosApi
iVosObject3DThis interface bridges between a VOS 3D object and the Crystal Space mesh wrapper created for that object
iVosSectorThis interface bridges between a VOS sector and a Crystal Space sector
iWin32AssistantThis interface describes actions specific to the Windows platform
iWxWindow
KDHELP64
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
CrystalSpace::DocumentHelper::NodeAttributeCompareNode comparator
CrystalSpace::DocumentHelper::NodeAttributeRegexpTestCheck if a regular expression matches(case-insensitive) with the value of the given attribute
CrystalSpace::DocumentHelper::NodeAttributeValueTestCompare (case-sensitive) node attribute to given
CrystalSpace::DocumentHelper::NodeNameCompareNode comparator
CrystalSpace::DocumentHelper::NodeValueTestCompare (case-sensitive) node value to given
OSXDelegate2D
OSXView
OSXWindow
SCF_IMPL_NAME< Class, >
scfFakeInterface< If >Fugly helper to resolve some bad situations
scfFakeInterface< If >::InterfaceTraits
scfImplementation< Class >Baseclass for the SCF implementation templates
scfInterfaceTraits< Interface >Interface information query class
scfStringThis is a thin SCF wrapper around csString
scfStringArrayThis class is a thin wrapper around csStringArray with SCF capability
STACKFRAME64
SYMBOL_INFO
ZIP_central_directory_file_header
ZIP_end_central_dir_record
ZIP_local_file_header

Generated for Crystal Space by doxygen 1.4.4