BlackTopp Studios inc
BlackTopp Studios| ►NMezzanine | The bulk of the engine components go in this namspace |
| ►NAudio | This namespace is for all the classes belonging to the Audio Subsystem |
| CAudioManager | This is the base manager class for the Audio subsystem and it's operations |
| CAutowahParameters | This is a struct containing all the parameters needed to describe an Auto-Wah effect |
| CChorusParameters | This is a struct containing all the parameters needed to describe a Chorus effect |
| CCompressorParameters | This is a struct containing all the parameters needed to describe a compressor effect |
| CDistortionParameters | This is a struct containing all the parameters needed to describe a Distortion effect |
| CEAXReverbParameters | This is a struct containing all the parameters needed to describe an EAX Reverb effect |
| CEchoParameters | This is a struct containing all the parameters needed to describe an echo effect |
| CEqualizerParameters | This is a struct containing all the parameters needed to describe an equalizer effect |
| CFlangerParameters | This is a struct containing all the parameters needed to describe an flanger effect |
| CFrequencyShiftParameters | This is a struct containing all the parameters needed to describe a frequency shift effect |
| CiBufferUpdate2DWorkUnit | This is the work unit for updating audio buffers as necessary for audio playback |
| CiBufferUpdate3DWorkUnit | This is the work unit for updating audio buffers as necessary for audio playback |
| CiDecoder | This is an interface class for the decoding of audio from a stream |
| CiDecoderFactory | This is an interface class for factories that create decoders |
| CiEffect | This is an interface class for an effect that can be applied to a sound |
| CiEffectFilterCleanWorkUnit | This is the work unit for marking all effects and filters as clean after sounds have been processed |
| CiEffectsHandler | This is an interface class for the creation, destruction, and overall management of audio effects |
| CiFilter | This is an interface class for the application of filters to audio playback |
| CiListener | This is an interface class for a listener (such as a player) in the 3D audio world |
| CiRecorder | This is an interface class for the recording of audio |
| CiSound | This is an interface class for a non-spacialized sound |
| CMusicPlayer | This is a convenience class for the playing of music in a game |
| CPitchShifterParameters | This is a struct containing all the parameters needed to describe a pitch shift effect |
| CPlaylist | This class is a list of sounds with common playlist features |
| CReverbParameters | This is a struct containing all the parameters needed to describe a Reverb effect |
| CRingModulatorParameters | This is a struct containing all the parameters needed to describe a ring modulation effect |
| CSoundProxy | This is a proxy class for representing a sound being played in 3D space |
| CSoundScapeManager | This is the base manager class for audio being played in a 3D environment |
| CVocalMorpherParameters | This is a struct containing all the parameters needed to describe a vocal morpher effect |
| ►NBinaryTools | |
| CBinaryBuffer | A way to store and pass binary buffers, for example compiled bytecode |
| ►Ndebug | This namespace is for internal debugging tools. In general it shouldn't be used in game code |
| CInternalDebugDrawer | This is used to draw wireframse for the Physics subsystem |
| ►NGraphics | This namespace is for all the classes belonging to the Graphics Subsystem |
| ►NProcedural | This namespace is for all the classes that facilitate the procedural creation of art assets |
| CAlphaMaskModifier | A modifier that will use a mask image to set the alpha channels of a source image |
| CAlphaModifier | A modifier that will replace all pixels with "White Smoke" corresponding to the intensity of the extracted colour and the source alpha channel |
| CAtlasGenerator | A generator that will produce an image that is a number of other images placed side by side with no overlap |
| CBlitModifier | A modifier that will copy a portion of one texture and place it into another |
| CBlurModifier | A modifier that will attempt to reduce the sharpness of the texture |
| CBooleanGenerator | A generator class for performing boolean operations on two buffers |
| CBoxCornerGenerator | A generator class for a mesh composed of boxes that outline the corner edges of a larger box |
| CBoxGenerator | A generator class for a box mesh |
| CBoxUVModifier | A modifier that will generate UV coordinates as they would need to be on a box model |
| CBufferSection | A convenience class used to describe a small portion of the mesh/buffer |
| CCapsuleGenerator | A generator class for a capsule mesh with rounded ends |
| CCellGenerator | Create a texture consisting of cells aligned in a grid, or a chessboard |
| CChannelModifier | A modifier that will zero out selected colour channels or produce a grey version of the provided texture |
| CCircleModifier | A modifier that draws a simple coloured circle onto the texture |
| CCloudGenerator | Creates a cloud structured image |
| CColoursModifier | A modifier that will alter the basic colour properties of the texture |
| CCombineLayer | Convenience class used by the CombineModifier class to describe what action to take with a specific texture to be combined |
| CCombineModifier | A modifier that will attempt to combine the content of multiple textures |
| CConeGenerator | A generator class for a cone mesh |
| CConvolutionModifier | A modifier that will calculate each pixel in an image to be a weighed sum of itself and it's neighbors |
| CCrackModifier | A modifier that will generate random coloured lines on a texture |
| CCycloidModifier | A modifier that will draw a series of curved line segments |
| CCylinderGenerator | A generator class for a cylinder mesh with flat ends |
| CCylinderUVModifier | A modifier that will generate UV coordinates as they would need to be on a cylinder model |
| CDelaunaySegment | A segment of 2 points in a Point2DContainer |
| CDelaunayTriangle | A triangle formed from 3 points in a Point2DContainer |
| CDilateModifier | A modifier that will bright areas of the texture over the darker areas of the image |
| CEdgeDetectionModifier | A modifier that will reduce the texture to an outline of the detected edges in the texture |
| CEllipseModifier | A modifier that draws a simple coloured ellipse onto the texture |
| CExtruder | A generator that will create a 3D model by moving a 2D shape along a 3D Path |
| CFlareModifier | A modifier that will draw an illuminated circle that fades over a distance to a previous texture |
| CFlipModifier | A modifier that will flip pixels along an axis or axes in a texture |
| CGradientGenerator | Fills full image with given colour gradients |
| CHemisphereUVModifier | A modifier that will generate UV coordinates as they would need to be on a hemisphere model |
| CIcoSphereGenerator | A generator class for a sphere mesh where all triangles are the same size |
| CImageGenerator | Creates an image to be modified from a pre-existing image on disk |
| CIntersectionInShape | Convenience class storing data on the point in a 2D shape where multiple segments intersect |
| CIntVector2 | Convenience class for pixel processing |
| CInvertModifier | A modifier that will invert the value of each colour channel for each pixel |
| CJitterModifier | A modifier that will randomly shuffle the pixel being processed to a nearby position |
| CLabyrinthGenerator | Creates a labyrinth structured image |
| CLathe | A generator that produces a Mesh by rotating a 2D shape around the Y axis |
| CLerpGenerator | Creates a texture that is the interpolated result between two other textures |
| CLookupModifier | A modifier that uses an image to lookup and copy pixels of another image |
| CMarbleGenerator | Creates a marble structured image |
| CMeshGenerator | A base class containing all of the utilities needed for a mesh generator |
| CMeshLoader | A generator class for loading an external mesh into a procedural buffer |
| CMeshModifier | A base class for modifying the contents of an already populated triangle buffer |
| CMultiPath | A grouping of individual 3D curves used to express complicated structures |
| CMultiShape | A grouping of individual 2D shapes used to express more elaborate shapes |
| CNoiseGenerator | Fills full image with noise in a given colour |
| CNormalsModifier | A modifier that will convery a greyscale image into a normals map |
| COilPaintModifier | A modifier that will group similiar pixels together and normalize their colour |
| CPath | A collection of interconnected 3D points used to express path through 3D space |
| CPathCoordinate | A convenience class for tracking points in a MultiPath |
| CPlaneGenerator | A generator class for a plane mesh |
| CPlaneUVModifier | A modifier that will generate UV coordinates as they would need to be on a plane model |
| CRandomPixelsModifier | A modifer that will draw coloured pixels at random positions on the texture |
| CRectangleModifier | A modifier that draws a simple coloured rectangle onto the texture |
| CRotationZoomModifier | A modifier that will apply a rotation to the image and optionally zoom in on it |
| CRoundedBoxGenerator | A generator class for a rounded box mesh |
| CSegmentModifier | A modifier that will alter the colour of pixels above a certain luminous value |
| CShape | A collection of interconnected 2D points used to express an arbitrary 2D shape |
| CSharpenModifier | A modifier that will attempt to add detail to a texture |
| CSolidGenerator | Fills full image with given colour |
| CSphereGenerator | A generator class for a sphere mesh |
| CSphereUVModifier | A modifier that will generate UV coordinates as they would need to be on a sphere model |
| CSpherifyModifier | A modifier that will increase or decrease the distance to a point to match a specified radius |
| CTextileGenerator | Creates a textile structured image |
| CTextTextureModifier | A modifier to add text to a texture |
| CTextureBuffer | A convenience buffer that stores pixel colour values of a texture to be generated |
| CTextureGenerator | A base class for texture generators that use the TextureBuffer class |
| CTextureModifier | A base class for modifying the contents of an already populated texture buffer |
| CThresholdModifier | A modifier that will set a pixels colour if it's intensity is outside a set threshold |
| CTorusGenerator | A generator class for a torus mesh |
| CTorusKnotGenerator | A generator class for a torus knot mesh |
| CTouchSuperTriangle | A triangle convenience class for some comparison operations |
| CTriangleBuffer | A convenience buffer that stores vertices and indices of a mesh to be generated |
| CTriangulator | A generator class that implements the Delaunay Triangulation algorithm |
| CTubeGenerator | A generator class for a tube mesh |
| CVertex | A simple definition for a Vertex to be used when procedurally generating meshes |
| CVertexNormalsModifier | |
| CVertexTransformModifier | A modifier that will update the transform of every vertex in a mesh |
| CVertexUVModifier | A modifier that will transform the UV coordinates of a mesh |
| CVortexModifier | Twists the pixel positions in a circle on the Texture |
| CWeighedLerpModifier | A modifier that will use the colours of the texture to be modified to perform a linear interpolation between two other textures |
| CWeldVerticesModifier | A modifier that will combine vertices together that are close to each other |
| CWoodGenerator | Creates a wood slice image |
| CBillboard | This is the proxy class for placing and manipulating a set of 2D billboards in the scene |
| CBillboardSetProxy | This is the proxy class for placing and manipulating a set of 2D billboards in the scene |
| CBone | This class encapsulates the bones contained in a skeleton used for animation |
| CCameraProxy | This is the proxy class for placing and manipulating a camera in the scene |
| CDefaultGraphicsManagerFactory | A factory responsible for the creation and destruction of the default graphicsmanager |
| CDefaultMeshManagerFactory | A factory responsible for the creation and destruction of the default MeshManager |
| CDefaultSceneManagerFactory | A factory responsible for the creation and destruction of the default scenemanager |
| CDefaultTextureManagerFactory | A factory responsible for the creation and destruction of the default TextureManager |
| CEntityProxy | This is the proxy class for placing and manipulating a mesh in the scene |
| CGameWindow | This class is for creating and managing game windows |
| CGraphicsManager | This is intended to store basic graphics setting for the user |
| CImage | This class represents an image loaded into system memory |
| CInternalImageData | This class is used to store the internal structures needed by the Image class |
| CInternalMaterialData | This class is used to store the internal structures needed by the Material class |
| CInternalMeshData | This class is used to store the internal structures needed by the Mesh class |
| CInternalSkeletonData | This class is used to store the internal structures needed by the Skeleton class |
| CInternalTextureData | This class is used to store the internal structures needed by the Texture class |
| CLightProxy | This is the proxy class for placing and manipulating lighting in the scene |
| CMaterial | This class represents all the rendering passes a rendered object has |
| CMesh | This class is used to check and modify the properties of a graphics mesh |
| CMeshInfo | A convenience class for the storage of rendering data in a Mesh/SubMesh |
| CMeshManager | This manager handles the storage, generation, and query of of Graphics Meshes |
| CParticleAffector | This class defines how particles of a given particle effect behave during their lifetime |
| CParticleEmitter | This class defines how particles of a given particle effect spawn |
| CParticleSystemProxy | This is the proxy class for placing and manipulating particles in the scene |
| CPass | This class represents one rendering pass for a graphics object |
| CRenderableProxy | This is the base proxy class for world proxies wrapping functionality of the graphics subsystem |
| CRenderWorkUnit | This does the main loop processing for required to make the Graphics Manager function |
| CResolution | This stores all the basic configuration options a game window supports |
| CSceneManager | This class contains utilities and functions to allow the manipulation of the Graphical scene, rather then the physics inside, or the object inside |
| CSceneManagerData | Stores internal data for the SCeneManager to keep it from cluttering the Header file |
| CSkeleton | This class encapsulates the Skeletal animation functionality of a Mesh |
| CSubMesh | This class represents a sub-section of an overall mesh |
| CTechnique | This class represents a collection of passes an object has for it's rendering |
| CTexture | This class represents a texture loaded into video memory |
| CTextureManager | This manager handles the storage and query of of Graphics Textures |
| CVertexInfo | A convenience class for the storage of Vertex data in a Mesh/SubMesh |
| CViewport | This class is for creating and managing viewports within a game window |
| CWindowSettings | This stores all the basic configuration options a game window supports |
| ►NInput | This namespace is for all the classes belonging to the Input Subsystem |
| CButtonDevice | This is a base class for all input devices with buttons |
| CController | This class represents a controller input device, such as a gamepad or joystick |
| CDefaultInputManagerFactory | A factory responsible for the creation and destruction of the default inputmanager |
| CDevice | This is a base class for all input devices |
| CDeviceUpdateWorkUnit | This is a Mezzanine::Threading::iWorkUnit for the updating of the physics debug drawer |
| CInputManager | This is the manager responsible for the handling of input devices and events |
| CInputManagerInternalData | This is an class for the handling of internal input data |
| CKeyboard | This class represents the keyboard input device. //////////////////////////////////// |
| CMetaCode | This Determines the kind of user input |
| CMetaCodeKey | A key class for MetaCodes to be used in associative containers |
| CMouse | This class represents the mouse input device |
| CSequenceContainer | This class stores and provides utilities for sequenced inputs and their operations |
| ►NInternal | |
| CEventManagerInternalData | Used to increase encapsulation, just a bit |
| CLine3D | Does the bulk of the work that that the Mezzanine::LineGroup performs |
| CLineVertex | A small declaration of what our vertexs look like for when we write to the buffers |
| ►NNetwork | This namespace is for all the classes belonging to the Network Subsystem |
| CConnection | A base class for the state of a connection made between peers |
| CDefaultNetworkManagerFactory | A factory responsible for the creation and destruction of the default networkmanager |
| CFTPCommand | A command that can be issued to an FTP server |
| CFTPMessage | A base class for text based messages exchanged between FTP clients and servers |
| CFTPResponse | A response to a command generated by a FTP server |
| CHeaderField | Convenience class for storing Header fields in internet messaging protocols |
| CHTTPClient | |
| CHTTPMessage | A base class for HTTP text parsing classes |
| CHTTPRequest | A simple class to facilitate the creation of HTTP requests |
| CHTTPResponse | A response to an HTTPRequest generated by an HTTP server |
| CIPAddress | This is a simple class for representing IP addresses used throughout the Network subsystem |
| CIPv4Socket | A socket class using the IP version 4 protocol |
| CIPv6Socket | A socket class using the IP version 6 protocol |
| CNetworkManager | This is the central management class for all network I/O operations |
| CPacket | A base class for packing information to be transferred over the network |
| CPlatformSocket | This is helper class for managing platform specific data of socket implementations |
| CSocket | This is a basic socket interface for the transmission and retrieval of packets |
| CSocketDescription | A convenience class storing socket data that can be returned from utility methods and used to create and init new sockets |
| CSocketHandle | Used to allow type inference on PlatformSocket constructors |
| CSocketResultContainer | A special container class used to store the results from a call to "ResolveDomainName" |
| CSystemAddress | A simple class that stores a complete set of information for establishing connections |
| CTCPSocket | A socket class using the TCP stream protocol |
| CTCPv4Socket | A TCP socket that uses IPv4 internet addresses for connections |
| CTCPv6Socket | A TCP socket that uses IPv6 internet addresses for connections |
| CUDPSocket | A socket class using the User Datagram Protocol |
| CUDPv4Socket | A UDP socket that uses IPv4 internet addresses for transmissions |
| CUDPv6Socket | A UDP socket that uses IPv6 internet addresses for transmissions |
| CURI | A helper class for the reading and using of Uniform Resource Identifiers |
| ►NPhysics | This namespace is for all the classes belonging to the Physics Subsystem |
| CBoxCollisionShape | A box physics shape |
| CCapsuleCollisionShape | A capsule physics shape |
| CCollidablePair | This is a helper class for storing pairs of collidable proxies in associative containers |
| CCollidableProxy | This is a proxy from which physics objects that can collide with each other are handled |
| CCollision | This is an event class used to track collsions in the physics world |
| CCollisionDispatcher | Used to provide better reporting of collisions |
| CCollisionInternalData | Used to insulate the interface from the implementation details for bullet |
| CCollisionShape | This is the base class for all collision shapes |
| CCollisionShapeDeSerializer | A tool to aid in deserialization for the specific instances that DeSerialization CollisionShapes other ways does not make sense |
| CCollisionShapeManager | This manager is for the storage of all shapes and creation of mesh shapes |
| CCompoundCollisionShape | A collision shape composed of many other collision shapes placed and oriented in local space |
| CConeCollisionShape | A cone physics shape |
| CConeTwistConstraint | This is a constraint that will limit the movement allowed from one body to within a cone area around another object |
| CConstraint | This is the base class for all constraints supported |
| CConvexHullCollisionShape | A simple convex shape built from a low number of points in local space |
| CCylinderCollisionShape | A cylinder physics shape |
| CDebugDrawWorkUnit | This is a Mezzanine::Threading::iWorkUnit for the updating of the physics debug drawer |
| CDefaultCollisionShapeManagerFactory | A factory responsible for the creation and destruction of the default collisionshapemanager |
| CDefaultPhysicsManagerFactory | A factory responsible for the creation and destruction of the default physicsmanager |
| CDualTransformConstraint | All constraints that track rotation and location of the Pivot relative to each Actor inherit from this |
| CDynamicMeshCollisionShape | A triangle mesh collsion shape based on a graphics mesh |
| CFieldCollisionShape | This is the base class for all Field shapes |
| CGearConstraint | This is a constraint that duplicate the angular motion of one object to another, adjusted by the provided ratio |
| CGeneric6DofConstraint | Create simple but specific limits on any axis of movement or rotation |
| CGeneric6DofSpringConstraint | Creates a constraint as configurable as the 6Dof constraint, but has added support for spring motion |
| CGhostProxy | This is the proxy object for ghost objects with no contact response |
| CHeightfieldCollisionShape | A series of values that store hieght in a grid like fashion |
| CHinge2Constraint | This is a convience class that will configure a 6DoF spring constraint with 2 angular and 1 linear (with a spring) axes of freedom such that it can behave like a wheel and axel |
| CHingeConstraint | This is a constraint to be used to restrict the movement between two objects to angular rotation on a single axis |
| CManagerConstructionInfo | This is a helper class storing information needed for the construction of a PhysicsManager |
| CMeshCollisionShape | This is the base class for all Mesh shapes |
| CMultiSphereCollisionShape | A physics shape comprised of multiple sphere's placed in local space |
| CParallelCollisionDispatcher | Used to provide better reporting of collisions in a multithreaded environment |
| CPhysicsManager | This is simply a place for storing all the Physics Related functions |
| CPlaneCollisionShape | A Flat wall/floor of limitless size |
| CPoint2PointConstraint | Tries to make a point relative to each of two actors match in 3d space, without regard to rotation |
| CPrimitiveCollisionShape | This is the base class for all Primitive shapes |
| CRigidProxy | This is a proxy from which rigid body proxys are handled |
| CSimulationMonopolyWorkUnit | This is a Mezzanine::Threading::iWorkUnit for the multi-threaded processing of physics simulations |
| CSimulationWorkUnit | This is a Mezzanine::Threading::iWorkUnit for the single threaded processing of physics simulations |
| CSliderConstraint | This is a constraint for permitting movement on only a singular linear or angular axis |
| CSoftCollisionShape | A collision shape for soft proxies |
| CSoftProxy | This is the proxy object for soft/compressable bodies |
| CSphereCollisionShape | A sphere physics shape |
| CStaticMeshCollisionShape | A triangle mesh collsion shape based on a graphics mesh |
| CStickyConstraintConstructionInfo | Simple struct for holding information on how sticky constraints should be constructed |
| CStickyData | This is a basic class for storing the data related to the sticky behavior available to rigid bodies |
| CUniversalConstraint | This is a constraint for sharing the rotation of one object along an angular axis with another |
| CWorldTriggerUpdateWorkUnit | This is a Mezzanine::Threading::iWorkUnit for the updating of WorldTriggers |
| ►NResource | This namespace is for all the classes belonging to the non-network I/O Subsystem |
| CArchive | |
| CAsset | A convenience base class for objects that may need common IO operations exposed for them |
| CAssetGroup | This is a class that stores a specific grouping of Assets, usually based on thier location |
| CAssetHandler | |
| CAssetID | This is a simple class storing the name and group identification of an Asset/Stream |
| CDefaultResourceManagerFactory | A factory responsible for the creation and destruction of the default resourcemanager |
| CFileStream | This represents a stream to a file on disk using the C++ file stream API |
| CiInStream | Interface class for input (read) streams |
| CIOStream | Base class for streams that support both read and write operations |
| CiOutStream | Interface class for output (write) streams |
| CIStream | Base class for input (read) streams with minimal implementation |
| CiStreamBase | Base class interface for resource streams |
| CMemoryStream | An I/O stream to a buffer of memory |
| CMemoryStreamBuffer | A stream buffer object to a chunk of memory |
| COStream | Base class for output (write) streams with minimal implementation |
| CResourceManager | This is the manager responsible for the loading and unloading of files |
| ►NScripting | This namespace is for all the classes belonging to the Scripting Subsystem |
| ►NLua | This contains the Lua51 and Lua52 resources |
| CFlaggedBuffer | An expanded version of the BinaryTools::BinaryBuffer to carry one tiny piece of metadata around with it |
| CLua51BoolArgument | No special care is required for Bool Lua Arguments, so a simple typedef is used |
| CLua51IntegerArgument | The implementations in the ScriptArgumentGeneric<Integer> will cover most of what this needs |
| CLua51NilArgument | Represents not much of anything but will insert and retrieves Nils from Lua51 |
| CLua51RealArgument | A Real that can readily be passed into lua scripts |
| CLua51Script | This class is used to store a Lua script and in its source and compiled state |
| CLua51ScriptingEngine | The workhorse of the Lua scripting system. All scripts come here to be executed |
| CLua51ScriptingEngineFactory | A factory responsible for the creation and destruction of the default scripting engine providing Lua 5.1 support |
| CLua51StringArgument | No special care is required for String Lua Arguments, so a simple typedef is used |
| CLua51WholeArgument | No special care is required for Whole number Lua Arguments, so a simple typedef is used |
| CLua51WorkUnit | This is a simple Container of script that will execute every script it is given in order each frame |
| CLuaArgument | The ScriptArgumentGeneric<T> needs just a bit of Lua specific functionality so we add push/pop for the LuaScript to call |
| CiScript | The interface for a script |
| CiScriptArgument | The interface for a script argument |
| CiScriptCompilable | The interface for a script that can be compiled to bytecode |
| CiScriptCompilationManager | What a scripting manager should look like |
| CiScriptingManager | What a scripting manager should look like |
| CiScriptMultipleReturn | This script can return simple group of values |
| CiScriptWorkUnit | The interface for a container of script that can be executed each frame |
| CNullArgument | A very simple type used to indicate to script argument templates that the argument represents |
| CScriptArgumentGeneric | A generic implementation of a ScriptArgument that is suitable for primitive types in most situations |
| CScriptArgumentGeneric< Boole > | A Bool implementation of a ScriptArgument that is suitable for primitive types in most situations |
| CScriptArgumentGeneric< Integer > | A Integer implementation of a ScriptArgument that is suitable for primitive types in most situations |
| CScriptArgumentGeneric< NullArgument > | A Null implementation of a ScriptArgument that is suitable for primitive types in most situations |
| CScriptArgumentGeneric< Real > | A Real number implementation of a ScriptArgument that is suitable for primitive types in most situations |
| CScriptArgumentGeneric< String > | A String implementation of a ScriptArgument that is suitable for primitive types in most situations |
| CScriptArgumentGeneric< Whole > | A Whole number implementation of a ScriptArgument that is suitable for primitive types in most situations |
| ►NTesting | This contains all the items (except the tests themselves) that make the unit tests work |
| COutputCaptureManager | Used to aplly RAII to Stdout and STDERR buffers/streams |
| CTestData | The information about a test and how to easily find it in the filesystem |
| CTimedTest | An easy way to get the time something took to execute |
| CUnitTestGroup | A single group of tests, suitable for being all the tests of a small subsystem or single class |
| ►NThreading | This is where game specific threading algorithms and a minimalistic subset of the std threading library a held |
| CAsynchronousFileLoadWorkUnit | This is intended to load files asynchronously and continue doing so whether or not other the FrameScheduler is running or paused |
| CBarrier | A synchronization primitive that causes a predefined number of threads to all wait before continuing |
| CDefaultThreadSpecificStorage | Use this to change the default resource type |
| CDefaultWorkUnit | Default implementation of WorkUnit. This represents on piece of work through time |
| CDoubleBufferedResource | A thread specific resource that uses double buffering to avoid multithreaded synchronization mechanisms |
| CFrameScheduler | This is central object in this algorithm, it is responsible for spawning threads and managing the order that work units are executed |
| CiAsynchronousWorkUnit | The interface for a WorkUnit that will keep running when the rest of the scheduler is paused |
| CiWorkUnit | Interface of a WorkUnit. This represents on piece of work through time |
| Clock_guard | Lock guard class |
| CLogAggregator | Gather all the thread specific logs and commit them to the main log |
| CMonopolyWorkUnit | A kind of workunit given exclusive runtime so it can consume time on multiple threads |
| CMutex | A cross-platform abstraction of the OS's mutex |
| CRawFile | A simple in memory representation of a file |
| CReadOnlyLockGuard | Read only lock guard |
| CReadWriteLockGuard | ReadWrite lock guard |
| CReadWriteSpinLock | A mutex like construct that supports multiple readsingle writer semantics and never makes a system call and uses CPU instructions instead |
| CScopedTimer | Used to time from this objects creation to its destruction |
| CSpinLock | A mutex like construct that never makes a system call and uses CPU instructions instead |
| CThread | A small wrapper around the system thread |
| CThreadId | The thread ID is a unique identifier for each thread |
| CThreadSpecificStorage | A thread specific collection of double-buffered and algorithm specific resources |
| CWorkSorter | Sorts all of the WorkUnits in the FrameScheduler |
| CWorkUnitKey | Stores data about a single work unit so that it can easily be sorted |
| ►NUI | This namespace is for all the classes belonging to the Graphical User Interface Subsystem |
| CAction | This class represents an action to be taken. Can have multiple inputs bound to it |
| CActionEventArguments | This is the base class for action specific event arguments |
| CActionHandler | This class is the core class responsible for the management of actions |
| CAtlasAndPosition | This class stores how the calls to Render are to be done |
| CBruteStrategy | This strategy uses a brute force reverse search for the hovered quad |
| CButton | This class is a helper class, specifically for use as a button |
| CButtonFactory | This is the factory implementation for Button widgets |
| CCharacter | This class creates and encapsultes a character that can be used in text renders |
| CCharacterTraits | This class stores common data for determining the look of a Character |
| CCheckBox | This is a simple widget for storing a bool value |
| CCheckBoxFactory | This is the factory implementation for CheckBox widgets |
| CChildSelectedArguments | This is the EventArguments class for when a child of a paged container is selected |
| CDefaultColourTag | This class implements a character colour changing tag |
| CDefaultFontTag | This class implements a character font changing tag |
| CDefaultMarkupParser | This class implements the default set of tags used by the UI markup system |
| CDefaultSpriteTag | This class implements a sprite inserting tag |
| CDefaultUIManagerFactory | A factory responsible for the creation and destruction of the default uimanager |
| CDropDownList | This is a widget that displays one selection from a list that can have it's visibility toggled |
| CDropDownListFactory | This is the factory implementation for DropDownList widgets |
| CEditBox | Widget for handling the input and manipulation of text |
| CEditBoxFactory | This is the factory implementation for EditBox widgets |
| CFontData | This class represents a collection of Glyphs in a common visual style |
| CGenericWidgetFactory | This is the factory implementation for generic widgets |
| CGlyph | Class used to describe a single glyph or character available for text operations |
| CGridContainer | This is a container class for placing child objects on a 2 dimensional grid |
| CGridContainerFactory | This is the factory implementation for GridContainer widgets |
| CGridRect | Simple rect used to represent a complete transform on a grid |
| CGridVector2 | Simple class used to represent positions or sizes on a grid |
| CGroupOrderEntry | This is a small convenience class used to store a RenderLayerGroup ID and a ZOrder on that RenderLayerGroup |
| CHorizontalContainer | A layout container that aligns it's children along a common X axis |
| CHorizontalContainerFactory | This is the factory implementation for HorizontalContainer widgets |
| CHorizontalLayoutStrategy | This is a specialization of a layout strategy where a group of quads are sized and placed in a linear sequence along the X axis |
| CHorizontalScrollbar | This is a scrollbar class aligned on the X axis |
| CHorizontalScrollbarFactory | This is the factory implementation for HorizontalScrollbar widgets |
| CHotKeyHandler | This class is responsible for the registration and handling of hotkeys in the UI system |
| CImageLayer | This layer is for placing images and basic colours in it's parents' quad space |
| CInsertTagToken | This struct represents a markup tag segment from the source string |
| CKerningInfo | Basic class used to describe Kerning for a given Glyph |
| CLayoutContainer | This is the base class for container objects that automatically position it's children |
| CLayoutStrategy | This is a base class for the algorithms used by QuadRenderables to determine how they should update their dimensions |
| CLeftToRightTextLine | This is a TextLine specialization class for text read from the left to the right |
| CLinearContainer | This is a container class for placing child objects in succession on a single axis |
| CLineList | This is an object comprised of a series of lines |
| CLineListRenderer | This is a renderer class specifically designed to draw lines |
| CListBox | This is a widget for displaying a list of captions in a box |
| CListBoxFactory | This is the factory implementation for ListBox widgets |
| CMarkupParser | This is a base class for the parsing of markup texts contained in text layers |
| CMarkupTag | This is a base class for tags that implement the functionality of a markup language |
| CMenuEntry | This class is an entry for a single window/widget in a menu |
| CMenuEntryFactory | This is the factory implementation for MenuEntry widgets |
| CMouseHoverCheck | Simple functor for finding which renderable the mouse is hovered over |
| CMouseHoverStrategy | This is the base class for a method of finding which quad the mouse is hovered over |
| CMultiImageData | This is an image layer that supports rendering of multiple images within it's space |
| CMultiImageLayer | This is an image layer that supports rendering of multiple images within it's space |
| CMultiLineTextLayer | This is a render layer specializing in multi-line text |
| CNineBoxCheck | Simple functor for finding which renderable the mouse is hovered over |
| CNineBoxStrategy | This strategy partitions the screen into 9 area's that track which Quads are in them, allowing a smaller list of quads to be checked |
| CPagedContainer | This is the base class for containers that have a render area and work area of different sizes |
| CPageProvider | This is the base class for interpretting widget values to page positions |
| CPartitionData | This is a helper class for storing metadata for partitions |
| CPositioningInfo | This is a helper class designed to describe the behaviors of a quad when it needs to be repositioned |
| CQuadRenderable | This represents a nestable quad for an object in a GUI layout |
| CQuadRenderer | |
| CRadioButton | This is a simple widget where only one of it's selections can be selected at a time |
| CRadioButtonFactory | This is the factory implementation for RadioButton widgets |
| CRadioButtonGroup | This is a class designed to facilitate operations across an entire group of RadioButtons |
| CRangeTagToken | This struct represents a markup tag segment from the source string |
| CRect | This class represents a box shaped area on the screen |
| CRenderable | Basic class for all structures that get inserted into the rendering hierarchy |
| CRenderLayer | This is the base class for the types of layers that can be added to a renderable |
| CRenderLayerGroup | This class stores a group of render layers that can be set to be rendered |
| CRightToLeftTextLine | This is a TextLine specialization class for text read from the right to the left |
| CScreen | This class is a helper class for creating UI's. It is responsible for storing and keeping track of all the elements of a single UI screen |
| CScreenRenderData | This class stores all vertices pertaining to a layer sorted by their priority for rendering |
| CScrollbar | This is the scrollbar base class |
| CScrollbarValueChangedArguments | This is the EventArguments class for when the scrollvalue of a scrollbar is updated |
| CSimpleRenderer | A simple class providing basic methods to generate vertices with |
| CSingleImageLayer | This is an image layer that supports rendering only a single image/sprite |
| CSingleLineTextLayer | This is a render layer specializing in single-line text |
| CSizingInfo | This is a helper class designed to describe the behaviors of a quad when it needs to be resized |
| CSpinner | This is a simple widget for a numeric variable in a box |
| CSpinnerFactory | This is the factory implementation for Spinner widgets |
| CSpinnerValueChangedArguments | This is the EventArguments class for when the spinvalue of a Spinner is updated |
| CSprite | Basic class used to describe a portion of a texture to be applied to a Quad |
| CStackButton | This is a button with additional data used to track the binding to a StackedContainer which can be serialized |
| CStackButtonFactory | This is the factory implementation for StackButton widgets |
| CStackedContainer | This is the base class for containers that stack their children one on top of the other |
| CTabSet | This is a widget that stores sets of renderables but only displays one at a time |
| CTabSetFactory | This is the factory implementation for TabSet widgets |
| CTagToken | This struct represents a markup tag segment from the source string |
| CTextCursor | Class for encapsulating the functionality of the text cursor/carat navigation in text layers |
| CTextLayer | This is a base class for render layers that render text |
| CTextLine | This represents a single line of text to be rendered by a TextLayer |
| CTextToken | This class represents a normal text segment from the source string |
| CTextureAtlas | This is a collection of smaller textures packed into a larger texture, intended to increase UI performance |
| CTextureAtlasHandler | This handles the creation, storage and overall handling of Texture Atlases |
| CTokenString | This is a helper class that facilitates operations with collections of tokens generated from Markup Parsers |
| CUIManager | This class is responsible for any and all user interactions with the User interface/HUD |
| CUnifiedDim | This class represents both the relative and absolute values that can be expressed for the values on one dimension for a UI renderable |
| CUnifiedRect | This class represents a 2D rect which can express the size and position of a renderable on screen |
| CUnifiedVec2 | This class represents a point in 2D space using UnifiedDim's |
| CVertex | Basic class describing a vertex in the UI to be rendered |
| CVertexData | Basic class describing a vertex in the UI to be rendered |
| CVerticalContainer | A layout container that aligns it's children along a common Y axis |
| CVerticalContainerFactory | This is the factory implementation for VerticalContainer widgets |
| CVerticalLayoutStrategy | This is a specialization of a layout strategy where a group of quads are sized and placed in a linear sequence along the Y axis |
| CVerticalScrollbar | This is a scrollbar class aligned on the Y axis |
| CVerticalScrollbarFactory | This is the factory implementation for VerticalScrollbar widgets |
| CWidget | This is the base class for all widgets |
| CWidgetEventArguments | This is the base class for widget specific event arguments |
| CWidgetFactory | This is a base class for factories that construct the widgets available to the UI subsystem |
| CWidgetUpdateWorkUnit | This is a Mezzanine::Threading::iWorkUnit for the updating of widgets in the UI system |
| ►NXML | All tools for working with XML are located in this namespace |
| CAttribute | A light-weight handle for manipulating attributes in DOM tree |
| CAttributeIterator | Attribute iterator (a bidirectional iterator over a collection of Attribute) |
| CDocument | The root node of any xml hierarchy is a Document |
| CNamedNodeIterator | Child node iterator (a forward iterator over a collection of Node) only iterates over nodes with a given name |
| CNode | A light-weight handle for manipulating nodes in DOM tree |
| CNodeIterator | Child node iterator (a bidirectional iterator over a collection of Node) |
| CNodeText | A helper for working with text inside PCDATA nodes |
| CObjectRange | Used by the xml system to pass around iterable ranges |
| CParseResult | Troubleshooting data intended to help troublshoot XML parsing errors |
| CTreeWalker | Used to call a function OnEachNode member of the subtree of nodes descended from a specific node |
| CWriter | Interface for node printing (see Node::Print) |
| CWriterFile | An implementation of Writer intended for writing to FILEs as defined in stdio |
| CWriterStream | An implementation of Writer intended for writing std::ostreams |
| CXMLStreamWrapper | This represents a simple wrapper that makes data streams compatible with the XML API |
| CXPathNode | An XPath node which can store handles to a XML::Node or an XML::Attribute |
| CXPathNodeSet | A fixed sized collection of nodes that an XPathQuery can work on |
| CXPathParseResult | XPath parsing result |
| CXPathQuery | A compiled XPath query object |
| CXPathVariable | A single XPath variable |
| CXPathVariableSet | A set of XPath variables |
| CActor | This is the base class from which all the actors inherit |
| CActorFactory | A base factory type for the creation of Actor objects |
| CActorManager | A manager responsible for the storage and management of all actors that exist in a world |
| CActorUpdateWorkUnit | This is a Mezzanine::Threading::iWorkUnit for the updating of actors |
| CAngleLimits | Boundaries for rotation on one axis |
| CAreaEffect | This class is used to define area's in the world that have unique effects |
| CAreaEffectFactory | A base factory type for the creation of AreaEffect objects |
| CAreaEffectManager | A manager responsible for the storage and management of all areaeffects in use |
| CAreaEffectUpdateWorkUnit | This is a Mezzanine::Threading::iWorkUnit for the updating of AreaEffects |
| CArithmeticException | Thrown when Math has failed |
| CAttachableBase | This class is the base class for other attachable classes and is responsible for transform updates to attachables |
| CAttachableChild | This class is the base class for objects that can be attached to AttachableParent |
| CAttachableParent | Base class for objects that can have attachables attached to them |
| CAxisAlignedBox | This is a utility class used to represent the Axis-Aligned Bounding Boxes of objects in various subsystems |
| CBezierInterpolator | A simple functor for interpolating data points in a simple way |
| CBufferedRollingAverage | A RollingAverage that stores a copy of each record. and does the math when queried |
| CCameraController | This is a simplified controller class for use with cameras |
| CCFunctionSubscriberSlot | This is a subscriber slot class that triggers a Free/C-style function |
| CCircle | A generic circle class for geometry calculations |
| CColourValue | This is a simple class for holding 4 reals representing the colour any give object or lightsource can have |
| CCountedPtr | A simple reference counting pointer |
| CCountedPtrCastImpl | This is used as to determine how a CountedPtr performs castin between pointer types internally |
| CCountedPtrCastImpl< OriginalPointer, OriginalPointer, CastNoneError > | An implementation of the CountedPtrCast that always return the pointer passed reached via CastNoneError in the ReferenceCountTraits of the target class |
| CCountedPtrCastImpl< ReturnPointer, OriginalPointer, CastDynamic > | An implementation of the CountedPtrCast that naively dynamic casts the passed pointer. Reached by putting CastDynamic in the ReferenceCountTraits of the target class |
| CCountedPtrCastImpl< ReturnPointer, OriginalPointer, CastImplicit > | An implementation of the CountedPtrCast that casts the passed pointer. Reached by putting CastStatic in the ReferenceCountTraits of the target class |
| CCountedPtrCastImpl< ReturnPointer, OriginalPointer, CastNoneReturnZero > | An implementation of the CountedPtrCast that always returns 0 cast to the original pointer type. Reached by putting CastNoneReturnZero in the ReferenceCountTraits of the target class |
| CCountedPtrCastImpl< ReturnPointer, OriginalPointer, CastStatic > | An implementation of the CountedPtrCast that naively static casts the passed pointer. Reached by putting CastStatic in the ReferenceCountTraits of the target class |
| CCubicSpline | A class for interpolating data with arbitrary |
| CCubicSplineElement | Meta data nodes required to generate a cubic spline |
| CCustomSubscriberSlot | This is a subscriber slot class that passes on the event firing to a custom subscriber class |
| CDebris | A simple world object without a large structure ideal for representing loose small objects |
| CDebrisFactory | A base factory type for the creation of Debris objects |
| CDebrisManager | A manager responsible for the storage and management of all Debris that exist in a world |
| CDebrisUpdateWorkUnit | This is a Mezzanine::Threading::iWorkUnit for the updating of Debris |
| CDefaultActorManagerFactory | A factory responsible for the creation and destruction of the default actormanager |
| CDefaultAreaEffectManagerFactory | A factory responsible for the creation and destruction of the default areaeffectmanager |
| CDefaultDebrisManagerFactory | A factory responsible for the creation and destruction of the default DebrisManager |
| CDefaultEventManagerFactory | A factory responsible for the creation and destruction of the default eventmanager |
| CDefaultRollingAverage | Use this to get the default rolling average for a given type |
| CDefaultTerrainManagerFactory | A factory responsible for the creation and destruction of the default terrainmanager |
| CDeSerializer | A tool for deserializing classes with specific issues deserializing them |
| CDirectoryException | Thrown when there is an unknown issue with a file |
| CDirectoryNotFoundException | Thrown when a directory was expected to be there, but was not |
| CDirectoryPermissionException | Thrown when permission is denied to a directory |
| CDirectoryReadException | Thrown when a directory could be read and it wasn't a permission issue |
| CDirectoryWriteException | Thrown when a directory could be written to and it wasn't a permission issue |
| CEntresol | This is the main entry point for the entire library |
| CEntresolManager | This is the base class for all managers that do no describe properties of a single world, but rather engine-wide functionality |
| CEntresolManagerFactory | This is a base class for factories that construct managers used by the Entresol class |
| CEvent | This class represents a given event that can be subscribed to and/or fired |
| CEventArguments | This is a common class to represent all possible arguments for a given event that is fired |
| CEventBase | The base class for all events |
| CEventGameWindow | Convey the message that Something happened to a game window |
| CEventGameWindowData | Used to keep private in one place that is actually private |
| CEventManager | This is a container for Events and facilitates the transfer of data |
| CEventPublisher | This is the base class for any class that generates and publishes events to subscribers |
| CEventPumpWorkUnit | Every frame the OS must be queried for changes to the state, this does that querying on behalf of an eventmanager |
| CEventQuit | This is intended to convey the message that quitting needs to happen |
| CEventSubscriber | This is a base class for all classes that subscribe to events |
| CEventSubscriberSlot | This class represents a slot in an event that can be subscribed to via subscribers, functors, or methods |
| CEventUserInput | This is a container for MetaCodes that is used in the EventManager |
| CExceptionBase | This is the exception thrown by most Mezzanine systems that can throw exceptions |
| CExceptionFactory | Template class that serves as the base for exception factories |
| CExceptionFactory< ArithmeticException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< DirectoryException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< DirectoryNotFoundException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< DirectoryPermissionException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< DirectoryReadException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< DirectoryWriteException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< FileException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< FileNotFoundException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< FilePermissionException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< FileReadException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< FileWriteException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< InstanceIdentityDuplicateException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< InstanceIdentityException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< InstanceIdentityInvalidException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< InstanceIdentityNotFoundException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< InternalException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< InvalidAssignment::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< InvalidStateException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< InvalidVersionException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< IOException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< IOReadException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< IOWriteException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< MemoryManagementException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< MemoryOutOfBoundsException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< NetworkException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< NetworkNotFoundException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< NetworkPermissionException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< NetworkReadException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< NetworkURLException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< NetworkWriteException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< NotImplementedException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< OutOfMemoryException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< ParametersCastException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< ParametersException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< ParametersRangeException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< RenderingAPIException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< RuntimeAssertionException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< ScriptException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< ScriptLuaErrErrException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< ScriptLuaException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< ScriptLuaRuntimeException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< ScriptLuaYieldException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< SyntaxErrorException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< SyntaxErrorLuaException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< SyntaxErrorXMLException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExceptionFactory< SyntaxErrorXPathException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CExtendedTimer | An enhanced timer class that can store and track many units of time |
| CFieldOfForce | This is field that applies force in a direction, and doesn't tamper with gravity |
| CFieldOfForceFactory | A factory type for the creation of FieldOfForce objects |
| CFileException | Thrown when there is an unknown issue with a file |
| CFileNotFoundException | Thrown when a file was expected to be there, but was not |
| CFilePermissionException | Thrown when permission was denied to a file |
| CFileReadException | Thrown when a file could not be read and permissions seem to not be an issue (Filesystem/hardware issue? |
| CFileWriteException | Thrown when a file could not be written and perimssions seem not to be an issue |
| CFunctorEventSubscriber | Basic class definition for functors used by a FunctorSubscriberSlot |
| CFunctorSubscriberSlot | This is a subscriber slot class that makes the appropriate call on a functor |
| CGravityField | This is an implementation of the AreaEffect class that alters gravity in a region |
| CGravityFieldFactory | A factory type for the creation of GravityField objects |
| CGravityWell | This is a gravity well implementation of the AreaEffect class |
| CGravityWellFactory | A factory type for the creation of GravityWell objects |
| CHashedString32 | An identifier that compares as fast as an integer but has a string |
| CInstanceIdentityDuplicateException | Thrown when duplicates of teh same identity string exist |
| CInstanceIdentityException | Thrown when an unknown error with using an Identifier and it is invalid |
| CInstanceIdentityInvalidException | Thrown when the identity string wasn't valid at all |
| CInstanceIdentityNotFoundException | Thrown when the requested identity could not be found |
| CInternalException | Thrown when an unknown internal error occurred |
| CInterval | This class will generate keep track of a pool of unique 32-bit ID's that can be used for distinct object instances |
| CIntHandle | Sample implementation for a ManagedPtr |
| CIntrusiveRefCount | A sample class that implements a minimal intrusive reference counting scheme |
| CInvalidAssignment | Thrown when a complex class is assigned to itself or other invalid assignments occur |
| CInvalidStateException | Thrown when the available information should have worked but failed for unknown reasons |
| CInvalidVersionException | Thrown when a version is accessed/parsed/required and it cannot work correctly or is missing |
| CIOException | Thrown when there was an issue with IO but very little was known about it |
| CIOReadException | Thrown when a read is happening but something has prevented the underlying code from knowing what was reading |
| CIOWriteException | Thrown when a write is happening but something has prevented the underlying code from knowing what was writing |
| CLinearInterpolator | A simple functor for interpolating data points in a simple way |
| CLineGroup | This is a group of consectutive line segments to be rendered together |
| CLineSegment2D | A geometry math class for expressing a line connecting 2 points in 2D space |
| CLineSegment3D | A geometry math class for expressing a line connecting 2 points in 3D space |
| CManagedPtr | This is used to get RAII semantics when not provided inherently |
| CManagerBase | This is the base class from which all the Entresol and World Managers inherit |
| CManagerFactory | This is a base class for factories that construct the managers the engine uses |
| CMatrix3x3 | This is a 3x3 Matrix class used for representing rotations and scaling in an object |
| CMatrix4x4 | A 4x4 matrix math class for the representation of full transforms |
| CMemoryManagementException | Thrown when an unknown memory management exception occurs |
| CMemoryOutOfBoundsException | Thrown when attempted to access something that really should note be accessed |
| CMeshTerrain | |
| CNetworkException | Thrown when something unknown causes network IO to fail |
| CNetworkNotFoundException | Thrown when no network connection is available |
| CNetworkPermissionException | Thrown when permision was denied to a network interface or network resource |
| CNetworkReadException | Thrown when data could not be read from the network (downloads) |
| CNetworkURLException | Thrown when an address is invalid or could not be found |
| CNetworkWriteException | Thrown when data could not be read from the network (iloads) |
| CNotImplementedException | Thrown when we just have not coded a thing yet, but we knew what the API should look like |
| CObjectSettingFile | This class represents a file to be saved containing one or more OhjectSettingGroup's |
| CObjectSettingGroup | A class that store's a collection of SettingSets that can be applied together |
| CObjectSettingSet | A class that store's a named set of settings for an object |
| CObjectSettingSetContainer | A base class for other classes that store ObjectSettingSet's |
| CObjectSettingsHandler | An abstract class for other classes that manage groups of settings |
| COutOfMemoryException | Thrown when A memory allocation was attempted and failed |
| CParametersCastException | Thrown when a pointer parameter is checked at runtime and cannot be cast as expected |
| CParametersException | Thrown when parameters are checked at runtime and found invalid |
| CParametersRangeException | Thrown when a passed parameter is checked at runtime and not in the expected range |
| CPlane | This is used to represent a flat infinite slice of the game world |
| CQuaternion | This is used to store information about rotation in 3d space |
| CRay | This represents a line placed in 3D space and is used with spacial queries |
| CRayQueryTool | This provides a number of optional tools for working with a Mezzanine::World |
| CRectBase | A class for tracking a rectangle by tracking two corners Top, Left and Right, Bottom |
| CReferenceCount | This exists once per object managed by a group of shared pointer to track items in memory |
| CReferenceCountTraits | This is used to deduce at compile if a specific class has built-in reference counting or needs an external reference count |
| CReferenceCountTraits< EventArguments > | This is a metaprogramming traits class used by EventArguments |
| CReferenceCountTraits< IntrusiveRefCount > | An Example ReferenceCountTraits implmentation |
| CReferenceCountTraits< Scripting::iScript > | Marks IScript for internal reference counting if a CountedPtr checks |
| CReferenceCountTraits< Scripting::iScriptArgument > | Marks iScriptArgument for internal reference counting if a CountedPtr checks |
| CReferenceCountTraits< Scripting::iScriptCompilable > | Marks iScriptCompilable for internal reference counting if a CountedPtr checks |
| CReferenceCountTraits< Scripting::iScriptMultipleReturn > | Marks iScriptMultipleReturn for internal reference counting if a CountedPtr checks |
| CReferenceCountTraits< Scripting::Lua::Lua51BoolArgument > | Marks Lua51BoolArgument for internal reference counting if a CountedPtr checks |
| CReferenceCountTraits< Scripting::Lua::Lua51IntegerArgument > | Marks Lua51IntegerArgument for internal reference counting if a CountedPtr checks |
| CReferenceCountTraits< Scripting::Lua::Lua51NilArgument > | Marks Lua51NilArgument for internal reference counting if a CountedPtr checks |
| CReferenceCountTraits< Scripting::Lua::Lua51RealArgument > | Marks Lua51RealArgument for internal reference counting if a CountedPtr checks |
| CReferenceCountTraits< Scripting::Lua::Lua51Script > | Marks Lua51Script for internal reference counting if a CountedPtr checks |
| CReferenceCountTraits< Scripting::Lua::Lua51StringArgument > | Marks Lua51StringArgument for internal reference counting if a CountedPtr checks |
| CReferenceCountTraits< Scripting::Lua::Lua51WholeArgument > | Marks Lua51WholeArgument for internal reference counting if a CountedPtr checks |
| CReferenceCountTraits< Scripting::Lua::LuaArgument > | Marks LuaArgument for internal reference counting if a CountedPtr checks |
| CReferenceCountTraits< Scripting::ScriptArgumentGeneric< Boole > > | Marks ScriptArgumentGeneric<Real> for internal reference counting if a CountedPtr checks |
| CReferenceCountTraits< Scripting::ScriptArgumentGeneric< Integer > > | Marks ScriptArgumentGeneric<Integer> for internal reference counting if a CountedPtr checks |
| CReferenceCountTraits< Scripting::ScriptArgumentGeneric< Real > > | Marks ScriptArgumentGeneric<Real> for internal reference counting if a CountedPtr checks |
| CReferenceCountTraits< Scripting::ScriptArgumentGeneric< Scripting::NullArgument > > | Marks ScriptArgumentGeneric<Real> for internal reference counting if a CountedPtr checks |
| CReferenceCountTraits< Scripting::ScriptArgumentGeneric< String > > | Marks ScriptArgumentGeneric<String> for internal reference counting if a CountedPtr checks |
| CReferenceCountTraits< Scripting::ScriptArgumentGeneric< Whole > > | Marks ScriptArgumentGeneric<Whole> for internal reference counting if a CountedPtr checks |
| CReferenceCountTraits< UI::ActionEventArguments > | This is a metaprogramming traits class used by ActionEventArguments |
| CReferenceCountTraits< UI::ChildSelectedArguments > | This is a metaprogramming traits class used by ChildFocusEventArguments |
| CReferenceCountTraits< UI::ScrollbarValueChangedArguments > | This is a metaprogramming traits class used by ScrollbarValueChangedArguments |
| CReferenceCountTraits< UI::SpinnerValueChangedArguments > | This is a metaprogramming traits class used by SpinnerValueChangedArguments |
| CReferenceCountTraits< UI::WidgetEventArguments > | This is a metaprogramming traits class used by WidgetEventArguments |
| CRenderingAPIException | Thrown when the graphics card/DirectX/OpenGL fail |
| CRigidDebris | A non-deformable debris |
| CRigidDebrisFactory | A base factory type for the creation of non-deformable Debris objects |
| CRollingAverage | The interface for rolling averages used in the Mezzanine, and threading library |
| CRuntimeAssertionException | Thrown when a rutime assertion could have been Thrown |
| CScriptException | Thrown when an unknown error happens with a script |
| CScriptLuaErrErrException | Thrown when Lua has an error handling an error |
| CScriptLuaException | Thrown when an unknown error happens in a Lua script |
| CScriptLuaRuntimeException | Thrown when a Lua script has a runtime error |
| CScriptLuaYieldException | Thrown when Lua returns a yield and it should not have |
| CScriptSubscriberSlot | This is a subscriber slot class that triggers a provided script |
| CSemanticVersion | A Version class matching the Semantic Version specification |
| CSerializer | A tool for serializing classes with specific issues serializing |
| CSimpleVersion | A very basic class for expressing an API or syntax version |
| CSingleton | This is a convenience base class intended to be used with classes that need to be singletons |
| CSlowSplineInterpolator | If something specifically needs the linear interpolator for T they should use this |
| CSmoothTrackIterator | An Iterator that can take an arbitrary amount of steps through a track |
| CSoftDebris | A deformable debris |
| CSoftDebrisFactory | A base factory type for the creation of deformable Debris objects |
| CSortedVector | |
| CSphere | This is a generic sphere class used for spacial queries |
| CStateMachine | |
| CStateTransition | |
| CStateTransitionAction | |
| CSyntaxErrorException | Thrown when some kind of syntax exception |
| CSyntaxErrorLuaException | Thrown when lua code in incorrect |
| CSyntaxErrorXMLException | Thrown when and XML document is being parsed but is invalid |
| CSyntaxErrorXPathException | Thrown when an XPath query is being parsed but is invalid |
| CTerrainBase | This is the base class from which all the terrains inherit |
| CTerrainManager | This is manager for terrains and their functions |
| CTime | A container for the metrics of time relevant for the timer class |
| CTimedTrackIterator | This will take the same amount of clock time to iterate over a range |
| CTimer | A basic timer class to assist in timed operations |
| CTrack | A base type that provides container features for different tracks |
| CTrackLooped | A track that keeps an extra data point in the track to make sure it loops |
| CTrackStorage | |
| CTransform | Stores information about relative location and rotation in 3d space |
| CTransformableChildObject | This is an interface for all child 3D objects that can have their full transforms manipulated |
| CTransformableObject | This is an interface for all 3D objects that can have their full transforms manipulated |
| CTriangle2D | A geometry math class for expressing a triangle in 2D space |
| CTriangle3D | A geometry math class for expressing a triangle in 3D space |
| CUIDGenerator | This class will generate keep track of a pool of unique 32-bit ID's that can be used for distinct object instances |
| CVector2 | This is used to represent a point on a 2 dimentional area, such as a screen |
| CVector2LengthCompare | A compare fuctor that uses vector length |
| CVector3 | This is used to represent a point in space, or a vector through space |
| CVector3LengthCompare | A compare fuctor that uses vector length |
| CWeightedRollingAverage | A weighted average that does math with every insertion and stores nothing |
| CWorld | This class represents a world for objects to interact within |
| CWorldManager | This is the base class for all managers that belong to a single world instance |
| CWorldManagerFactory | This is a base class for factories that construct managers used by the World class |
| CWorldObject | This is the base class from which classes that are insertable into the physical world |
| CWorldProxy | This is the base class for proxy objects belonging to the various 3D subsystems |
| CWorldTrigger | This is an abstract class for creating in-game triggers |
| ►NOgre | |
| CSharedPtr | |
| ►Nstd | STL namespace |
| Cnumeric_limits< Mezzanine::Quaternion > | Get Numeric details on Quaternion |
| Cnumeric_limits< Mezzanine::Transform > | Get Numeric details on Transform |
| Cnumeric_limits< Mezzanine::Vector2 > | Get Numeric details on Vector2 |
| Cnumeric_limits< Mezzanine::Vector3 > | Get Numeric details on Vector3 |
| CAllUnitTestGroups | This aggregates the results of all the other test groups |
| CLogStream | A stream that tracks its own level of logging |
1.8.9.1. Thanks to the
Open Icon Library
for help with some of the icons.
