| ►CbtCollisionDispatcher | |
| CMezzanine::Physics::CollisionDispatcher | Used to provide better reporting of collisions |
| ►CbtIDebugDraw | |
| CMezzanine::debug::InternalDebugDrawer | This is used to draw wireframse for the Physics subsystem |
| CMezzanine::CountedPtr< iScriptArgument > | |
| CMezzanine::CountedPtr< Mezzanine::Scripting::Lua::Lua51Script > | |
| CMezzanine::DefaultRollingAverage< Whole > | |
| ►CMezzanine::DeSerializer< CollisionShape > | |
| CMezzanine::Physics::CollisionShapeDeSerializer | A tool to aid in deserialization for the specific instances that DeSerialization CollisionShapes other ways does not make sense |
| ►CMezzanine::Graphics::Procedural::MeshGenerator< BooleanGenerator > | |
| CMezzanine::Graphics::Procedural::BooleanGenerator | A generator class for performing boolean operations on two buffers |
| ►CMezzanine::Graphics::Procedural::MeshGenerator< BoxCornerGenerator > | |
| CMezzanine::Graphics::Procedural::BoxCornerGenerator | A generator class for a mesh composed of boxes that outline the corner edges of a larger box |
| ►CMezzanine::Graphics::Procedural::MeshGenerator< BoxGenerator > | |
| CMezzanine::Graphics::Procedural::BoxGenerator | A generator class for a box mesh |
| ►CMezzanine::Graphics::Procedural::MeshGenerator< CapsuleGenerator > | |
| CMezzanine::Graphics::Procedural::CapsuleGenerator | A generator class for a capsule mesh with rounded ends |
| ►CMezzanine::Graphics::Procedural::MeshGenerator< ConeGenerator > | |
| CMezzanine::Graphics::Procedural::ConeGenerator | A generator class for a cone mesh |
| ►CMezzanine::Graphics::Procedural::MeshGenerator< CylinderGenerator > | |
| CMezzanine::Graphics::Procedural::CylinderGenerator | A generator class for a cylinder mesh with flat ends |
| ►CMezzanine::Graphics::Procedural::MeshGenerator< Extruder > | |
| CMezzanine::Graphics::Procedural::Extruder | A generator that will create a 3D model by moving a 2D shape along a 3D Path |
| ►CMezzanine::Graphics::Procedural::MeshGenerator< IcoSphereGenerator > | |
| CMezzanine::Graphics::Procedural::IcoSphereGenerator | A generator class for a sphere mesh where all triangles are the same size |
| ►CMezzanine::Graphics::Procedural::MeshGenerator< Lathe > | |
| CMezzanine::Graphics::Procedural::Lathe | A generator that produces a Mesh by rotating a 2D shape around the Y axis |
| ►CMezzanine::Graphics::Procedural::MeshGenerator< MeshLoader > | |
| CMezzanine::Graphics::Procedural::MeshLoader | A generator class for loading an external mesh into a procedural buffer |
| ►CMezzanine::Graphics::Procedural::MeshGenerator< PlaneGenerator > | |
| CMezzanine::Graphics::Procedural::PlaneGenerator | A generator class for a plane mesh |
| ►CMezzanine::Graphics::Procedural::MeshGenerator< RoundedBoxGenerator > | |
| CMezzanine::Graphics::Procedural::RoundedBoxGenerator | A generator class for a rounded box mesh |
| ►CMezzanine::Graphics::Procedural::MeshGenerator< SphereGenerator > | |
| CMezzanine::Graphics::Procedural::SphereGenerator | A generator class for a sphere mesh |
| ►CMezzanine::Graphics::Procedural::MeshGenerator< TorusGenerator > | |
| CMezzanine::Graphics::Procedural::TorusGenerator | A generator class for a torus mesh |
| ►CMezzanine::Graphics::Procedural::MeshGenerator< TorusKnotGenerator > | |
| CMezzanine::Graphics::Procedural::TorusKnotGenerator | A generator class for a torus knot mesh |
| ►CMezzanine::Graphics::Procedural::MeshGenerator< Triangulator > | |
| CMezzanine::Graphics::Procedural::Triangulator | A generator class that implements the Delaunay Triangulation algorithm |
| ►CMezzanine::Graphics::Procedural::MeshGenerator< TubeGenerator > | |
| CMezzanine::Graphics::Procedural::TubeGenerator | A generator class for a tube mesh |
| CMezzanine::ActorFactory | A base factory type for the creation of Actor objects |
| CMezzanine::AngleLimits | Boundaries for rotation on one axis |
| ►CMezzanine::AreaEffectFactory | A base factory type for the creation of AreaEffect objects |
| CMezzanine::FieldOfForceFactory | A factory type for the creation of FieldOfForce objects |
| CMezzanine::GravityFieldFactory | A factory type for the creation of GravityField objects |
| CMezzanine::GravityWellFactory | A factory type for the creation of GravityWell objects |
| ►CMezzanine::AttachableBase | This class is the base class for other attachable classes and is responsible for transform updates to attachables |
| CMezzanine::AttachableChild | This class is the base class for objects that can be attached to AttachableParent |
| CMezzanine::AttachableParent | Base class for objects that can have attachables attached to them |
| CMezzanine::Audio::AutowahParameters | This is a struct containing all the parameters needed to describe an Auto-Wah effect |
| CMezzanine::Audio::ChorusParameters | This is a struct containing all the parameters needed to describe a Chorus effect |
| CMezzanine::Audio::CompressorParameters | This is a struct containing all the parameters needed to describe a compressor effect |
| CMezzanine::Audio::DistortionParameters | This is a struct containing all the parameters needed to describe a Distortion effect |
| CMezzanine::Audio::EAXReverbParameters | This is a struct containing all the parameters needed to describe an EAX Reverb effect |
| CMezzanine::Audio::EchoParameters | This is a struct containing all the parameters needed to describe an echo effect |
| CMezzanine::Audio::EqualizerParameters | This is a struct containing all the parameters needed to describe an equalizer effect |
| CMezzanine::Audio::FlangerParameters | This is a struct containing all the parameters needed to describe an flanger effect |
| CMezzanine::Audio::FrequencyShiftParameters | This is a struct containing all the parameters needed to describe a frequency shift effect |
| CMezzanine::Audio::iDecoder | This is an interface class for the decoding of audio from a stream |
| CMezzanine::Audio::iDecoderFactory | This is an interface class for factories that create decoders |
| CMezzanine::Audio::iEffect | This is an interface class for an effect that can be applied to a sound |
| CMezzanine::Audio::iEffectsHandler | This is an interface class for the creation, destruction, and overall management of audio effects |
| CMezzanine::Audio::iFilter | This is an interface class for the application of filters to audio playback |
| CMezzanine::Audio::iRecorder | This is an interface class for the recording of audio |
| ►CMezzanine::Audio::iSound | This is an interface class for a non-spacialized sound |
| CMezzanine::Audio::SoundProxy | This is a proxy class for representing a sound being played in 3D space |
| CMezzanine::Audio::MusicPlayer | This is a convenience class for the playing of music in a game |
| CMezzanine::Audio::PitchShifterParameters | This is a struct containing all the parameters needed to describe a pitch shift effect |
| CMezzanine::Audio::ReverbParameters | This is a struct containing all the parameters needed to describe a Reverb effect |
| CMezzanine::Audio::RingModulatorParameters | This is a struct containing all the parameters needed to describe a ring modulation effect |
| CMezzanine::Audio::VocalMorpherParameters | This is a struct containing all the parameters needed to describe a vocal morpher effect |
| CMezzanine::AxisAlignedBox | This is a utility class used to represent the Axis-Aligned Bounding Boxes of objects in various subsystems |
| CMezzanine::BezierInterpolator< T > | A simple functor for interpolating data points in a simple way |
| ►CMezzanine::BinaryTools::BinaryBuffer | A way to store and pass binary buffers, for example compiled bytecode |
| CMezzanine::Scripting::Lua::FlaggedBuffer | An expanded version of the BinaryTools::BinaryBuffer to carry one tiny piece of metadata around with it |
| CMezzanine::CameraController | This is a simplified controller class for use with cameras |
| CMezzanine::Circle | A generic circle class for geometry calculations |
| CMezzanine::ColourValue | This is a simple class for holding 4 reals representing the colour any give object or lightsource can have |
| CMezzanine::CountedPtr< TypePointedTo > | A simple reference counting pointer |
| CMezzanine::CountedPtrCastImpl< ReturnPointer, OriginalPointer, CountedPointerCastingState > | This is used as to determine how a CountedPtr performs castin between pointer types internally |
| CMezzanine::CountedPtrCastImpl< OriginalPointer, OriginalPointer, CastNoneError > | An implementation of the CountedPtrCast that always return the pointer passed reached via CastNoneError in the ReferenceCountTraits of the target class |
| CMezzanine::CountedPtrCastImpl< 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 |
| CMezzanine::CountedPtrCastImpl< ReturnPointer, OriginalPointer, CastImplicit > | An implementation of the CountedPtrCast that casts the passed pointer. Reached by putting CastStatic in the ReferenceCountTraits of the target class |
| CMezzanine::CountedPtrCastImpl< 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 |
| CMezzanine::CountedPtrCastImpl< 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 |
| CMezzanine::CubicSpline< TimeSeriesType, DataSeriesType > | A class for interpolating data with arbitrary |
| CMezzanine::CubicSplineElement< X, Y > | Meta data nodes required to generate a cubic spline |
| ►CMezzanine::DebrisFactory | A base factory type for the creation of Debris objects |
| CMezzanine::RigidDebrisFactory | A base factory type for the creation of non-deformable Debris objects |
| CMezzanine::SoftDebrisFactory | A base factory type for the creation of deformable Debris objects |
| CMezzanine::DefaultRollingAverage< RecordType > | Use this to get the default rolling average for a given type |
| CMezzanine::DeSerializer< DeSerializable > | A tool for deserializing classes with specific issues deserializing them |
| CMezzanine::Event | This class represents a given event that can be subscribed to and/or fired |
| ►CMezzanine::EventArguments | This is a common class to represent all possible arguments for a given event that is fired |
| CMezzanine::UI::ActionEventArguments | This is the base class for action specific event arguments |
| ►CMezzanine::UI::WidgetEventArguments | This is the base class for widget specific event arguments |
| CMezzanine::UI::ChildSelectedArguments | This is the EventArguments class for when a child of a paged container is selected |
| CMezzanine::UI::ScrollbarValueChangedArguments | This is the EventArguments class for when the scrollvalue of a scrollbar is updated |
| CMezzanine::UI::SpinnerValueChangedArguments | This is the EventArguments class for when the spinvalue of a Spinner is updated |
| ►CMezzanine::EventBase | The base class for all events |
| CMezzanine::EventGameWindow | Convey the message that Something happened to a game window |
| CMezzanine::EventQuit | This is intended to convey the message that quitting needs to happen |
| CMezzanine::EventUserInput | This is a container for MetaCodes that is used in the EventManager |
| CMezzanine::EventGameWindowData | Used to keep private in one place that is actually private |
| ►CMezzanine::EventPublisher | This is the base class for any class that generates and publishes events to subscribers |
| CMezzanine::UI::Action | This class represents an action to be taken. Can have multiple inputs bound to it |
| CMezzanine::UI::RadioButtonGroup | This is a class designed to facilitate operations across an entire group of RadioButtons |
| ►CMezzanine::UI::Widget | This is the base class for all widgets |
| ►CMezzanine::UI::Button | This class is a helper class, specifically for use as a button |
| ►CMezzanine::UI::CheckBox | This is a simple widget for storing a bool value |
| CMezzanine::UI::RadioButton | This is a simple widget where only one of it's selections can be selected at a time |
| CMezzanine::UI::StackButton | This is a button with additional data used to track the binding to a StackedContainer which can be serialized |
| CMezzanine::UI::DropDownList | This is a widget that displays one selection from a list that can have it's visibility toggled |
| CMezzanine::UI::EditBox | Widget for handling the input and manipulation of text |
| CMezzanine::UI::LayoutContainer | This is the base class for container objects that automatically position it's children |
| CMezzanine::UI::ListBox | This is a widget for displaying a list of captions in a box |
| ►CMezzanine::UI::PagedContainer | This is the base class for containers that have a render area and work area of different sizes |
| CMezzanine::UI::GridContainer | This is a container class for placing child objects on a 2 dimensional grid |
| ►CMezzanine::UI::LinearContainer | This is a container class for placing child objects in succession on a single axis |
| CMezzanine::UI::HorizontalContainer | A layout container that aligns it's children along a common X axis |
| CMezzanine::UI::VerticalContainer | A layout container that aligns it's children along a common Y axis |
| ►CMezzanine::UI::PageProvider | This is the base class for interpretting widget values to page positions |
| ►CMezzanine::UI::Scrollbar | This is the scrollbar base class |
| CMezzanine::UI::HorizontalScrollbar | This is a scrollbar class aligned on the X axis |
| CMezzanine::UI::VerticalScrollbar | This is a scrollbar class aligned on the Y axis |
| CMezzanine::UI::Spinner | This is a simple widget for a numeric variable in a box |
| ►CMezzanine::UI::StackedContainer | This is the base class for containers that stack their children one on top of the other |
| CMezzanine::UI::MenuEntry | This class is an entry for a single window/widget in a menu |
| CMezzanine::UI::TabSet | This is a widget that stores sets of renderables but only displays one at a time |
| ►CMezzanine::EventSubscriber | This is a base class for all classes that subscribe to events |
| CMezzanine::UI::Widget | This is the base class for all widgets |
| ►CMezzanine::EventSubscriberSlot | This class represents a slot in an event that can be subscribed to via subscribers, functors, or methods |
| CMezzanine::CFunctionSubscriberSlot | This is a subscriber slot class that triggers a Free/C-style function |
| CMezzanine::CustomSubscriberSlot | This is a subscriber slot class that passes on the event firing to a custom subscriber class |
| CMezzanine::FunctorSubscriberSlot | This is a subscriber slot class that makes the appropriate call on a functor |
| CMezzanine::ScriptSubscriberSlot | This is a subscriber slot class that triggers a provided script |
| CMezzanine::ExceptionFactory< N > | Template class that serves as the base for exception factories |
| CMezzanine::ExceptionFactory< ArithmeticException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< DirectoryException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< DirectoryNotFoundException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< DirectoryPermissionException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< DirectoryReadException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< DirectoryWriteException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< FileException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< FileNotFoundException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< FilePermissionException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< FileReadException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< FileWriteException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< InstanceIdentityDuplicateException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< InstanceIdentityException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< InstanceIdentityInvalidException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< InstanceIdentityNotFoundException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< InternalException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< InvalidAssignment::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< InvalidStateException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< InvalidVersionException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< IOException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< IOReadException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< IOWriteException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< MemoryManagementException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< MemoryOutOfBoundsException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< NetworkException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< NetworkNotFoundException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< NetworkPermissionException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< NetworkReadException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< NetworkURLException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< NetworkWriteException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< NotImplementedException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< OutOfMemoryException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< ParametersCastException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< ParametersException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< ParametersRangeException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< RenderingAPIException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< RuntimeAssertionException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< ScriptException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< ScriptLuaErrErrException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< ScriptLuaException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< ScriptLuaRuntimeException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< ScriptLuaYieldException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< SyntaxErrorException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< SyntaxErrorLuaException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< SyntaxErrorXMLException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::ExceptionFactory< SyntaxErrorXPathException::ExceptionCode > | Template class that serves as the base for exception factories. |
| CMezzanine::FunctorEventSubscriber | Basic class definition for functors used by a FunctorSubscriberSlot |
| CMezzanine::Graphics::Billboard | This is the proxy class for placing and manipulating a set of 2D billboards in the scene |
| CMezzanine::Graphics::GameWindow | This class is for creating and managing game windows |
| CMezzanine::Graphics::Image | This class represents an image loaded into system memory |
| CMezzanine::Graphics::InternalImageData | This class is used to store the internal structures needed by the Image class |
| CMezzanine::Graphics::InternalMaterialData | This class is used to store the internal structures needed by the Material class |
| CMezzanine::Graphics::InternalMeshData | This class is used to store the internal structures needed by the Mesh class |
| CMezzanine::Graphics::InternalSkeletonData | This class is used to store the internal structures needed by the Skeleton class |
| CMezzanine::Graphics::InternalTextureData | This class is used to store the internal structures needed by the Texture class |
| CMezzanine::Graphics::Material | This class represents all the rendering passes a rendered object has |
| CMezzanine::Graphics::Mesh | This class is used to check and modify the properties of a graphics mesh |
| CMezzanine::Graphics::MeshInfo | A convenience class for the storage of rendering data in a Mesh/SubMesh |
| CMezzanine::Graphics::ParticleAffector | This class defines how particles of a given particle effect behave during their lifetime |
| CMezzanine::Graphics::ParticleEmitter | This class defines how particles of a given particle effect spawn |
| CMezzanine::Graphics::Pass | This class represents one rendering pass for a graphics object |
| CMezzanine::Graphics::Procedural::BufferSection | A convenience class used to describe a small portion of the mesh/buffer |
| CMezzanine::Graphics::Procedural::CombineLayer | Convenience class used by the CombineModifier class to describe what action to take with a specific texture to be combined |
| CMezzanine::Graphics::Procedural::DelaunaySegment | A segment of 2 points in a Point2DContainer |
| CMezzanine::Graphics::Procedural::DelaunayTriangle | A triangle formed from 3 points in a Point2DContainer |
| CMezzanine::Graphics::Procedural::IntersectionInShape | Convenience class storing data on the point in a 2D shape where multiple segments intersect |
| CMezzanine::Graphics::Procedural::IntVector2 | Convenience class for pixel processing |
| CMezzanine::Graphics::Procedural::MeshGenerator< T > | A base class containing all of the utilities needed for a mesh generator |
| ►CMezzanine::Graphics::Procedural::MeshModifier | A base class for modifying the contents of an already populated triangle buffer |
| CMezzanine::Graphics::Procedural::BoxUVModifier | A modifier that will generate UV coordinates as they would need to be on a box model |
| CMezzanine::Graphics::Procedural::CylinderUVModifier | A modifier that will generate UV coordinates as they would need to be on a cylinder model |
| CMezzanine::Graphics::Procedural::HemisphereUVModifier | A modifier that will generate UV coordinates as they would need to be on a hemisphere model |
| CMezzanine::Graphics::Procedural::PlaneUVModifier | A modifier that will generate UV coordinates as they would need to be on a plane model |
| CMezzanine::Graphics::Procedural::SphereUVModifier | A modifier that will generate UV coordinates as they would need to be on a sphere model |
| CMezzanine::Graphics::Procedural::SpherifyModifier | A modifier that will increase or decrease the distance to a point to match a specified radius |
| CMezzanine::Graphics::Procedural::VertexNormalsModifier | |
| CMezzanine::Graphics::Procedural::VertexTransformModifier | A modifier that will update the transform of every vertex in a mesh |
| CMezzanine::Graphics::Procedural::VertexUVModifier | A modifier that will transform the UV coordinates of a mesh |
| CMezzanine::Graphics::Procedural::WeldVerticesModifier | A modifier that will combine vertices together that are close to each other |
| CMezzanine::Graphics::Procedural::MultiPath | A grouping of individual 3D curves used to express complicated structures |
| CMezzanine::Graphics::Procedural::MultiShape | A grouping of individual 2D shapes used to express more elaborate shapes |
| CMezzanine::Graphics::Procedural::Path | A collection of interconnected 3D points used to express path through 3D space |
| CMezzanine::Graphics::Procedural::PathCoordinate | A convenience class for tracking points in a MultiPath |
| CMezzanine::Graphics::Procedural::Shape | A collection of interconnected 2D points used to express an arbitrary 2D shape |
| CMezzanine::Graphics::Procedural::TextureBuffer | A convenience buffer that stores pixel colour values of a texture to be generated |
| ►CMezzanine::Graphics::Procedural::TextureGenerator | A base class for texture generators that use the TextureBuffer class |
| CMezzanine::Graphics::Procedural::AtlasGenerator | A generator that will produce an image that is a number of other images placed side by side with no overlap |
| CMezzanine::Graphics::Procedural::CellGenerator | Create a texture consisting of cells aligned in a grid, or a chessboard |
| CMezzanine::Graphics::Procedural::CloudGenerator | Creates a cloud structured image |
| CMezzanine::Graphics::Procedural::GradientGenerator | Fills full image with given colour gradients |
| CMezzanine::Graphics::Procedural::ImageGenerator | Creates an image to be modified from a pre-existing image on disk |
| CMezzanine::Graphics::Procedural::LabyrinthGenerator | Creates a labyrinth structured image |
| CMezzanine::Graphics::Procedural::LerpGenerator | Creates a texture that is the interpolated result between two other textures |
| CMezzanine::Graphics::Procedural::MarbleGenerator | Creates a marble structured image |
| CMezzanine::Graphics::Procedural::NoiseGenerator | Fills full image with noise in a given colour |
| CMezzanine::Graphics::Procedural::SolidGenerator | Fills full image with given colour |
| CMezzanine::Graphics::Procedural::TextileGenerator | Creates a textile structured image |
| CMezzanine::Graphics::Procedural::WoodGenerator | Creates a wood slice image |
| ►CMezzanine::Graphics::Procedural::TextureModifier | A base class for modifying the contents of an already populated texture buffer |
| CMezzanine::Graphics::Procedural::AlphaMaskModifier | A modifier that will use a mask image to set the alpha channels of a source image |
| CMezzanine::Graphics::Procedural::AlphaModifier | A modifier that will replace all pixels with "White Smoke" corresponding to the intensity of the extracted colour and the source alpha channel |
| CMezzanine::Graphics::Procedural::BlitModifier | A modifier that will copy a portion of one texture and place it into another |
| CMezzanine::Graphics::Procedural::BlurModifier | A modifier that will attempt to reduce the sharpness of the texture |
| CMezzanine::Graphics::Procedural::ChannelModifier | A modifier that will zero out selected colour channels or produce a grey version of the provided texture |
| CMezzanine::Graphics::Procedural::CircleModifier | A modifier that draws a simple coloured circle onto the texture |
| CMezzanine::Graphics::Procedural::ColoursModifier | A modifier that will alter the basic colour properties of the texture |
| CMezzanine::Graphics::Procedural::CombineModifier | A modifier that will attempt to combine the content of multiple textures |
| CMezzanine::Graphics::Procedural::ConvolutionModifier | A modifier that will calculate each pixel in an image to be a weighed sum of itself and it's neighbors |
| CMezzanine::Graphics::Procedural::CrackModifier | A modifier that will generate random coloured lines on a texture |
| CMezzanine::Graphics::Procedural::CycloidModifier | A modifier that will draw a series of curved line segments |
| CMezzanine::Graphics::Procedural::DilateModifier | A modifier that will bright areas of the texture over the darker areas of the image |
| CMezzanine::Graphics::Procedural::EdgeDetectionModifier | A modifier that will reduce the texture to an outline of the detected edges in the texture |
| CMezzanine::Graphics::Procedural::EllipseModifier | A modifier that draws a simple coloured ellipse onto the texture |
| CMezzanine::Graphics::Procedural::FlareModifier | A modifier that will draw an illuminated circle that fades over a distance to a previous texture |
| CMezzanine::Graphics::Procedural::FlipModifier | A modifier that will flip pixels along an axis or axes in a texture |
| CMezzanine::Graphics::Procedural::InvertModifier | A modifier that will invert the value of each colour channel for each pixel |
| CMezzanine::Graphics::Procedural::JitterModifier | A modifier that will randomly shuffle the pixel being processed to a nearby position |
| CMezzanine::Graphics::Procedural::LookupModifier | A modifier that uses an image to lookup and copy pixels of another image |
| CMezzanine::Graphics::Procedural::NormalsModifier | A modifier that will convery a greyscale image into a normals map |
| CMezzanine::Graphics::Procedural::OilPaintModifier | A modifier that will group similiar pixels together and normalize their colour |
| CMezzanine::Graphics::Procedural::RandomPixelsModifier | A modifer that will draw coloured pixels at random positions on the texture |
| CMezzanine::Graphics::Procedural::RectangleModifier | A modifier that draws a simple coloured rectangle onto the texture |
| CMezzanine::Graphics::Procedural::RotationZoomModifier | A modifier that will apply a rotation to the image and optionally zoom in on it |
| CMezzanine::Graphics::Procedural::SegmentModifier | A modifier that will alter the colour of pixels above a certain luminous value |
| CMezzanine::Graphics::Procedural::SharpenModifier | A modifier that will attempt to add detail to a texture |
| CMezzanine::Graphics::Procedural::TextTextureModifier | A modifier to add text to a texture |
| CMezzanine::Graphics::Procedural::ThresholdModifier | A modifier that will set a pixels colour if it's intensity is outside a set threshold |
| CMezzanine::Graphics::Procedural::VortexModifier | Twists the pixel positions in a circle on the Texture |
| CMezzanine::Graphics::Procedural::WeighedLerpModifier | A modifier that will use the colours of the texture to be modified to perform a linear interpolation between two other textures |
| CMezzanine::Graphics::Procedural::TouchSuperTriangle | A triangle convenience class for some comparison operations |
| CMezzanine::Graphics::Procedural::TriangleBuffer | A convenience buffer that stores vertices and indices of a mesh to be generated |
| CMezzanine::Graphics::Procedural::Vertex | A simple definition for a Vertex to be used when procedurally generating meshes |
| CMezzanine::Graphics::Resolution | This stores all the basic configuration options a game window supports |
| CMezzanine::Graphics::SceneManagerData | Stores internal data for the SCeneManager to keep it from cluttering the Header file |
| CMezzanine::Graphics::Skeleton | This class encapsulates the Skeletal animation functionality of a Mesh |
| CMezzanine::Graphics::SubMesh | This class represents a sub-section of an overall mesh |
| CMezzanine::Graphics::Technique | This class represents a collection of passes an object has for it's rendering |
| CMezzanine::Graphics::Texture | This class represents a texture loaded into video memory |
| CMezzanine::Graphics::VertexInfo | A convenience class for the storage of Vertex data in a Mesh/SubMesh |
| CMezzanine::Graphics::Viewport | This class is for creating and managing viewports within a game window |
| CMezzanine::Graphics::WindowSettings | This stores all the basic configuration options a game window supports |
| CMezzanine::HashedString32 | An identifier that compares as fast as an integer but has a string |
| ►CMezzanine::Input::Device | This is a base class for all input devices |
| ►CMezzanine::Input::ButtonDevice | This is a base class for all input devices with buttons |
| CMezzanine::Input::Controller | This class represents a controller input device, such as a gamepad or joystick |
| CMezzanine::Input::Keyboard | This class represents the keyboard input device. //////////////////////////////////// |
| CMezzanine::Input::Mouse | This class represents the mouse input device |
| CMezzanine::Input::InputManagerInternalData | This is an class for the handling of internal input data |
| CMezzanine::Input::MetaCode | This Determines the kind of user input |
| CMezzanine::Input::MetaCodeKey | A key class for MetaCodes to be used in associative containers |
| CMezzanine::Input::SequenceContainer | This class stores and provides utilities for sequenced inputs and their operations |
| CMezzanine::Internal::EventManagerInternalData | Used to increase encapsulation, just a bit |
| CMezzanine::Internal::LineVertex | A small declaration of what our vertexs look like for when we write to the buffers |
| CMezzanine::Interval< NumType > | This class will generate keep track of a pool of unique 32-bit ID's that can be used for distinct object instances |
| CMezzanine::IntHandle | Sample implementation for a ManagedPtr |
| ►CMezzanine::IntrusiveRefCount | A sample class that implements a minimal intrusive reference counting scheme |
| ►CMezzanine::Scripting::iScriptArgument | The interface for a script argument |
| CMezzanine::Scripting::ScriptArgumentGeneric< T > | A generic implementation of a ScriptArgument that is suitable for primitive types in most situations |
| ►CMezzanine::Scripting::ScriptArgumentGeneric< Boole > | A Bool implementation of a ScriptArgument that is suitable for primitive types in most situations |
| CMezzanine::Scripting::Lua::Lua51BoolArgument | No special care is required for Bool Lua Arguments, so a simple typedef is used |
| ►CMezzanine::Scripting::ScriptArgumentGeneric< Integer > | A Integer implementation of a ScriptArgument that is suitable for primitive types in most situations |
| CMezzanine::Scripting::Lua::Lua51IntegerArgument | The implementations in the ScriptArgumentGeneric<Integer> will cover most of what this needs |
| ►CMezzanine::Scripting::ScriptArgumentGeneric< NullArgument > | A Null implementation of a ScriptArgument that is suitable for primitive types in most situations |
| CMezzanine::Scripting::Lua::Lua51NilArgument | Represents not much of anything but will insert and retrieves Nils from Lua51 |
| ►CMezzanine::Scripting::ScriptArgumentGeneric< Real > | A Real number implementation of a ScriptArgument that is suitable for primitive types in most situations |
| CMezzanine::Scripting::Lua::Lua51RealArgument | A Real that can readily be passed into lua scripts |
| ►CMezzanine::Scripting::ScriptArgumentGeneric< String > | A String implementation of a ScriptArgument that is suitable for primitive types in most situations |
| CMezzanine::Scripting::Lua::Lua51StringArgument | No special care is required for String Lua Arguments, so a simple typedef is used |
| ►CMezzanine::Scripting::ScriptArgumentGeneric< Whole > | A Whole number implementation of a ScriptArgument that is suitable for primitive types in most situations |
| CMezzanine::Scripting::Lua::Lua51WholeArgument | No special care is required for Whole number Lua Arguments, so a simple typedef is used |
| CMezzanine::LinearInterpolator< T > | A simple functor for interpolating data points in a simple way |
| CMezzanine::LineGroup | This is a group of consectutive line segments to be rendered together |
| CMezzanine::LineSegment2D | A geometry math class for expressing a line connecting 2 points in 2D space |
| CMezzanine::LineSegment3D | A geometry math class for expressing a line connecting 2 points in 3D space |
| CMezzanine::ManagedPtr< Handle > | This is used to get RAII semantics when not provided inherently |
| ►CMezzanine::ManagerBase | This is the base class from which all the Entresol and World Managers inherit |
| ►CMezzanine::EntresolManager | This is the base class for all managers that do no describe properties of a single world, but rather engine-wide functionality |
| CMezzanine::Audio::AudioManager | This is the base manager class for the Audio subsystem and it's operations |
| CMezzanine::EventManager | This is a container for Events and facilitates the transfer of data |
| CMezzanine::Graphics::GraphicsManager | This is intended to store basic graphics setting for the user |
| CMezzanine::Graphics::MeshManager | This manager handles the storage, generation, and query of of Graphics Meshes |
| CMezzanine::Graphics::TextureManager | This manager handles the storage and query of of Graphics Textures |
| CMezzanine::Input::InputManager | This is the manager responsible for the handling of input devices and events |
| CMezzanine::Network::NetworkManager | This is the central management class for all network I/O operations |
| CMezzanine::Physics::CollisionShapeManager | This manager is for the storage of all shapes and creation of mesh shapes |
| CMezzanine::Resource::ResourceManager | This is the manager responsible for the loading and unloading of files |
| ►CMezzanine::Scripting::iScriptingManager | What a scripting manager should look like |
| ►CMezzanine::Scripting::iScriptCompilationManager | What a scripting manager should look like |
| CMezzanine::Scripting::Lua::Lua51ScriptingEngine | The workhorse of the Lua scripting system. All scripts come here to be executed |
| CMezzanine::UI::UIManager | This class is responsible for any and all user interactions with the User interface/HUD |
| ►CMezzanine::WorldManager | This is the base class for all managers that belong to a single world instance |
| CMezzanine::ActorManager | A manager responsible for the storage and management of all actors that exist in a world |
| CMezzanine::AreaEffectManager | A manager responsible for the storage and management of all areaeffects in use |
| CMezzanine::Audio::SoundScapeManager | This is the base manager class for audio being played in a 3D environment |
| CMezzanine::DebrisManager | A manager responsible for the storage and management of all Debris that exist in a world |
| CMezzanine::Graphics::SceneManager | This class contains utilities and functions to allow the manipulation of the Graphical scene, rather then the physics inside, or the object inside |
| CMezzanine::Physics::PhysicsManager | This is simply a place for storing all the Physics Related functions |
| CMezzanine::TerrainManager | This is manager for terrains and their functions |
| ►CMezzanine::ManagerFactory | This is a base class for factories that construct the managers the engine uses |
| ►CMezzanine::EntresolManagerFactory | This is a base class for factories that construct managers used by the Entresol class |
| CMezzanine::DefaultEventManagerFactory | A factory responsible for the creation and destruction of the default eventmanager |
| CMezzanine::Graphics::DefaultGraphicsManagerFactory | A factory responsible for the creation and destruction of the default graphicsmanager |
| CMezzanine::Graphics::DefaultMeshManagerFactory | A factory responsible for the creation and destruction of the default MeshManager |
| CMezzanine::Graphics::DefaultTextureManagerFactory | A factory responsible for the creation and destruction of the default TextureManager |
| CMezzanine::Input::DefaultInputManagerFactory | A factory responsible for the creation and destruction of the default inputmanager |
| CMezzanine::Network::DefaultNetworkManagerFactory | A factory responsible for the creation and destruction of the default networkmanager |
| CMezzanine::Physics::DefaultCollisionShapeManagerFactory | A factory responsible for the creation and destruction of the default collisionshapemanager |
| CMezzanine::Resource::DefaultResourceManagerFactory | A factory responsible for the creation and destruction of the default resourcemanager |
| CMezzanine::Scripting::Lua::Lua51ScriptingEngineFactory | A factory responsible for the creation and destruction of the default scripting engine providing Lua 5.1 support |
| CMezzanine::UI::DefaultUIManagerFactory | A factory responsible for the creation and destruction of the default uimanager |
| ►CMezzanine::WorldManagerFactory | This is a base class for factories that construct managers used by the World class |
| CMezzanine::DefaultActorManagerFactory | A factory responsible for the creation and destruction of the default actormanager |
| CMezzanine::DefaultAreaEffectManagerFactory | A factory responsible for the creation and destruction of the default areaeffectmanager |
| CMezzanine::DefaultDebrisManagerFactory | A factory responsible for the creation and destruction of the default DebrisManager |
| CMezzanine::DefaultTerrainManagerFactory | A factory responsible for the creation and destruction of the default terrainmanager |
| CMezzanine::Graphics::DefaultSceneManagerFactory | A factory responsible for the creation and destruction of the default scenemanager |
| CMezzanine::Physics::DefaultPhysicsManagerFactory | A factory responsible for the creation and destruction of the default physicsmanager |
| CMezzanine::Matrix3x3 | This is a 3x3 Matrix class used for representing rotations and scaling in an object |
| CMezzanine::Matrix4x4 | A 4x4 matrix math class for the representation of full transforms |
| CMezzanine::Network::Connection | A base class for the state of a connection made between peers |
| ►CMezzanine::Network::FTPMessage | A base class for text based messages exchanged between FTP clients and servers |
| CMezzanine::Network::FTPCommand | A command that can be issued to an FTP server |
| CMezzanine::Network::FTPResponse | A response to a command generated by a FTP server |
| CMezzanine::Network::HeaderField | Convenience class for storing Header fields in internet messaging protocols |
| CMezzanine::Network::HTTPClient | |
| ►CMezzanine::Network::HTTPMessage | A base class for HTTP text parsing classes |
| CMezzanine::Network::HTTPRequest | A simple class to facilitate the creation of HTTP requests |
| CMezzanine::Network::HTTPResponse | A response to an HTTPRequest generated by an HTTP server |
| CMezzanine::Network::IPAddress | This is a simple class for representing IP addresses used throughout the Network subsystem |
| CMezzanine::Network::Packet | A base class for packing information to be transferred over the network |
| CMezzanine::Network::PlatformSocket | This is helper class for managing platform specific data of socket implementations |
| ►CMezzanine::Network::Socket | This is a basic socket interface for the transmission and retrieval of packets |
| ►CMezzanine::Network::IPv4Socket | A socket class using the IP version 4 protocol |
| CMezzanine::Network::TCPv4Socket | A TCP socket that uses IPv4 internet addresses for connections |
| CMezzanine::Network::UDPv4Socket | A UDP socket that uses IPv4 internet addresses for transmissions |
| ►CMezzanine::Network::IPv6Socket | A socket class using the IP version 6 protocol |
| CMezzanine::Network::TCPv6Socket | A TCP socket that uses IPv6 internet addresses for connections |
| CMezzanine::Network::UDPv6Socket | A UDP socket that uses IPv6 internet addresses for transmissions |
| ►CMezzanine::Network::TCPSocket | A socket class using the TCP stream protocol |
| CMezzanine::Network::TCPv4Socket | A TCP socket that uses IPv4 internet addresses for connections |
| CMezzanine::Network::TCPv6Socket | A TCP socket that uses IPv6 internet addresses for connections |
| ►CMezzanine::Network::UDPSocket | A socket class using the User Datagram Protocol |
| CMezzanine::Network::UDPv4Socket | A UDP socket that uses IPv4 internet addresses for transmissions |
| CMezzanine::Network::UDPv6Socket | A UDP socket that uses IPv6 internet addresses for transmissions |
| CMezzanine::Network::SocketDescription | A convenience class storing socket data that can be returned from utility methods and used to create and init new sockets |
| CMezzanine::Network::SocketHandle | Used to allow type inference on PlatformSocket constructors |
| CMezzanine::Network::SocketResultContainer | A special container class used to store the results from a call to "ResolveDomainName" |
| CMezzanine::Network::SystemAddress | A simple class that stores a complete set of information for establishing connections |
| CMezzanine::Network::URI | A helper class for the reading and using of Uniform Resource Identifiers |
| CMezzanine::ObjectSettingFile | This class represents a file to be saved containing one or more OhjectSettingGroup's |
| ►CMezzanine::ObjectSettingSetContainer | A base class for other classes that store ObjectSettingSet's |
| CMezzanine::ObjectSettingGroup | A class that store's a collection of SettingSets that can be applied together |
| CMezzanine::ObjectSettingSet | A class that store's a named set of settings for an object |
| ►CMezzanine::ObjectSettingsHandler | An abstract class for other classes that manage groups of settings |
| CMezzanine::Audio::AudioManager | This is the base manager class for the Audio subsystem and it's operations |
| CMezzanine::Graphics::GraphicsManager | This is intended to store basic graphics setting for the user |
| CMezzanine::Physics::CollidablePair | This is a helper class for storing pairs of collidable proxies in associative containers |
| CMezzanine::Physics::Collision | This is an event class used to track collsions in the physics world |
| CMezzanine::Physics::CollisionInternalData | Used to insulate the interface from the implementation details for bullet |
| ►CMezzanine::Physics::CollisionShape | This is the base class for all collision shapes |
| CMezzanine::Physics::CompoundCollisionShape | A collision shape composed of many other collision shapes placed and oriented in local space |
| ►CMezzanine::Physics::FieldCollisionShape | This is the base class for all Field shapes |
| CMezzanine::Physics::HeightfieldCollisionShape | A series of values that store hieght in a grid like fashion |
| CMezzanine::Physics::PlaneCollisionShape | A Flat wall/floor of limitless size |
| ►CMezzanine::Physics::MeshCollisionShape | This is the base class for all Mesh shapes |
| CMezzanine::Physics::DynamicMeshCollisionShape | A triangle mesh collsion shape based on a graphics mesh |
| CMezzanine::Physics::SoftCollisionShape | A collision shape for soft proxies |
| CMezzanine::Physics::StaticMeshCollisionShape | A triangle mesh collsion shape based on a graphics mesh |
| ►CMezzanine::Physics::PrimitiveCollisionShape | This is the base class for all Primitive shapes |
| CMezzanine::Physics::BoxCollisionShape | A box physics shape |
| CMezzanine::Physics::CapsuleCollisionShape | A capsule physics shape |
| CMezzanine::Physics::ConeCollisionShape | A cone physics shape |
| CMezzanine::Physics::ConvexHullCollisionShape | A simple convex shape built from a low number of points in local space |
| CMezzanine::Physics::CylinderCollisionShape | A cylinder physics shape |
| CMezzanine::Physics::MultiSphereCollisionShape | A physics shape comprised of multiple sphere's placed in local space |
| CMezzanine::Physics::SphereCollisionShape | A sphere physics shape |
| ►CMezzanine::Physics::Constraint | This is the base class for all constraints supported |
| ►CMezzanine::Physics::DualTransformConstraint | All constraints that track rotation and location of the Pivot relative to each Actor inherit from this |
| CMezzanine::Physics::ConeTwistConstraint | This is a constraint that will limit the movement allowed from one body to within a cone area around another object |
| ►CMezzanine::Physics::Generic6DofConstraint | Create simple but specific limits on any axis of movement or rotation |
| ►CMezzanine::Physics::Generic6DofSpringConstraint | Creates a constraint as configurable as the 6Dof constraint, but has added support for spring motion |
| CMezzanine::Physics::Hinge2Constraint | 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 |
| CMezzanine::Physics::UniversalConstraint | This is a constraint for sharing the rotation of one object along an angular axis with another |
| CMezzanine::Physics::HingeConstraint | This is a constraint to be used to restrict the movement between two objects to angular rotation on a single axis |
| CMezzanine::Physics::SliderConstraint | This is a constraint for permitting movement on only a singular linear or angular axis |
| CMezzanine::Physics::GearConstraint | This is a constraint that duplicate the angular motion of one object to another, adjusted by the provided ratio |
| CMezzanine::Physics::Point2PointConstraint | Tries to make a point relative to each of two actors match in 3d space, without regard to rotation |
| CMezzanine::Physics::ManagerConstructionInfo | This is a helper class storing information needed for the construction of a PhysicsManager |
| CMezzanine::Physics::StickyConstraintConstructionInfo | Simple struct for holding information on how sticky constraints should be constructed |
| CMezzanine::Physics::StickyData | This is a basic class for storing the data related to the sticky behavior available to rigid bodies |
| CMezzanine::Plane | This is used to represent a flat infinite slice of the game world |
| CMezzanine::Quaternion | This is used to store information about rotation in 3d space |
| CMezzanine::Ray | This represents a line placed in 3D space and is used with spacial queries |
| CMezzanine::RayQueryTool | This provides a number of optional tools for working with a Mezzanine::World |
| CMezzanine::RectBase< NumType > | A class for tracking a rectangle by tracking two corners Top, Left and Right, Bottom |
| CMezzanine::ReferenceCount< TypePointedTo > | This exists once per object managed by a group of shared pointer to track items in memory |
| CMezzanine::ReferenceCountTraits< T > | This is used to deduce at compile if a specific class has built-in reference counting or needs an external reference count |
| CMezzanine::ReferenceCountTraits< EventArguments > | This is a metaprogramming traits class used by EventArguments |
| CMezzanine::ReferenceCountTraits< IntrusiveRefCount > | An Example ReferenceCountTraits implmentation |
| CMezzanine::ReferenceCountTraits< Scripting::iScript > | Marks IScript for internal reference counting if a CountedPtr checks |
| CMezzanine::ReferenceCountTraits< Scripting::iScriptArgument > | Marks iScriptArgument for internal reference counting if a CountedPtr checks |
| CMezzanine::ReferenceCountTraits< Scripting::iScriptCompilable > | Marks iScriptCompilable for internal reference counting if a CountedPtr checks |
| CMezzanine::ReferenceCountTraits< Scripting::iScriptMultipleReturn > | Marks iScriptMultipleReturn for internal reference counting if a CountedPtr checks |
| CMezzanine::ReferenceCountTraits< Scripting::Lua::Lua51BoolArgument > | Marks Lua51BoolArgument for internal reference counting if a CountedPtr checks |
| CMezzanine::ReferenceCountTraits< Scripting::Lua::Lua51IntegerArgument > | Marks Lua51IntegerArgument for internal reference counting if a CountedPtr checks |
| CMezzanine::ReferenceCountTraits< Scripting::Lua::Lua51NilArgument > | Marks Lua51NilArgument for internal reference counting if a CountedPtr checks |
| CMezzanine::ReferenceCountTraits< Scripting::Lua::Lua51RealArgument > | Marks Lua51RealArgument for internal reference counting if a CountedPtr checks |
| CMezzanine::ReferenceCountTraits< Scripting::Lua::Lua51Script > | Marks Lua51Script for internal reference counting if a CountedPtr checks |
| CMezzanine::ReferenceCountTraits< Scripting::Lua::Lua51StringArgument > | Marks Lua51StringArgument for internal reference counting if a CountedPtr checks |
| CMezzanine::ReferenceCountTraits< Scripting::Lua::Lua51WholeArgument > | Marks Lua51WholeArgument for internal reference counting if a CountedPtr checks |
| CMezzanine::ReferenceCountTraits< Scripting::Lua::LuaArgument > | Marks LuaArgument for internal reference counting if a CountedPtr checks |
| CMezzanine::ReferenceCountTraits< Scripting::ScriptArgumentGeneric< Boole > > | Marks ScriptArgumentGeneric<Real> for internal reference counting if a CountedPtr checks |
| CMezzanine::ReferenceCountTraits< Scripting::ScriptArgumentGeneric< Integer > > | Marks ScriptArgumentGeneric<Integer> for internal reference counting if a CountedPtr checks |
| CMezzanine::ReferenceCountTraits< Scripting::ScriptArgumentGeneric< Real > > | Marks ScriptArgumentGeneric<Real> for internal reference counting if a CountedPtr checks |
| CMezzanine::ReferenceCountTraits< Scripting::ScriptArgumentGeneric< Scripting::NullArgument > > | Marks ScriptArgumentGeneric<Real> for internal reference counting if a CountedPtr checks |
| CMezzanine::ReferenceCountTraits< Scripting::ScriptArgumentGeneric< String > > | Marks ScriptArgumentGeneric<String> for internal reference counting if a CountedPtr checks |
| CMezzanine::ReferenceCountTraits< Scripting::ScriptArgumentGeneric< Whole > > | Marks ScriptArgumentGeneric<Whole> for internal reference counting if a CountedPtr checks |
| CMezzanine::ReferenceCountTraits< UI::ActionEventArguments > | This is a metaprogramming traits class used by ActionEventArguments |
| CMezzanine::ReferenceCountTraits< UI::ChildSelectedArguments > | This is a metaprogramming traits class used by ChildFocusEventArguments |
| CMezzanine::ReferenceCountTraits< UI::ScrollbarValueChangedArguments > | This is a metaprogramming traits class used by ScrollbarValueChangedArguments |
| CMezzanine::ReferenceCountTraits< UI::SpinnerValueChangedArguments > | This is a metaprogramming traits class used by SpinnerValueChangedArguments |
| CMezzanine::ReferenceCountTraits< UI::WidgetEventArguments > | This is a metaprogramming traits class used by WidgetEventArguments |
| CMezzanine::Resource::Archive | |
| CMezzanine::Resource::Asset | A convenience base class for objects that may need common IO operations exposed for them |
| CMezzanine::Resource::AssetGroup | This is a class that stores a specific grouping of Assets, usually based on thier location |
| CMezzanine::Resource::AssetHandler | |
| CMezzanine::Resource::AssetID | This is a simple class storing the name and group identification of an Asset/Stream |
| ►CMezzanine::Resource::iStreamBase | Base class interface for resource streams |
| ►CMezzanine::Resource::iInStream | Interface class for input (read) streams |
| ►CMezzanine::Resource::IOStream | Base class for streams that support both read and write operations |
| CMezzanine::Resource::FileStream | This represents a stream to a file on disk using the C++ file stream API |
| CMezzanine::Resource::MemoryStream | An I/O stream to a buffer of memory |
| CMezzanine::Resource::IStream | Base class for input (read) streams with minimal implementation |
| ►CMezzanine::Resource::iOutStream | Interface class for output (write) streams |
| CMezzanine::Resource::IOStream | Base class for streams that support both read and write operations |
| CMezzanine::Resource::OStream | Base class for output (write) streams with minimal implementation |
| ►CMezzanine::RollingAverage< RecordType > | The interface for rolling averages used in the Mezzanine, and threading library |
| CMezzanine::BufferedRollingAverage< RecordType > | A RollingAverage that stores a copy of each record. and does the math when queried |
| CMezzanine::WeightedRollingAverage< RecordType, MathType > | A weighted average that does math with every insertion and stores nothing |
| ►CMezzanine::Scripting::iScript | The interface for a script |
| ►CMezzanine::Scripting::iScriptCompilable | The interface for a script that can be compiled to bytecode |
| CMezzanine::Scripting::Lua::Lua51Script | This class is used to store a Lua script and in its source and compiled state |
| ►CMezzanine::Scripting::iScriptMultipleReturn | This script can return simple group of values |
| CMezzanine::Scripting::Lua::Lua51Script | This class is used to store a Lua script and in its source and compiled state |
| ►CMezzanine::Scripting::Lua::LuaArgument | The ScriptArgumentGeneric<T> needs just a bit of Lua specific functionality so we add push/pop for the LuaScript to call |
| CMezzanine::Scripting::Lua::Lua51BoolArgument | No special care is required for Bool Lua Arguments, so a simple typedef is used |
| CMezzanine::Scripting::Lua::Lua51IntegerArgument | The implementations in the ScriptArgumentGeneric<Integer> will cover most of what this needs |
| CMezzanine::Scripting::Lua::Lua51NilArgument | Represents not much of anything but will insert and retrieves Nils from Lua51 |
| CMezzanine::Scripting::Lua::Lua51RealArgument | A Real that can readily be passed into lua scripts |
| CMezzanine::Scripting::Lua::Lua51StringArgument | No special care is required for String Lua Arguments, so a simple typedef is used |
| CMezzanine::Scripting::Lua::Lua51WholeArgument | No special care is required for Whole number Lua Arguments, so a simple typedef is used |
| CMezzanine::Scripting::NullArgument | A very simple type used to indicate to script argument templates that the argument represents |
| CMezzanine::SemanticVersion | A Version class matching the Semantic Version specification |
| CMezzanine::Serializer< Serializable > | A tool for serializing classes with specific issues serializing |
| CMezzanine::SimpleVersion | A very basic class for expressing an API or syntax version |
| CMezzanine::Singleton< Type > | This is a convenience base class intended to be used with classes that need to be singletons |
| CMezzanine::SlowSplineInterpolator< T > | If something specifically needs the linear interpolator for T they should use this |
| CMezzanine::SmoothTrackIterator< InterpolatorType > | An Iterator that can take an arbitrary amount of steps through a track |
| CMezzanine::SortedVector< T > | |
| CMezzanine::Sphere | This is a generic sphere class used for spacial queries |
| CMezzanine::StateMachine | |
| CMezzanine::StateTransition | |
| CMezzanine::StateTransitionAction | |
| CMezzanine::Testing::OutputCaptureManager | Used to aplly RAII to Stdout and STDERR buffers/streams |
| CMezzanine::Testing::TestData | The information about a test and how to easily find it in the filesystem |
| CMezzanine::Testing::TimedTest | An easy way to get the time something took to execute |
| CMezzanine::Threading::Barrier | A synchronization primitive that causes a predefined number of threads to all wait before continuing |
| CMezzanine::Threading::DefaultThreadSpecificStorage | Use this to change the default resource type |
| CMezzanine::Threading::DoubleBufferedResource< T > | A thread specific resource that uses double buffering to avoid multithreaded synchronization mechanisms |
| CMezzanine::Threading::FrameScheduler | This is central object in this algorithm, it is responsible for spawning threads and managing the order that work units are executed |
| ►CMezzanine::Threading::iWorkUnit | Interface of a WorkUnit. This represents on piece of work through time |
| ►CMezzanine::Threading::DefaultWorkUnit | Default implementation of WorkUnit. This represents on piece of work through time |
| CMezzanine::ActorUpdateWorkUnit | This is a Mezzanine::Threading::iWorkUnit for the updating of actors |
| CMezzanine::AreaEffectUpdateWorkUnit | This is a Mezzanine::Threading::iWorkUnit for the updating of AreaEffects |
| CMezzanine::Audio::iBufferUpdate2DWorkUnit | This is the work unit for updating audio buffers as necessary for audio playback |
| CMezzanine::Audio::iBufferUpdate3DWorkUnit | This is the work unit for updating audio buffers as necessary for audio playback |
| CMezzanine::Audio::iEffectFilterCleanWorkUnit | This is the work unit for marking all effects and filters as clean after sounds have been processed |
| CMezzanine::DebrisUpdateWorkUnit | This is a Mezzanine::Threading::iWorkUnit for the updating of Debris |
| CMezzanine::EventPumpWorkUnit | Every frame the OS must be queried for changes to the state, this does that querying on behalf of an eventmanager |
| CMezzanine::Input::DeviceUpdateWorkUnit | This is a Mezzanine::Threading::iWorkUnit for the updating of the physics debug drawer |
| CMezzanine::Physics::DebugDrawWorkUnit | This is a Mezzanine::Threading::iWorkUnit for the updating of the physics debug drawer |
| CMezzanine::Physics::SimulationWorkUnit | This is a Mezzanine::Threading::iWorkUnit for the single threaded processing of physics simulations |
| CMezzanine::Physics::WorldTriggerUpdateWorkUnit | This is a Mezzanine::Threading::iWorkUnit for the updating of WorldTriggers |
| ►CMezzanine::Scripting::iScriptWorkUnit | The interface for a container of script that can be executed each frame |
| CMezzanine::Scripting::Lua::Lua51WorkUnit | This is a simple Container of script that will execute every script it is given in order each frame |
| ►CMezzanine::Threading::iAsynchronousWorkUnit | The interface for a WorkUnit that will keep running when the rest of the scheduler is paused |
| CMezzanine::Threading::AsynchronousFileLoadWorkUnit | This is intended to load files asynchronously and continue doing so whether or not other the FrameScheduler is running or paused |
| CMezzanine::Threading::LogAggregator | Gather all the thread specific logs and commit them to the main log |
| ►CMezzanine::Threading::MonopolyWorkUnit | A kind of workunit given exclusive runtime so it can consume time on multiple threads |
| CMezzanine::Graphics::RenderWorkUnit | This does the main loop processing for required to make the Graphics Manager function |
| CMezzanine::Physics::SimulationMonopolyWorkUnit | This is a Mezzanine::Threading::iWorkUnit for the multi-threaded processing of physics simulations |
| CMezzanine::Threading::WorkSorter | Sorts all of the WorkUnits in the FrameScheduler |
| CMezzanine::UI::WidgetUpdateWorkUnit | This is a Mezzanine::Threading::iWorkUnit for the updating of widgets in the UI system |
| CMezzanine::Threading::lock_guard< T > | Lock guard class |
| CMezzanine::Threading::Mutex | A cross-platform abstraction of the OS's mutex |
| CMezzanine::Threading::RawFile | A simple in memory representation of a file |
| CMezzanine::Threading::ReadOnlyLockGuard< T > | Read only lock guard |
| CMezzanine::Threading::ReadWriteLockGuard< T > | ReadWrite lock guard |
| CMezzanine::Threading::ReadWriteSpinLock | A mutex like construct that supports multiple readsingle writer semantics and never makes a system call and uses CPU instructions instead |
| CMezzanine::Threading::ScopedTimer | Used to time from this objects creation to its destruction |
| CMezzanine::Threading::SpinLock | A mutex like construct that never makes a system call and uses CPU instructions instead |
| CMezzanine::Threading::Thread | A small wrapper around the system thread |
| CMezzanine::Threading::ThreadId | The thread ID is a unique identifier for each thread |
| CMezzanine::Threading::ThreadSpecificStorage | A thread specific collection of double-buffered and algorithm specific resources |
| CMezzanine::Threading::WorkUnitKey | Stores data about a single work unit so that it can easily be sorted |
| CMezzanine::Time | A container for the metrics of time relevant for the timer class |
| CMezzanine::TimedTrackIterator< InterpolatorType > | This will take the same amount of clock time to iterate over a range |
| ►CMezzanine::Timer | A basic timer class to assist in timed operations |
| CMezzanine::ExtendedTimer | An enhanced timer class that can store and track many units of time |
| ►CMezzanine::Track< InterpolatorType > | A base type that provides container features for different tracks |
| CMezzanine::TrackLooped< InterpolatorType > | A track that keeps an extra data point in the track to make sure it loops |
| CMezzanine::TrackStorage< InterpolatableType, InterpolatorType > | |
| CMezzanine::Transform | Stores information about relative location and rotation in 3d space |
| ►CMezzanine::TransformableChildObject | This is an interface for all child 3D objects that can have their full transforms manipulated |
| CMezzanine::Graphics::Bone | This class encapsulates the bones contained in a skeleton used for animation |
| ►CMezzanine::TransformableObject | This is an interface for all 3D objects that can have their full transforms manipulated |
| ►CMezzanine::WorldObject | This is the base class from which classes that are insertable into the physical world |
| CMezzanine::Actor | This is the base class from which all the actors inherit |
| ►CMezzanine::AreaEffect | This class is used to define area's in the world that have unique effects |
| CMezzanine::FieldOfForce | This is field that applies force in a direction, and doesn't tamper with gravity |
| CMezzanine::GravityField | This is an implementation of the AreaEffect class that alters gravity in a region |
| CMezzanine::GravityWell | This is a gravity well implementation of the AreaEffect class |
| ►CMezzanine::Debris | A simple world object without a large structure ideal for representing loose small objects |
| CMezzanine::RigidDebris | A non-deformable debris |
| CMezzanine::SoftDebris | A deformable debris |
| ►CMezzanine::TerrainBase | This is the base class from which all the terrains inherit |
| CMezzanine::MeshTerrain | |
| ►CMezzanine::WorldProxy | This is the base class for proxy objects belonging to the various 3D subsystems |
| CMezzanine::Audio::iListener | This is an interface class for a listener (such as a player) in the 3D audio world |
| CMezzanine::Audio::SoundProxy | This is a proxy class for representing a sound being played in 3D space |
| ►CMezzanine::Graphics::RenderableProxy | This is the base proxy class for world proxies wrapping functionality of the graphics subsystem |
| CMezzanine::Graphics::BillboardSetProxy | This is the proxy class for placing and manipulating a set of 2D billboards in the scene |
| CMezzanine::Graphics::CameraProxy | This is the proxy class for placing and manipulating a camera in the scene |
| CMezzanine::Graphics::EntityProxy | This is the proxy class for placing and manipulating a mesh in the scene |
| CMezzanine::Graphics::LightProxy | This is the proxy class for placing and manipulating lighting in the scene |
| CMezzanine::Graphics::ParticleSystemProxy | This is the proxy class for placing and manipulating particles in the scene |
| ►CMezzanine::Physics::CollidableProxy | This is a proxy from which physics objects that can collide with each other are handled |
| CMezzanine::Physics::GhostProxy | This is the proxy object for ghost objects with no contact response |
| CMezzanine::Physics::RigidProxy | This is a proxy from which rigid body proxys are handled |
| CMezzanine::Physics::SoftProxy | This is the proxy object for soft/compressable bodies |
| CMezzanine::Triangle2D | A geometry math class for expressing a triangle in 2D space |
| CMezzanine::Triangle3D | A geometry math class for expressing a triangle in 3D space |
| CMezzanine::UI::ActionHandler | This class is the core class responsible for the management of actions |
| CMezzanine::UI::AtlasAndPosition | This class stores how the calls to Render are to be done |
| CMezzanine::UI::Character | This class creates and encapsultes a character that can be used in text renders |
| CMezzanine::UI::CharacterTraits | This class stores common data for determining the look of a Character |
| CMezzanine::UI::FontData | This class represents a collection of Glyphs in a common visual style |
| CMezzanine::UI::Glyph | Class used to describe a single glyph or character available for text operations |
| CMezzanine::UI::GridRect | Simple rect used to represent a complete transform on a grid |
| CMezzanine::UI::GridVector2 | Simple class used to represent positions or sizes on a grid |
| CMezzanine::UI::GroupOrderEntry | This is a small convenience class used to store a RenderLayerGroup ID and a ZOrder on that RenderLayerGroup |
| CMezzanine::UI::HotKeyHandler | This class is responsible for the registration and handling of hotkeys in the UI system |
| CMezzanine::UI::KerningInfo | Basic class used to describe Kerning for a given Glyph |
| ►CMezzanine::UI::LayoutStrategy | This is a base class for the algorithms used by QuadRenderables to determine how they should update their dimensions |
| CMezzanine::UI::HorizontalLayoutStrategy | 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 |
| CMezzanine::UI::VerticalLayoutStrategy | 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 |
| ►CMezzanine::UI::MarkupParser | This is a base class for the parsing of markup texts contained in text layers |
| CMezzanine::UI::DefaultMarkupParser | This class implements the default set of tags used by the UI markup system |
| ►CMezzanine::UI::MarkupTag | This is a base class for tags that implement the functionality of a markup language |
| CMezzanine::UI::DefaultColourTag | This class implements a character colour changing tag |
| CMezzanine::UI::DefaultFontTag | This class implements a character font changing tag |
| CMezzanine::UI::DefaultSpriteTag | This class implements a sprite inserting tag |
| CMezzanine::UI::MouseHoverCheck | Simple functor for finding which renderable the mouse is hovered over |
| ►CMezzanine::UI::MouseHoverStrategy | This is the base class for a method of finding which quad the mouse is hovered over |
| CMezzanine::UI::BruteStrategy | This strategy uses a brute force reverse search for the hovered quad |
| CMezzanine::UI::NineBoxStrategy | 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 |
| CMezzanine::UI::MultiImageData | This is an image layer that supports rendering of multiple images within it's space |
| CMezzanine::UI::NineBoxCheck | Simple functor for finding which renderable the mouse is hovered over |
| CMezzanine::UI::PartitionData | This is a helper class for storing metadata for partitions |
| CMezzanine::UI::PositioningInfo | This is a helper class designed to describe the behaviors of a quad when it needs to be repositioned |
| CMezzanine::UI::Rect | This class represents a box shaped area on the screen |
| ►CMezzanine::UI::Renderable | Basic class for all structures that get inserted into the rendering hierarchy |
| CMezzanine::UI::LineList | This is an object comprised of a series of lines |
| ►CMezzanine::UI::QuadRenderable | This represents a nestable quad for an object in a GUI layout |
| CMezzanine::UI::Screen | 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 |
| CMezzanine::UI::Widget | This is the base class for all widgets |
| CMezzanine::UI::RenderLayerGroup | This class stores a group of render layers that can be set to be rendered |
| CMezzanine::UI::ScreenRenderData | This class stores all vertices pertaining to a layer sorted by their priority for rendering |
| ►CMezzanine::UI::SimpleRenderer | A simple class providing basic methods to generate vertices with |
| CMezzanine::UI::LineListRenderer | This is a renderer class specifically designed to draw lines |
| ►CMezzanine::UI::QuadRenderer | |
| ►CMezzanine::UI::RenderLayer | This is the base class for the types of layers that can be added to a renderable |
| ►CMezzanine::UI::ImageLayer | This layer is for placing images and basic colours in it's parents' quad space |
| CMezzanine::UI::MultiImageLayer | This is an image layer that supports rendering of multiple images within it's space |
| CMezzanine::UI::SingleImageLayer | This is an image layer that supports rendering only a single image/sprite |
| ►CMezzanine::UI::TextLayer | This is a base class for render layers that render text |
| CMezzanine::UI::MultiLineTextLayer | This is a render layer specializing in multi-line text |
| CMezzanine::UI::SingleLineTextLayer | This is a render layer specializing in single-line text |
| CMezzanine::UI::SizingInfo | This is a helper class designed to describe the behaviors of a quad when it needs to be resized |
| CMezzanine::UI::Sprite | Basic class used to describe a portion of a texture to be applied to a Quad |
| CMezzanine::UI::TextCursor | Class for encapsulating the functionality of the text cursor/carat navigation in text layers |
| ►CMezzanine::UI::TextLine | This represents a single line of text to be rendered by a TextLayer |
| CMezzanine::UI::LeftToRightTextLine | This is a TextLine specialization class for text read from the left to the right |
| CMezzanine::UI::RightToLeftTextLine | This is a TextLine specialization class for text read from the right to the left |
| ►CMezzanine::UI::TextToken | This class represents a normal text segment from the source string |
| ►CMezzanine::UI::TagToken | This struct represents a markup tag segment from the source string |
| CMezzanine::UI::InsertTagToken | This struct represents a markup tag segment from the source string |
| CMezzanine::UI::RangeTagToken | This struct represents a markup tag segment from the source string |
| CMezzanine::UI::TextureAtlas | This is a collection of smaller textures packed into a larger texture, intended to increase UI performance |
| CMezzanine::UI::TextureAtlasHandler | This handles the creation, storage and overall handling of Texture Atlases |
| CMezzanine::UI::TokenString | This is a helper class that facilitates operations with collections of tokens generated from Markup Parsers |
| CMezzanine::UI::UnifiedDim | This class represents both the relative and absolute values that can be expressed for the values on one dimension for a UI renderable |
| CMezzanine::UI::UnifiedRect | This class represents a 2D rect which can express the size and position of a renderable on screen |
| CMezzanine::UI::UnifiedVec2 | This class represents a point in 2D space using UnifiedDim's |
| CMezzanine::UI::Vertex | Basic class describing a vertex in the UI to be rendered |
| CMezzanine::UI::VertexData | Basic class describing a vertex in the UI to be rendered |
| ►CMezzanine::UI::WidgetFactory | This is a base class for factories that construct the widgets available to the UI subsystem |
| CMezzanine::UI::ButtonFactory | This is the factory implementation for Button widgets |
| CMezzanine::UI::CheckBoxFactory | This is the factory implementation for CheckBox widgets |
| CMezzanine::UI::DropDownListFactory | This is the factory implementation for DropDownList widgets |
| CMezzanine::UI::EditBoxFactory | This is the factory implementation for EditBox widgets |
| CMezzanine::UI::GenericWidgetFactory | This is the factory implementation for generic widgets |
| CMezzanine::UI::GridContainerFactory | This is the factory implementation for GridContainer widgets |
| CMezzanine::UI::HorizontalContainerFactory | This is the factory implementation for HorizontalContainer widgets |
| CMezzanine::UI::HorizontalScrollbarFactory | This is the factory implementation for HorizontalScrollbar widgets |
| CMezzanine::UI::ListBoxFactory | This is the factory implementation for ListBox widgets |
| CMezzanine::UI::MenuEntryFactory | This is the factory implementation for MenuEntry widgets |
| CMezzanine::UI::RadioButtonFactory | This is the factory implementation for RadioButton widgets |
| CMezzanine::UI::SpinnerFactory | This is the factory implementation for Spinner widgets |
| CMezzanine::UI::StackButtonFactory | This is the factory implementation for StackButton widgets |
| CMezzanine::UI::TabSetFactory | This is the factory implementation for TabSet widgets |
| CMezzanine::UI::VerticalContainerFactory | This is the factory implementation for VerticalContainer widgets |
| CMezzanine::UI::VerticalScrollbarFactory | This is the factory implementation for VerticalScrollbar widgets |
| CMezzanine::UIDGenerator | This class will generate keep track of a pool of unique 32-bit ID's that can be used for distinct object instances |
| CMezzanine::Vector2 | This is used to represent a point on a 2 dimentional area, such as a screen |
| CMezzanine::Vector2LengthCompare | A compare fuctor that uses vector length |
| CMezzanine::Vector3 | This is used to represent a point in space, or a vector through space |
| CMezzanine::Vector3LengthCompare | A compare fuctor that uses vector length |
| CMezzanine::World | This class represents a world for objects to interact within |
| CMezzanine::WorldTrigger | This is an abstract class for creating in-game triggers |
| CMezzanine::XML::Attribute | A light-weight handle for manipulating attributes in DOM tree |
| CMezzanine::XML::AttributeIterator | Attribute iterator (a bidirectional iterator over a collection of Attribute) |
| CMezzanine::XML::NamedNodeIterator | Child node iterator (a forward iterator over a collection of Node) only iterates over nodes with a given name |
| ►CMezzanine::XML::Node | A light-weight handle for manipulating nodes in DOM tree |
| CMezzanine::XML::Document | The root node of any xml hierarchy is a Document |
| CMezzanine::XML::NodeIterator | Child node iterator (a bidirectional iterator over a collection of Node) |
| CMezzanine::XML::NodeText | A helper for working with text inside PCDATA nodes |
| CMezzanine::XML::ObjectRange< It > | Used by the xml system to pass around iterable ranges |
| CMezzanine::XML::ParseResult | Troubleshooting data intended to help troublshoot XML parsing errors |
| CMezzanine::XML::TreeWalker | Used to call a function OnEachNode member of the subtree of nodes descended from a specific node |
| ►CMezzanine::XML::Writer | Interface for node printing (see Node::Print) |
| CMezzanine::XML::WriterFile | An implementation of Writer intended for writing to FILEs as defined in stdio |
| CMezzanine::XML::WriterStream | An implementation of Writer intended for writing std::ostreams |
| CMezzanine::XML::XMLStreamWrapper | This represents a simple wrapper that makes data streams compatible with the XML API |
| CMezzanine::XML::XPathNode | An XPath node which can store handles to a XML::Node or an XML::Attribute |
| CMezzanine::XML::XPathNodeSet | A fixed sized collection of nodes that an XPathQuery can work on |
| CMezzanine::XML::XPathParseResult | XPath parsing result |
| CMezzanine::XML::XPathQuery | A compiled XPath query object |
| CMezzanine::XML::XPathVariable | A single XPath variable |
| CMezzanine::XML::XPathVariableSet | A set of XPath variables |
| COgre::SharedPtr< T > | |
| ►CSimpleRenderable | |
| CMezzanine::Internal::Line3D | Does the bulk of the work that that the Mezzanine::LineGroup performs |
| CMezzanine::RectBase< Real > | |
| CMezzanine::RectBase< Whole > | |
| ►CMezzanine::Singleton< AudioManager > | |
| CMezzanine::Audio::AudioManager | This is the base manager class for the Audio subsystem and it's operations |
| ►CMezzanine::Singleton< CollisionShapeManager > | |
| CMezzanine::Physics::CollisionShapeManager | This manager is for the storage of all shapes and creation of mesh shapes |
| ►CMezzanine::Singleton< Entresol > | |
| CMezzanine::Entresol | This is the main entry point for the entire library |
| ►CMezzanine::Singleton< EventManager > | |
| CMezzanine::EventManager | This is a container for Events and facilitates the transfer of data |
| ►CMezzanine::Singleton< GraphicsManager > | |
| CMezzanine::Graphics::GraphicsManager | This is intended to store basic graphics setting for the user |
| ►CMezzanine::Singleton< InputManager > | |
| CMezzanine::Input::InputManager | This is the manager responsible for the handling of input devices and events |
| ►CMezzanine::Singleton< MeshManager > | |
| CMezzanine::Graphics::MeshManager | This manager handles the storage, generation, and query of of Graphics Meshes |
| ►CMezzanine::Singleton< NetworkManager > | |
| CMezzanine::Network::NetworkManager | This is the central management class for all network I/O operations |
| ►CMezzanine::Singleton< ResourceManager > | |
| CMezzanine::Resource::ResourceManager | This is the manager responsible for the loading and unloading of files |
| ►CMezzanine::Singleton< TextureManager > | |
| CMezzanine::Graphics::TextureManager | This manager handles the storage and query of of Graphics Textures |
| ►CMezzanine::Singleton< UIManager > | |
| CMezzanine::UI::UIManager | This class is responsible for any and all user interactions with the User interface/HUD |
| ►CSpuGatheringCollisionDispatcher | |
| CMezzanine::Physics::ParallelCollisionDispatcher | Used to provide better reporting of collisions in a multithreaded environment |
| ►Cstd::exception | STL class |
| ►CMezzanine::ExceptionBase | This is the exception thrown by most Mezzanine systems that can throw exceptions |
| CMezzanine::ArithmeticException | Thrown when Math has failed |
| ►CMezzanine::InstanceIdentityException | Thrown when an unknown error with using an Identifier and it is invalid |
| CMezzanine::InstanceIdentityDuplicateException | Thrown when duplicates of teh same identity string exist |
| CMezzanine::InstanceIdentityInvalidException | Thrown when the identity string wasn't valid at all |
| CMezzanine::InstanceIdentityNotFoundException | Thrown when the requested identity could not be found |
| CMezzanine::InternalException | Thrown when an unknown internal error occurred |
| CMezzanine::InvalidAssignment | Thrown when a complex class is assigned to itself or other invalid assignments occur |
| CMezzanine::InvalidStateException | Thrown when the available information should have worked but failed for unknown reasons |
| CMezzanine::InvalidVersionException | Thrown when a version is accessed/parsed/required and it cannot work correctly or is missing |
| ►CMezzanine::IOException | Thrown when there was an issue with IO but very little was known about it |
| ►CMezzanine::DirectoryException | Thrown when there is an unknown issue with a file |
| CMezzanine::DirectoryNotFoundException | Thrown when a directory was expected to be there, but was not |
| CMezzanine::DirectoryPermissionException | Thrown when permission is denied to a directory |
| CMezzanine::DirectoryReadException | Thrown when a directory could be read and it wasn't a permission issue |
| CMezzanine::DirectoryWriteException | Thrown when a directory could be written to and it wasn't a permission issue |
| ►CMezzanine::FileException | Thrown when there is an unknown issue with a file |
| CMezzanine::FileNotFoundException | Thrown when a file was expected to be there, but was not |
| CMezzanine::FilePermissionException | Thrown when permission was denied to a file |
| CMezzanine::FileReadException | Thrown when a file could not be read and permissions seem to not be an issue (Filesystem/hardware issue? |
| CMezzanine::FileWriteException | Thrown when a file could not be written and perimssions seem not to be an issue |
| CMezzanine::IOReadException | Thrown when a read is happening but something has prevented the underlying code from knowing what was reading |
| CMezzanine::IOWriteException | Thrown when a write is happening but something has prevented the underlying code from knowing what was writing |
| ►CMezzanine::NetworkException | Thrown when something unknown causes network IO to fail |
| CMezzanine::NetworkNotFoundException | Thrown when no network connection is available |
| CMezzanine::NetworkPermissionException | Thrown when permision was denied to a network interface or network resource |
| CMezzanine::NetworkReadException | Thrown when data could not be read from the network (downloads) |
| CMezzanine::NetworkURLException | Thrown when an address is invalid or could not be found |
| CMezzanine::NetworkWriteException | Thrown when data could not be read from the network (iloads) |
| ►CMezzanine::MemoryManagementException | Thrown when an unknown memory management exception occurs |
| CMezzanine::MemoryOutOfBoundsException | Thrown when attempted to access something that really should note be accessed |
| CMezzanine::OutOfMemoryException | Thrown when A memory allocation was attempted and failed |
| CMezzanine::NotImplementedException | Thrown when we just have not coded a thing yet, but we knew what the API should look like |
| ►CMezzanine::ParametersException | Thrown when parameters are checked at runtime and found invalid |
| CMezzanine::ParametersCastException | Thrown when a pointer parameter is checked at runtime and cannot be cast as expected |
| CMezzanine::ParametersRangeException | Thrown when a passed parameter is checked at runtime and not in the expected range |
| CMezzanine::RenderingAPIException | Thrown when the graphics card/DirectX/OpenGL fail |
| CMezzanine::RuntimeAssertionException | Thrown when a rutime assertion could have been Thrown |
| ►CMezzanine::ScriptException | Thrown when an unknown error happens with a script |
| ►CMezzanine::ScriptLuaException | Thrown when an unknown error happens in a Lua script |
| CMezzanine::ScriptLuaErrErrException | Thrown when Lua has an error handling an error |
| CMezzanine::ScriptLuaRuntimeException | Thrown when a Lua script has a runtime error |
| CMezzanine::ScriptLuaYieldException | Thrown when Lua returns a yield and it should not have |
| ►CMezzanine::SyntaxErrorException | Thrown when some kind of syntax exception |
| CMezzanine::SyntaxErrorLuaException | Thrown when lua code in incorrect |
| CMezzanine::SyntaxErrorXMLException | Thrown when and XML document is being parsed but is invalid |
| CMezzanine::SyntaxErrorXPathException | Thrown when an XPath query is being parsed but is invalid |
| ►Cstd::ios_base | STL class |
| ►Cstd::basic_ios< Char > | STL class |
| ►Cstd::basic_istream< Char > | STL class |
| ►Cstd::istream | STL class |
| CMezzanine::Resource::IStream | Base class for input (read) streams with minimal implementation |
| ►Cstd::basic_ostream< Char > | STL class |
| CLogStream< CharType, CharTraits > | A stream that tracks its own level of logging |
| ►Cstd::ostream | STL class |
| CMezzanine::Resource::OStream | Base class for output (write) streams with minimal implementation |
| ►Ciostream | |
| CMezzanine::Resource::IOStream | Base class for streams that support both read and write operations |
| ►Cstd::list< T > | STL class |
| CMezzanine::Audio::Playlist | This class is a list of sounds with common playlist features |
| Cstd::numeric_limits< Mezzanine::Quaternion > | Get Numeric details on Quaternion |
| Cstd::numeric_limits< Mezzanine::Transform > | Get Numeric details on Transform |
| Cstd::numeric_limits< Mezzanine::Vector2 > | Get Numeric details on Vector2 |
| Cstd::numeric_limits< Mezzanine::Vector3 > | Get Numeric details on Vector3 |
| ►Cstd::set< K > | STL class |
| CMezzanine::Testing::UnitTestGroup | A single group of tests, suitable for being all the tests of a small subsystem or single class |
| ►Cstreambuf | |
| CMezzanine::Resource::MemoryStreamBuffer | A stream buffer object to a chunk of memory |
| ►Cstd::vector< T > | STL class |
| CMezzanine::EventUserInput | This is a container for MetaCodes that is used in the EventManager |
| ►CUnitTestGroup | |
| CAllUnitTestGroups | This aggregates the results of all the other test groups |
BlackTopp Studios
1.8.9.1. Thanks to the
Open Icon Library
for help with some of the icons.
