| C_ENetAcknowledgement | |
| C_ENetAddress | Portable internet address structure |
| C_ENetCallbacks | |
| C_ENetChannel | |
| C_ENetCompressor | An ENet packet compressor for compressing UDP packets before socket sends or receives |
| C_ENetEvent | An ENet event as returned by enet_host_service() |
| C_ENetHost | An ENet host for communicating with peers |
| C_ENetHostAddress | |
| C_ENetIncomingCommand | |
| C_ENetList | |
| C_ENetListNode | |
| C_ENetOutgoingCommand | |
| C_ENetPacket | ENet packet structure |
| C_ENetPeer | An ENet peer which data packets may be sent or received from |
| C_ENetProtocol | |
| C_ENetProtocolAcknowledge | |
| C_ENetProtocolBandwidthLimit | |
| C_ENetProtocolCommandHeader | |
| C_ENetProtocolConnect | |
| C_ENetProtocolDisconnect | |
| C_ENetProtocolHeader | |
| C_ENetProtocolPing | |
| C_ENetProtocolSendFragment | |
| C_ENetProtocolSendReliable | |
| C_ENetProtocolSendUnreliable | |
| C_ENetProtocolSendUnsequenced | |
| C_ENetProtocolThrottleConfigure | |
| C_ENetProtocolVerifyConnect | |
| C_ENetRangeCoder | |
| C_ENetSymbol | |
| Ctesting::Action< InnerFunctionType > | |
| Ctesting::Action< OriginalFunction > | |
| Ctesting::Action< VoidResult > | |
| ►Ctesting::ActionInterface< F1 > | |
| Ctesting::internal::ActionAdaptor< F1, F2 > | |
| Ctesting::ActionInterface< F2 > | |
| Ctesting::ActionInterface< InnerFunctionType > | |
| Ctesting::ActionInterface< OriginalFunction > | |
| Ctesting::ActionInterface< VoidResult > | |
| ►CArgs const | |
| CLuaTBTypedStack::function< Ret(Args...)> | Needed to get a lambda to call a lua function |
| ►Ctesting::internal::bool_constant< ((sizeof(From)< sizeof(To))&&(!GMOCK_IS_SIGNED_(From)||GMOCK_IS_SIGNED_(To)))||((sizeof(From)==sizeof(To))&&(GMOCK_IS_SIGNED_(From)==GMOCK_IS_SIGNED_(To)))> | |
| Ctesting::internal::LosslessArithmeticConvertibleImpl< kInteger, From, kInteger, To > | |
| ►Ctesting::internal::bool_constant< ImplicitlyConvertible< const T *, const ::ProtocolMessage * >::value||ImplicitlyConvertible< const T *, const ::proto2::Message * >::value > | |
| Ctesting::internal::IsAProtocolMessage< T > | |
| Cboost::filesystem::basic_path< String, Traits > | |
| ►CbtIDebugDraw | |
| Corxonox::BulletDebugDrawer | Originally from http://www.ogre3d.org/tikiwiki/BulletDebugDrawer&structure=Cookbook This source code is released into the Public Domain |
| ►CbtMotionState | |
| ►Corxonox::WorldEntity | The WorldEntity represents everything that can be put in a Scene at a certain location |
| ►Corxonox::MobileEntity | The MobileEntity is a derived class from orxonox::WorldEntity and orxonox::Tickable |
| ►Corxonox::ControllableEntity | The ControllableEntity is derived from the orxonox::MobileEntity |
| Corxonox::Arrow | |
| Corxonox::AutonomousDrone | Drone, that is made to move upon a specified pattern |
| Corxonox::JumpFigure | |
| Corxonox::PacmanGhost | |
| Corxonox::PacmanPointAfraid | |
| Corxonox::PacmanPointSphere | |
| ►Corxonox::Pawn | Everything in Orxonox that has a health attribute is a Pawn |
| Corxonox::AsteroidMinable | |
| Corxonox::Asteroids2DStone | |
| Corxonox::Drone | Drone, that is made to move upon a specified pattern |
| Corxonox::FpsPlayer | |
| ►Corxonox::InvaderEnemy | |
| Corxonox::InvaderEnemyShooter | |
| Corxonox::ScriptableControllerDrone | Drone, that is made to move upon a specified pattern |
| Corxonox::ShootableObstacle | This class encapsulates a pawn (so an object with health) with the addition, that it damages other objects when it hits them |
| ►Corxonox::SpaceShip | The SpaceShip is the principal entity through which the player interacts with the game |
| Corxonox::Asteroids2DShip | |
| Corxonox::Destroyer | |
| Corxonox::DodgeRaceShip | |
| Corxonox::FlappyOrxShip | |
| Corxonox::HoverShip | |
| Corxonox::InvaderShip | |
| Corxonox::ModularSpaceShip | The SpaceShip is the principal entity through which the player interacts with the game |
| Corxonox::OrxoKartKart | |
| Corxonox::OrxyRoadShip | |
| Corxonox::PacmanGelb | |
| Corxonox::StoryModePawn | |
| Corxonox::TowerDefenseEnemy | See TowerDefenseReadme.txt for Information |
| Corxonox::TeamBaseMatchBase | |
| ►Corxonox::Turret | Creates a turret with limited rotation |
| Corxonox::TowerDefenseTower | See TowerDefenseTowerDefenseReadme.txt for Information |
| Corxonox::WagnisProvince | |
| Corxonox::PongBat | Manages the bats for Pong, which are the elements controlled by the players |
| Corxonox::Rocket | Rocket that can be steered by the player |
| Corxonox::RocketOld | RocketOld that can be steered by the player |
| Corxonox::SimpleRocket | SimpleRocket is a target seeking, intelligent rocket |
| Corxonox::SOBFigure | |
| Corxonox::Spectator | |
| Corxonox::TetrisBrick | ContainerClass in order to create TetrisBricks by combining TetrisStones |
| Corxonox::TowerDefenseSelecter | |
| ►Corxonox::MovableEntity | |
| Corxonox::DodgeRaceCube | |
| Corxonox::ExplosionChunk | |
| Corxonox::ExplosionPart | |
| Corxonox::GravityBomb | This class implements how long the bomb flies before it places the GravityField at it's last possition |
| Corxonox::JumpEnemy | |
| ►Corxonox::JumpItem | |
| Corxonox::JumpBoots | |
| Corxonox::JumpPropeller | |
| Corxonox::JumpRocket | |
| Corxonox::JumpShield | |
| Corxonox::JumpSpring | |
| ►Corxonox::JumpPlatform | |
| Corxonox::JumpPlatformDisappear | |
| Corxonox::JumpPlatformFake | |
| Corxonox::JumpPlatformHMove | |
| Corxonox::JumpPlatformStatic | |
| Corxonox::JumpPlatformTimer | |
| Corxonox::JumpPlatformVMove | |
| Corxonox::JumpProjectile | |
| Corxonox::MineProjectile | TODO |
| Corxonox::OrxyRoadCube | |
| Corxonox::PongBall | This class manages the ball for Pong |
| ►Corxonox::Projectile | Represents all 'standard' projectiles |
| ►Corxonox::BillboardProjectile | A BillboardProjectile is a projectile that is represented by a Billboard |
| Corxonox::LightningGunProjectile | The LightningGunProjectile is a projectile that is represented by a looped series of billboards |
| Corxonox::SplitGunProjectile | The SplitGunProjectile is a projectile that may split up into many child projectiles |
| Corxonox::IceGunProjectile | The IceGunProjectile is a projectile that attaches a IceGunFreezer to the hit object |
| ►Corxonox::ParticleProjectile | A projectile that is represented by particles |
| Corxonox::FlameGunProjectile | |
| Corxonox::SOBCoin | |
| Corxonox::SOBFireball | |
| ►Corxonox::SOBGumba | |
| Corxonox::SOBGumbaBoss | |
| Corxonox::SOBMushroom | |
| Corxonox::SOBTube | |
| Corxonox::TetrisStone | |
| Corxonox::TowerDefenseField | See TowerDefenseReadme.txt for Information |
| Corxonox::WagnisProjectile | |
| Corxonox::TowerDefenseCenterpoint | See TowerDefenseReadme.txt for Information |
| ►Corxonox::StaticEntity | The StaticEntity is the simplest derivative of the orxonox::WorldEntity class |
| Corxonox::Actionpoint | Actionpoints are used by ActionpointController and all derived classes |
| Corxonox::Asteroids2DCenterPoint | |
| Corxonox::Attacher | |
| ►Corxonox::Billboard | |
| Corxonox::BlinkingBillboard | |
| ►Corxonox::FadingBillboard | |
| Corxonox::Backlight | |
| Corxonox::MuzzleFlash | A muzzle flash that destroys itself after some time |
| Corxonox::Camera | |
| Corxonox::CameraPosition | |
| Corxonox::DistanceTriggerBeacon | A DistanceTriggerBeacon can be used together with a DistanceTrigger or a DistanceMultiTrigger to make them only react to specific objects |
| Corxonox::Dock | |
| Corxonox::DockingTarget | DockingTargets for Docks |
| Corxonox::DodgeRaceCenterPoint | |
| ►Corxonox::ForceField | Implements a force field, that applies a force to any MobileEntity that enters its range |
| Corxonox::GravityBombField | This class is used by GravityBomb to place the ForceField and Visual effect to the environment |
| Corxonox::HoverFlag | |
| Corxonox::HoverOrigin | The HoverOrigin implements the playing field Hover takes place in and allows for many parameters of the minigame to be set |
| Corxonox::HoverWall | |
| Corxonox::IceGunFreezer | This is the WorldEntity that gets attached to a victim hit by a IceGunProjectile |
| Corxonox::InvaderCenterPoint | |
| Corxonox::JumpCenterpoint | The JumpCenterpoint is a StaticEntity which represents the level of the minigame |
| Corxonox::LensFlare | This class adds a configurable LensFlare effect by adding multiple billboards for the several components of lens flare |
| Corxonox::Light | |
| Corxonox::Mini4DgameBoard | This class manages the board for Mini4Dgame |
| ►Corxonox::Model | |
| Corxonox::AnimatedModel | |
| Corxonox::Planet | |
| Corxonox::NameableStaticEntity | |
| Corxonox::OrxoKartFlag | |
| Corxonox::OrxoKartOrigin | The OrxoKartOrigin implements the playing field OrxoKart takes place in and allows for many parameters of the minigame to be set |
| Corxonox::OrxoKartTile | |
| Corxonox::OrxyRoadCenterPoint | |
| ►Corxonox::ParticleEmitter | |
| Corxonox::ParticleSpawner | |
| Corxonox::PickupSpawner | The PickupSpawner class is responsible for spawning @ref orxonox::Pickupable "Pickupables" of a specific type. |
| Corxonox::PongCenterpoint | The PongCenterpoint implements the playing field Pong takes place in and allows for many parameters of the minigame to be set |
| Corxonox::PortalEndPoint | A PortalEndPoint serves as portal entrance and/or exit |
| Corxonox::QuestEffectBeacon | A QuestEffectBeacon is a physical entity in the game which can (under some condition(s)) invoke a number of QuestEffects on players meeting the condition(s) |
| Corxonox::SOBCastlestone | |
| Corxonox::SOBCenterpoint | The SOBCenterpoint is a StaticEntity which represents the level of the minigame |
| Corxonox::SOBFlagstone | |
| ►Corxonox::SOBItem | |
| Corxonox::SOBQBlock | |
| Corxonox::SpaceBoundaries | SpaceBoundaries gives level creators the possibility to bar Pawns from leaving a defined area (until now this area is a ball) |
| ►Corxonox::SpawnPoint | |
| Corxonox::TeamSpawnPoint | |
| Corxonox::TetrisCenterpoint | |
| ►Corxonox::TriggerBase | Base class for the two types of triggers, the (normal) Triggers and the MultiTriggers, it encompasses the shared data and functionality between these two types of triggers, but is in itself not a trigger that has any meaningful behavior and thus should not be instantiated |
| ►Corxonox::MultiTrigger | Implements a trigger that has a distinct state for each object triggering it |
| ►Corxonox::DistanceMultiTrigger | The DistanceMultiTrigger is a MultiTrigger that triggers whenever an object (that is of the specified target type) is in a specified range of the DistanceMultiTrigger |
| Corxonox::RaceCheckPoint | Enables the creation of a check point to use in a SpaceRace level |
| Corxonox::EventMultiTrigger | Equivalent of the EventTrigger class for MultiTriggers |
| ►Corxonox::Trigger | A Trigger is an object that can either be active or inactive, with a specified behavior how to switch between the two |
| ►Corxonox::DistanceTrigger | The DistanceTrigger is a Trigger that triggers whenever an object (that is of the specified target type) is in a specified range of the DistanceTrigger |
| Corxonox::CheckPoint | |
| Corxonox::EventTrigger | Way to have a Trigger triggered by any kinds of Events |
| Corxonox::WagnisGameboard | |
| Corxonox::Weapon | A Weapon is a StaticEntity that can be attached to a WeaponSlot |
| Corxonox::WeaponSlot | The a WeaponSlot defines where a Weapon is placed on a pawn |
| Corxonox::WorldSound | To be used for sounds with position and orientation |
| Ctesting::internal::CallableTraits< Callable > | |
| ►CDefaultLogger | |
| Corxonox::CEGUILogger | |
| CCEGUI::OgreCEGUIRenderer::QuadInfo | Structure holding details about a quad to be drawn |
| CCEGUI::OgreCEGUIRenderer::QuadVertex | Structure used for all vertices |
| ►CScriptModule | |
| Corxonox::LuaScriptModuleWorkaround | Class with the same memory layout as CEGUI::LuaScriptModule |
| CConverterStringStream< FromType, ToType > | Fallback template for stringstream |
| CConverterStringStream< FromType, std::string > | Template that evaluates whether we can convert to std::string via ostringstream |
| CConverterStringStream< std::string, ToType > | Template that evaluates whether we can convert from std::string via istringstream |
| Corxonox::DestructionHelper< orxonox::Core > | |
| Corxonox::DestructionHelper< orxonox::Game > | |
| Corxonox::DestructionHelper< orxonox::GraphicsManager > | |
| Corxonox::DestructionHelper< orxonox::GUIManager > | |
| CDeviceComponentInfo | |
| CENetBuffer | |
| ►CFailureReporterInterface | |
| Ctesting::internal::GoogleTestFailureReporter | |
| Ctesting::internal::Function< R() > | |
| Ctesting::internal::Function< R(A1) > | |
| Ctesting::internal::Function< R(A1, A2) > | |
| Ctesting::internal::Function< R(A1, A2, A3) > | |
| Ctesting::internal::Function< R(A1, A2, A3, A4) > | |
| Ctesting::internal::Function< R(A1, A2, A3, A4, A5) > | |
| Ctesting::internal::Function< R(A1, A2, A3, A4, A5, A6) > | |
| Ctesting::internal::Function< R(A1, A2, A3, A4, A5, A6, A7) > | |
| Ctesting::internal::Function< R(A1, A2, A3, A4, A5, A6, A7, A8) > | |
| Ctesting::internal::Function< R(A1, A2, A3, A4, A5, A6, A7, A8, A9) > | |
| Ctesting::internal::Function< R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) > | |
| CIsCallableImpl< T > | Implementation of IsCallable |
| CIsCallableImpl< T >::Check< U, U > | |
| ►CIsCallableImpl< T >::Fallback | |
| CIsCallableImpl< T >::Derived | |
| Ctesting::internal::linked_ptr< const testing::CardinalityInterface > | |
| Ctesting::internal::linked_ptr< const testing::internal::RE > | |
| Ctesting::internal::linked_ptr< const testing::MatcherInterface< const internal::string & > > | |
| Ctesting::internal::linked_ptr< const testing::MatcherInterface< internal::string > > | |
| Ctesting::internal::linked_ptr< const testing::MatcherInterface< T > > | |
| Ctesting::internal::linked_ptr< ExpectationBase > | |
| Ctesting::internal::linked_ptr< internal::ExpectationBase > | |
| Ctesting::internal::linked_ptr< Proto > | |
| Ctesting::internal::linked_ptr< testing::ActionInterface< F > > | |
| Ctesting::internal::linked_ptr< testing::ActionInterface< F2 > > | |
| Ctesting::internal::linked_ptr< testing::ActionInterface< InnerFunctionType > > | |
| Ctesting::internal::linked_ptr< testing::ActionInterface< OriginalFunction > > | |
| Ctesting::internal::linked_ptr< testing::ActionInterface< VoidResult > > | |
| Ctesting::internal::linked_ptr< testing::Expectation > | |
| CLoki::CompileTimeError< int > | |
| CLoki::CompileTimeError< true > | |
| CLoki::Int2Type< v > | |
| CLoki::IsCustomFloat< T > | |
| CLoki::IsCustomSignedInt< T > | |
| CLoki::IsCustomUnsignedInt< T > | |
| CLoki::IsSameType< T, U > | |
| CLoki::IsSameType< T, T > | |
| CLoki::NullType | |
| CLoki::Private::AddParameterType< U > | |
| CLoki::Private::AddParameterType< U & > | |
| CLoki::Private::AddParameterType< void > | |
| CLoki::Private::AddPointer< U > | |
| CLoki::Private::AddPointer< U & > | |
| CLoki::Private::AddReference< U > | |
| CLoki::Private::AddReference< U & > | |
| CLoki::Private::AddReference< void > | |
| CLoki::RefToValue< T > | Transports a reference as a value Serves to implement the Colvin/Gibbons trick for SmartPtr/ScopeGuard |
| ►CLoki::ScopeGuardImplBase | Base class used by all ScopeGuard implementations |
| CLoki::ObjScopeGuardImpl0< Obj, MemFun > | Implementation class for a class per-instance member function with no parameters |
| CLoki::ObjScopeGuardImpl1< Obj, MemFun, P1 > | Implementation class for a class per-instance member function with one parameter |
| CLoki::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > | Implementation class for a class per-instance member function with two parameters |
| CLoki::ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > | Implementation class for a class per-instance member function with three parameters |
| CLoki::ScopeGuardImpl0< F > | Implementation class for a standalone function or class static function with no parameters |
| CLoki::ScopeGuardImpl1< F, P1 > | Implementation class for a standalone function or class static function with one parameter |
| CLoki::ScopeGuardImpl2< F, P1, P2 > | Implementation class for a standalone function or class static function with two parameters |
| CLoki::ScopeGuardImpl3< F, P1, P2, P3 > | Implementation class for a standalone function or class static function with three parameters |
| CLoki::ScopeGuardImpl4< F, P1, P2, P3, P4 > | Implementation class for a standalone function or class static function with four parameters |
| CLoki::ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > | Implementation class for a standalone function or class static function with five parameters |
| CLoki::Select< flag, T, U > | |
| CLoki::Select< false, T, U > | |
| CLoki::Type2Type< T > | |
| CLoki::TypeTraits< T > | |
| CLoki::TypeTraits< T >::PointerTraits< U > | |
| CLoki::TypeTraits< T >::PointerTraits< U * > | |
| CLoki::TypeTraits< T >::PointerTraits< U *& > | |
| CLoki::TypeTraits< T >::PToMTraits< U > | |
| CLoki::TypeTraits< T >::PToMTraits< U V::* > | |
| CLoki::TypeTraits< T >::PToMTraits< U V::*& > | |
| CLoki::TypeTraits< T >::ReferenceTraits< U > | |
| CLoki::TypeTraits< T >::ReferenceTraits< U & > | |
| CLoki::TypeTraits< T >::UnConst< U > | |
| CLoki::TypeTraits< T >::UnConst< const U & > | |
| CLoki::TypeTraits< T >::UnConst< const U > | |
| CLoki::TypeTraits< T >::UnVolatile< U > | |
| CLoki::TypeTraits< T >::UnVolatile< volatile U & > | |
| CLoki::TypeTraits< T >::UnVolatile< volatile U > | |
| CLuaTB< ThisType, FunctionType > | Makes certain functions visible to lua while staying type-safe on the C++ side |
| CLuaTBTypedStack | Represents a typed version of the lua stack |
| CLuaTBTypedStack::GetLuaCallback< T > | |
| ►Ctesting::internal::MatcherBase< const internal::string & > | |
| Ctesting::Matcher< const internal::string & > | |
| ►Ctesting::internal::MatcherBase< internal::string > | |
| Ctesting::Matcher< internal::string > | |
| ►Ctesting::MatcherInterface< ArgsTuple > | |
| Ctesting::internal::ArgsMatcherImpl< ArgsTuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 > | |
| Ctesting::MatcherInterface< const internal::string & > | |
| ►Ctesting::MatcherInterface< Container > | |
| Ctesting::internal::ElementsAreMatcherImpl< Container > | |
| ►Ctesting::internal::QuantifierMatcherImpl< Container > | |
| Ctesting::internal::ContainsMatcherImpl< Container > | |
| Ctesting::internal::EachMatcherImpl< Container > | |
| Ctesting::MatcherInterface< internal::string > | |
| ►Ctesting::MatcherInterface< LhsContainer > | |
| Ctesting::internal::PointwiseMatcher< TupleMatcher, RhsContainer >::Impl< LhsContainer > | |
| ►Ctesting::MatcherInterface< PairType > | |
| Ctesting::internal::KeyMatcherImpl< PairType > | |
| Ctesting::internal::PairMatcherImpl< PairType > | |
| ►Ctesting::MatcherInterface< Pointer > | |
| Ctesting::internal::PointeeMatcher< InnerMatcher >::Impl< Pointer > | |
| ►Ctesting::MatcherInterface< Super & > | |
| Ctesting::internal::RefMatcher< T & >::Impl< Super > | |
| ►CMockClass | |
| Ctesting::NiceMock< MockClass > | |
| Ctesting::StrictMock< MockClass > | |
| Ctesting::internal::MockSpec< R() > | |
| Ctesting::internal::MockSpec< R(A1) > | |
| Ctesting::internal::MockSpec< R(A1, A2) > | |
| Ctesting::internal::MockSpec< R(A1, A2, A3) > | |
| Ctesting::internal::MockSpec< R(A1, A2, A3, A4) > | |
| Ctesting::internal::MockSpec< R(A1, A2, A3, A4, A5) > | |
| Ctesting::internal::MockSpec< R(A1, A2, A3, A4, A5, A6) > | |
| Ctesting::internal::MockSpec< R(A1, A2, A3, A4, A5, A6, A7) > | |
| Ctesting::internal::MockSpec< R(A1, A2, A3, A4, A5, A6, A7, A8) > | |
| Ctesting::internal::MockSpec< R(A1, A2, A3, A4, A5, A6, A7, A8, A9) > | |
| Ctesting::internal::MockSpec< R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) > | |
| ►C<NSApplicationDelegate> | |
| COrxonoxAppDelegate | |
| ►CNSObject | |
| COrxonoxAppDelegate | |
| Corxonox::ObjectList< orxonox::RadarViewable > | |
| ►CListener | |
| Corxonox::Shader | Shader is a wrapper class around Ogre::CompositorInstance |
| COgre::Controller< T > | |
| COgre::ControllerFunction< T > | |
| COgre::ControllerValue< T > | |
| ►CFrameListener | |
| Corxonox::BulletDebugDrawer | Originally from http://www.ogre3d.org/tikiwiki/BulletDebugDrawer&structure=Cookbook This source code is released into the Public Domain |
| ►CLogListener | |
| Corxonox::GraphicsManager | Graphics engine manager class |
| ►CListener | |
| Corxonox::GlowMaterialListener | |
| ►CRenderQueueListener | |
| CCEGUI::CEGUIRQListener | RenderQueueListener based class used to hook into the ogre rendering system |
| Corxonox::RenderQueueListener | This class derives from the Ogre-Class RenderQueueListener and provides a way to define new rendering stages to enable use of e.g |
| COgre::SharedPtr< T > | |
| ►CWindowEventListener | |
| Corxonox::OgreWindowEventListener | |
| COIS::AxisInfo | |
| ►COIS::Component | Base of all device components (button, axis, etc) |
| COIS::Axis | Axis component |
| COIS::Button | Button can be a keyboard key, mouse button, etc |
| COIS::Pov | POV / HAT Joystick component |
| COIS::Slider | A sliding axis - only used in Win32 Right Now |
| COIS::Vector3 | A 3D Vector component (perhaps an orientation, as in the WiiMote) |
| COIS::cookie_struct | |
| COIS::Effect | Force Feedback is a relatively complex set of properties to upload to a device |
| ►COIS::EventArg | Base class of all events |
| COIS::JoyStickEvent | Specialised for joystick events |
| COIS::KeyEvent | Specialised for key events |
| COIS::MouseEvent | Specialised for mouse events |
| COIS::MultiTouchEvent | Specialised for multi-touch events |
| COIS::EventUtils | |
| ►COIS::FactoryCreator | Interface for creating devices - all devices ultimately get enumerated/created via a factory |
| COIS::LinuxInputManager | Linux X11 InputManager specialization - Using lowlevel joys |
| COIS::MacHIDManager | |
| COIS::MacInputManager | |
| COIS::Win32InputManager | Win32InputManager specialization - Using DirectInput8 |
| ►COIS::ForceEffect | Base class of all effect property classes |
| COIS::ConditionalEffect | Use this class when dealing with Force type of Condional |
| COIS::ConstantEffect | Use this class when dealing with Force type of Constant |
| COIS::Envelope | An optional envelope to be applied to the start/end of an effect |
| COIS::PeriodicEffect | Use this class when dealing with Force type of Periodic |
| COIS::RampEffect | Use this class when dealing with Force type of Ramp |
| COIS::HidInfo | |
| ►COIS::InputManager | Base Manager class |
| COIS::LinuxInputManager | Linux X11 InputManager specialization - Using lowlevel joys |
| COIS::MacInputManager | |
| COIS::Win32InputManager | Win32InputManager specialization - Using DirectInput8 |
| ►COIS::Interface | An Object's interface is a way to gain write access to devices which support it |
| ►COIS::ForceFeedback | Interface class for dealing with Force Feedback devices |
| COIS::LinuxForceFeedback | |
| COIS::Win32ForceFeedback | |
| COIS::JoyStickInfo | |
| ►COIS::JoyStickListener | To recieve buffered joystick input, derive a class from this, and implement the methods here |
| Corxonox::JoyStick | Wraps around an OIS::JoyStick and forwards the input events to a list of input states |
| COIS::JoyStickState | Represents the state of the joystick All members are valid for both buffered and non buffered mode Sticks with zero values are not present on the device |
| ►COIS::KeyListener | To recieve buffered keyboard input, derive a class from this, and implement the methods here |
| Corxonox::Keyboard | Wraps around an OIS::Mouse and forwards the input events to a list of input states |
| COIS::Mac_KeyStackEvent | |
| COIS::Mac_MouseStackEvent | |
| ►COIS::MouseListener | To recieve buffered mouse input, derive a class from this, and implement the methods here |
| Corxonox::Mouse | Wraps around an OIS::Mouse and forwards the input events to a list of input states |
| COIS::MouseState | Represents the state of the mouse All members are valid for both buffered and non buffered mode |
| COIS::MultiTouchListener | To receive buffered touch input, derive a class from this, and implement the methods here |
| COIS::MultiTouchState | |
| ►COIS::Object | The base class of all input types |
| ►COIS::JoyStick | Joystick base class |
| COIS::LinuxJoyStick | Linux specialization of JoyStick class |
| COIS::MacJoyStick | |
| COIS::Win32JoyStick | |
| ►COIS::Keyboard | Keyboard base class |
| COIS::LinuxKeyboard | Linux implementation of Keyboard object - uses x11 |
| COIS::MacKeyboard | |
| COIS::Win32Keyboard | |
| ►COIS::Mouse | Mouse base class |
| COIS::LinuxMouse | |
| COIS::MacMouse | |
| COIS::Win32Mouse | |
| COIS::MultiTouch | MultiTouch base class |
| COIS::OIS_CFString | Simple wrapper class for CFString which will create a valid CFString and retain ownership until class instance is outof scope To Access the CFStringRef instance, simply cast to void*, pass into a function expecting a void* CFStringRef object, or access via cf_str() method |
| COIS::Range | |
| ►Corxonox::OrxEnum< InputStatePriority > | |
| Corxonox::InputStatePriority | Enumeration wrapper for input state priorities |
| ►Corxonox::AdditionalContextListener | AdditionalContextListener is an interface which is used to notify OutputManager about additional contexts in OutputListeners |
| Corxonox::OutputManager | OutputManager acts as the center of the output system and is implemented as a singleton |
| Corxonox::ArgumentCompleter | This class executes an argument completion function and returns a list of the possible arguments |
| Corxonox::ArgumentCompletionListElement | This class is used in argument completion lists and contains up to three different strings, used in different situations |
| ►Corxonox::BaseCommand | |
| Corxonox::ParamCommand | |
| Corxonox::SimpleCommand | |
| ►Corxonox::BaseInputBufferListenerTuple | |
| Corxonox::InputBufferListenerTuple< T > | |
| Corxonox::BaseObject::StrongOrWeakPtr< T > | |
| Corxonox::BillboardSet | |
| Corxonox::BufferedParamCommand | |
| Corxonox::BulletDebugDrawer::ContactPoint | |
| ►Corxonox::Button | |
| Corxonox::HalfAxis | |
| Corxonox::ButtonEvent::EnumToType< Event > | Enables function overloading with integer values |
| Corxonox::Circle | |
| Corxonox::ClassTreeMask | The ClassTreeMask is a set of rules, containing the information for each class whether it's included or not |
| Corxonox::ClassTreeMaskIterator | The ClassTreeMaskIterator moves through all ClassTreeMaskNodes of the internal tree of a ClassTreeMask which contains the rules |
| Corxonox::ClassTreeMaskNode | The ClassTreeMaskNode is a node in the internal tree of the ClassTreeMask, containing the rules of the mask |
| Corxonox::ClassTreeMaskObjectIterator | The ClassTreeMaskObjectIterator iterates through all objects of the classes that were included by a ClassTreeMask |
| Corxonox::Clock | Simple real time clock based on Ogre::Timer |
| Corxonox::CommandEvaluation | CommandEvaluation is used to gather information about a command and to evaluate its arguments |
| Corxonox::CommandExecutor | This class is used to execute and evaluate command-strings |
| Corxonox::CommandExecutor::CacheEntry | Helper struct, used to store cached entries |
| Corxonox::CommandLineArgument | Container class for a command line argument of any type supported by MultiType |
| ►Corxonox::ConfigFile | This class represents a config file, which is stored on the hard-disk and contains config values in different sections |
| Corxonox::SettingsConfigFile | Child class of ConfigFile, used to store the settings of the game |
| ►Corxonox::ConfigFileEntry | This class represents an entry in the config file |
| Corxonox::ConfigFileEntryComment | This class represents a line in the config file which contains only a comment |
| ►Corxonox::ConfigFileEntryValue | This class represents a normal value in the config file |
| Corxonox::ConfigFileEntryVectorValue | Subclass of ConfigFileEntryValue, represents an element of a vector |
| Corxonox::ConfigFileSection | Represents a section in a config file |
| ►Corxonox::ConfigValueCallbackBase | |
| Corxonox::ConfigValueCallback< T > | |
| Corxonox::ConfigValueContainer | The ConfigValuecontainer contains all needed information about a configurable variable |
| ►Corxonox::Connection | |
| ►Corxonox::ClientConnection | |
| Corxonox::Client | Client *client; The network/Client class This class implements all necessary function for the network communication It is the root class of the network module |
| ►Corxonox::ServerConnection | |
| Corxonox::Server | This class is the root class of the network module for a server |
| Corxonox::ConsoleCommand | Stores all information about a console command which can be executed by CommandExecutor |
| Corxonox::ConsoleCommand::Command | Helper class that is used to put the current state of the ConsoleCommand on a stack |
| Corxonox::ConsoleCommand::CommandName | Defines the name of a command, consisting of an optional group ("" means no group) and the name itself |
| Corxonox::ConsoleCommand::ConsoleCommandManipulator | Helper class that is used to manipulate console commands |
| Corxonox::ConverterExplicit< FromType, ToType > | Default template if no orxonox::ConverterExplicit is available |
| Corxonox::ConverterExplicit< bool, std::string > | Conversion from bool to std::string |
| Corxonox::ConverterExplicit< btQuaternion, orxonox::Quaternion > | |
| Corxonox::ConverterExplicit< btVector3, orxonox::Vector3 > | |
| Corxonox::ConverterExplicit< char, std::string > | Conversion would exhibit ambiguous << or >> operators when using iostream |
| Corxonox::ConverterExplicit< const char *, ToType > | Delegates conversion from const char* to std::string |
| Corxonox::ConverterExplicit< orxonox::ColourValue, std::string > | Ogre::ColourValue to std::string conversion |
| Corxonox::ConverterExplicit< orxonox::Quaternion, btQuaternion > | |
| Corxonox::ConverterExplicit< orxonox::Quaternion, std::string > | Ogre::Quaternion to std::string conversion |
| Corxonox::ConverterExplicit< orxonox::Vector2, std::string > | Ogre::Vector2 to std::string conversion |
| Corxonox::ConverterExplicit< orxonox::Vector3, btVector3 > | |
| Corxonox::ConverterExplicit< orxonox::Vector3, std::string > | Ogre::Vector3 to std::string conversion |
| Corxonox::ConverterExplicit< orxonox::Vector4, std::string > | Ogre::Vector4 to std::string conversion |
| Corxonox::ConverterExplicit< std::string, bool > | Conversion from std::string to bool |
| Corxonox::ConverterExplicit< std::string, char > | Conversion would exhibit ambiguous << or >> operators when using iostream |
| Corxonox::ConverterExplicit< std::string, Ogre::DisplayString > | |
| Corxonox::ConverterExplicit< std::string, unsigned char > | Conversion would exhibit ambiguous << or >> operators when using iostream |
| Corxonox::ConverterExplicit< unsigned char, std::string > | Conversion would exhibit ambiguous << or >> operators when using iostream |
| Corxonox::ConverterFallback< FromType, ToType > | Default template. No conversion available at all |
| Corxonox::ConverterFallback< FromType *, ToType * > | If all else fails, try a dynamic_cast for pointer types |
| Corxonox::ConverterFallback< FromType, orxonox::Degree > | Delegates conversions to Degree to conversions to float |
| Corxonox::ConverterFallback< FromType, orxonox::Radian > | Delegates conversions to Radian to conversions to float |
| Corxonox::ConverterFallback< orxonox::Degree, ToType > | Delegates conversions from Degree to conversions from float |
| Corxonox::ConverterFallback< orxonox::Radian, ToType > | Delegates conversions from Radian to conversions from float |
| Corxonox::ConverterFallback< std::string, orxonox::ColourValue > | Std::string to Ogre::ColourValue conversion |
| Corxonox::ConverterFallback< std::string, orxonox::Quaternion > | Std::string to Ogre::Quaternion conversion |
| Corxonox::ConverterFallback< std::string, orxonox::Vector2 > | Std::string to Ogre::Vector2 conversion |
| Corxonox::ConverterFallback< std::string, orxonox::Vector3 > | Std::string to Ogre::Vector3 conversion |
| Corxonox::ConverterFallback< std::string, orxonox::Vector4 > | Std::string to Ogre::Vector4 conversion |
| Corxonox::CreateLines | |
| Corxonox::DebugDrawer | DebugDrawer is a utility to draw debug shapes (lines, triangles, spheres) with Ogre |
| ►Corxonox::Destroyable | Classes must inherit from this class if they should be used with StrongPtr or WeakPtr |
| ►Corxonox::Identifier | The Identifier is used to identify the class of an object and to store information about the class |
| Corxonox::ClassIdentifier< T > | The ClassIdentifier is derived from Identifier and holds all class-specific functions and variables the Identifier cannot have |
| ►Corxonox::OrxonoxClass | This is the class from which all objects of the game-logic (not the engine) are derived from |
| ►Corxonox::BaseObject | The BaseObject is the parent of all classes representing an instance in the game |
| Corxonox::Answer | Class containing the pc side of the Dialog |
| Corxonox::AnswerId | Container class for answerids in xml |
| Corxonox::BarColour | |
| ►Corxonox::CollisionShape | Wrapper for bullet collision shape class btCollisionShape |
| ►Corxonox::AbstractRadiusHeightCollisionShape | Wrapper for the bullet collision shapes with radius and height |
| Corxonox::ConeCollisionShape | Wrapper for the bullet cone collision shape class btConeShape |
| Corxonox::CylinderCollisionShape | Wrapper for the bullet Cylinder collision shape class btCylinderShape |
| Corxonox::BoxCollisionShape | Wrapper for the bullet box collision shape class btBoxShape |
| ►Corxonox::CompoundCollisionShape | Wrapper for the bullet compound collision shape class btCompoundShape |
| Corxonox::WorldEntityCollisionShape | |
| Corxonox::PlaneCollisionShape | Wrapper for the bullet plane collision shape class btStaticPlaneShape |
| Corxonox::SphereCollisionShape | Wrapper for the bullet sphere collision shape class btSphereShape |
| ►Corxonox::Controller | |
| Corxonox::ArrowController | |
| Corxonox::AutonomousDroneController | Controller for the AutonomousDrone of the PPS tutorial |
| ►Corxonox::CommonController | |
| ►Corxonox::FlyingController | |
| ►Corxonox::FightingController | FightingController stores all the fighting methods and member variables of AI |
| ►Corxonox::ActionpointController | |
| Corxonox::DivisionController | |
| Corxonox::SectionController | |
| Corxonox::WingmanController | |
| ►Corxonox::FormationController | |
| ►Corxonox::ArtificialController | |
| Corxonox::AIController | |
| Corxonox::ControllerDirector | |
| Corxonox::DockingController | |
| Corxonox::DroneController | Controller for the Drone of the PPS tutorial |
| Corxonox::ScriptController | |
| Corxonox::SpaceRaceController | Conventions: -first Checkpoint has index 0 -staticCheckPoint= static Point (see def over = constructor) |
| Corxonox::TurretController | Controller for turrets |
| ►Corxonox::WaypointController | |
| Corxonox::WaypointPatrolController | |
| ►Corxonox::HumanController | |
| Corxonox::NewHumanController | |
| Corxonox::TeamTargetProxy | A controller, that just copies the team and the target of a parent for itself and it's controllable entity |
| Corxonox::MasterController | Calles action(), maneuver() and canFire() methods of all the ActionpointControllers in level |
| Corxonox::Mini4DgameAI | The Mini4DgameAI is an artificial intelligence for the Mini4Dgame gametype |
| Corxonox::PongAI | The PongAI is an artificial intelligence for the Pong gametype |
| Corxonox::RocketController | Controller for the SimpleRocket (target seeking) |
| Corxonox::CreateStars | |
| Corxonox::DefaultWeaponmodeLink | |
| Corxonox::Dialog | Class containing core of one dialog with one npc |
| ►Corxonox::DockingAnimation | Base class for docking animations used by Docks |
| Corxonox::MoveToDockingTarget | Base class for docking animations used by Docks |
| ►Corxonox::DockingEffect | Handles DockingEffects for Docks |
| Corxonox::DockToShip | Allows players to dock onto a ship |
| Corxonox::EffectContainer | |
| Corxonox::EventDispatcher | |
| Corxonox::EventFilter | |
| Corxonox::EventListener | |
| Corxonox::EventName | |
| Corxonox::EventTarget | |
| ►Corxonox::Gametype | |
| Corxonox::Asteroids | |
| ►Corxonox::Deathmatch | |
| Corxonox::Asteroids2D | |
| Corxonox::DodgeRace | |
| Corxonox::FlappyOrx | |
| Corxonox::Invader | |
| Corxonox::Jump | |
| Corxonox::LastManStanding | |
| Corxonox::Mini4Dgame | |
| Corxonox::OrxyRoad | |
| Corxonox::Pacman | |
| Corxonox::Pong | Implements a Pong minigame (Wikipedia::Pong) |
| Corxonox::SOB | |
| Corxonox::Tetris | |
| Corxonox::Wagnis | |
| Corxonox::Dynamicmatch | Short Gaming Manual: There are three different parties a player can belong to: victim, chaser or killer Every player starts as chaser |
| Corxonox::Hover | |
| Corxonox::OrxoKart | |
| Corxonox::SpaceRace | Enables the creation of a space race level, where the player has to reach check points in a given order |
| Corxonox::StoryMode | |
| ►Corxonox::TeamGametype | |
| Corxonox::Mission | |
| ►Corxonox::TeamDeathmatch | |
| Corxonox::LastTeamStanding | |
| Corxonox::TeamBaseMatch | |
| Corxonox::TowerDefense | GameType class for TowerDefense |
| Corxonox::UnderAttack | |
| Corxonox::GlobalShader | |
| Corxonox::GUISheet | Simple XML loadable interface to the otherwise Lua coded GUI framework |
| ►Corxonox::Info | |
| Corxonox::GametypeInfo | Keeps track of the state of the game and provides facilities to inform the player about it |
| ►Corxonox::PlayerInfo | |
| ►Corxonox::Bot | |
| Corxonox::PongBot | A bot especially for Pong |
| Corxonox::SpaceRaceBot | |
| ►Corxonox::HumanPlayer | |
| Corxonox::WagnisPlayer | |
| ►Corxonox::Item | |
| ►Corxonox::Engine | Propulsion to the SpaceShip |
| Corxonox::MultiStateEngine | |
| Corxonox::PartDestructionEvent | In order to assign attached entities to a ShipPart, a ShipPart with the same name as the corresponding entity needs to be created in the <parts> tag. |
| Corxonox::ShipPart | |
| Corxonox::Level | |
| Corxonox::LevelInfo | Can be used to store information regarding a Level in its level file |
| Corxonox::MeshLodInformation | |
| Corxonox::MultiTriggerContainer | This class is used by the MultiTrigger class to transport additional data via Events |
| ►Corxonox::Munition | |
| Corxonox::FlameMunition | FlameMunition |
| Corxonox::FusionMunition | FusionMunition |
| Corxonox::GravityBombMunition | This class is used to set the behaviour of various munition specific attributes of the GravityBomb like max count of munition per magazine |
| Corxonox::IceMunition | IceMunition |
| Corxonox::LightningMunition | LightningMunition |
| Corxonox::MineMunition | MineMunition |
| ►Corxonox::ReplenishingMunition | Munition that is replenished by a certain amount each time interval |
| Corxonox::LaserMunition | LaserMunition |
| Corxonox::RocketMunition | Munition for the Rocket |
| Corxonox::SplitMunition | SplitMunition |
| Corxonox::MunitionContainer | |
| Corxonox::Namespace | |
| ►Corxonox::NotificationDispatcher | A NotificationDispatcher is an entity that, upon being triggered, dispatches (or sends) a specified Notification |
| Corxonox::CommandNotification | This class implements a method of displaying a Notification with information to an input command and the key the command is mapped to |
| Corxonox::SimpleNotification | Enables the sending of (in XML) predefined Notifications upon some kind of triggering event |
| ►Corxonox::NotificationQueue | Displays Notifications from specific senders |
| Corxonox::NotificationQueueCEGUI | Displays Notifications using CEGUI |
| ►Corxonox::OrxonoxOverlay | Base class to display content directly onto the screen |
| Corxonox::FlagHUD | |
| Corxonox::GUIOverlay | |
| ►Corxonox::HUDBar | |
| Corxonox::HUDBoostBar | |
| ►Corxonox::HUDHealthBar | |
| Corxonox::HUDEnemyHealthBar | |
| Corxonox::HUDRocketFuelBar | |
| ►Corxonox::HUDShieldBar | The HUDShieldBar displays the the status of the shield of its owner (a Pawn) |
| Corxonox::HUDEnemyShieldBar | This class displays the shield status of the target enemy of it's owner |
| Corxonox::HUDSpeedBar | |
| Corxonox::HUDNavigation | |
| Corxonox::HUDPickupSystem | |
| Corxonox::HUDRadar | |
| Corxonox::HUDWeapon | |
| Corxonox::HUDWeaponMode | |
| Corxonox::HUDWeaponSystem | |
| ►Corxonox::OverlayText | |
| Corxonox::Asteroids2DHUDinfo | |
| Corxonox::ChatOverlay | |
| Corxonox::CountDown | |
| Corxonox::DebugFPSText | |
| Corxonox::DebugPositionText | |
| Corxonox::DebugRTRText | |
| Corxonox::DodgeRaceHUDinfo | |
| ►Corxonox::FadeoutText | |
| Corxonox::AnnounceMessage | |
| Corxonox::DeathMessage | |
| Corxonox::GametypeFadingMessage | |
| Corxonox::KillMessage | |
| Corxonox::FlappyOrxHUDinfo | |
| Corxonox::GametypeStaticMessage | |
| Corxonox::HUDTimer | |
| Corxonox::InvaderHUDinfo | |
| Corxonox::JumpScore | |
| Corxonox::LastManStandingInfos | |
| Corxonox::LastTeamStandingInfos | |
| Corxonox::OrxyRoadHUDinfo | |
| Corxonox::PacmanHUDinfo | |
| Corxonox::PauseNotice | |
| Corxonox::PongScore | Displays the score for a game of Pong |
| Corxonox::SOBHUDInfo | |
| Corxonox::TeamBaseMatchScore | |
| Corxonox::TetrisScore | Displays the score for a game of Tetris |
| Corxonox::TimeHUD | |
| Corxonox::TimeHUD | |
| Corxonox::TowerDefenseHUDController | This subclass of OverlayText is used to display the stats of the player in the HUD |
| Corxonox::WagnisHUDinfo | |
| Corxonox::Scoreboard | |
| Corxonox::ShroomHUD | |
| Corxonox::Stats | |
| Corxonox::StoryModeHUD | |
| Corxonox::WagnisHUD | |
| Corxonox::OverlayGroup | OverlayGroup does almost exactly what it says: It groups OrxonoxOverlays together |
| ►Corxonox::Pickup | Offers (useful) base functionality for a wide range of pickups |
| Corxonox::BoostPickup | |
| Corxonox::DamageBoostPickup | |
| Corxonox::DronePickup | The DronePickup adds a Drone to the Pawn upon being picked up |
| Corxonox::HealthPickup | The HealthPickup is a Pickupable that can do (dependent upon the parameters) lots of different things to the health of a Pawn |
| Corxonox::InvisiblePickup | A pickup that makes the Pawn invisible |
| Corxonox::MetaPickup | The MetaPickup is a Pickupable that can, depending on the parameter metaTye, do different things |
| Corxonox::MunitionPickup | The MunitionPickup gives munition to the user (a Pawn) |
| Corxonox::ShieldPickup | A Pickup which can add a Shield to the Pawn |
| Corxonox::ShrinkPickup | The ShrinkPickup is a Pickupable that causes the pawn to shrink to a certain size for a certain time with a certain speed, all of them specified in the following variables: |
| Corxonox::SpeedPickup | A Pickup which can manipulate the Speed of a Pawn |
| Corxonox::PickupCollection | The PickupCollection combines different Pickupables (more precisely CollectiblePickups) to a coherent, single pickup and makes them seem (from the outside looking in) just as if they were just one Pickupable |
| Corxonox::PickupRepresentation | Specific pickup type |
| Corxonox::PortalLink | A PortalLink represents the connection between two @ref orxonox::PortalEndPoint "PortalEndPoints"
|
| Corxonox::QuestDescription | This class is a description of a QuestItem (Quest and QuestHint) |
| ►Corxonox::QuestEffect | Handles QuestEffects for Quests |
| Corxonox::AddQuestHint | Adds a QuestHint, resp |
| Corxonox::AddReward | Adds a list of Rewardables to a player |
| ►Corxonox::ChangeQuestStatus | A QuestEffect which changes the status of a specified Quest for the player invoking the QuestEffect |
| Corxonox::AddQuest | Adds a Quest, resp |
| Corxonox::CompleteQuest | Completes a Quest (with a specified id) for the player invoking the QuestEffect |
| Corxonox::FailQuest | Fails a Quest (with a specified id) for the player invoking the QuestEffect |
| Corxonox::Question | Class containing the npc side of the Dialog |
| ►Corxonox::QuestItem | Functions as a base class for quest classes such as Quest or QuestHint |
| ►Corxonox::Quest | Represents a Quest in the game |
| Corxonox::GlobalQuest | GlobalQuests are Quests, that have the same status for all players |
| Corxonox::LocalQuest | Handles Quests which have different states for different players |
| Corxonox::QuestHint | Represents a hint in the game that gives aid towards completing a Quest |
| Corxonox::QuestListener | Provides a way to react to the starting, completing and failing of Quests |
| Corxonox::ResourceCollection | |
| Corxonox::ResourceLocation | |
| Corxonox::Scene | |
| Corxonox::Script | Lets you execute a piece of code, either the normal way or in lua, through XML |
| Corxonox::SpaceRaceManager | Controls a space race level, where the player has to reach check points in a given order |
| Corxonox::SpicedAsteroidBelt | |
| Corxonox::SpicedAsteroidField | |
| Corxonox::Template | |
| Corxonox::Test | |
| ►Corxonox::WeaponMode | A WeaponMode defines how a Weapon is used |
| Corxonox::EnergyDrink | Shoots a can |
| Corxonox::FlameGun | A WeaponMode that fires burning projectiles |
| Corxonox::FusionFire | FusionFire |
| Corxonox::GravityBombFire | Fires the GravityBomb |
| ►Corxonox::HsW01 | Shoots laser beams |
| Corxonox::Asteroids2DWeapon | |
| ►Corxonox::InvaderWeapon | |
| Corxonox::InvaderWeaponEnemy | |
| Corxonox::IceGun | A Gun that fires ice arrows that slow down any SpaceShip object that gets hit |
| Corxonox::LaserFire | Shoots a particle laser |
| Corxonox::LightningGun | A slow ball of lightning |
| Corxonox::MineGun | A Weapon that drops mines to space |
| Corxonox::RocketFire | Fires the (steerable) Rocket |
| Corxonox::RocketFireOld | Fires the (steerable) RocketOld |
| Corxonox::SimpleRocketFire | FireMode for target-seeking Rocket |
| Corxonox::SplitGun | A WeaponMode that fires projectiles that may split up into many other projectiles, that may again split up .. |
| Corxonox::WagnisGun | Shoots laser beams |
| Corxonox::WeaponPack | |
| Corxonox::WeaponSet | |
| Corxonox::WeaponSystem | An orxonox::Pawn that is able to fire weapons always need to have a WeaponSystem |
| Corxonox::WorldAmbientSound | This class is used to play and control ambient sound in a level file |
| Corxonox::WorldEntity | The WorldEntity represents everything that can be put in a Scene at a certain location |
| ►Corxonox::OrxonoxInterface | This is the class from which all interfaces of the game-logic (not the engine) are derived from |
| ►Corxonox::BasicProjectile | Baseclass of all projectiles |
| Corxonox::GravityBomb | This class implements how long the bomb flies before it places the GravityField at it's last possition |
| Corxonox::MineProjectile | TODO |
| Corxonox::Projectile | Represents all 'standard' projectiles |
| Corxonox::Rocket | Rocket that can be steered by the player |
| Corxonox::RocketOld | RocketOld that can be steered by the player |
| Corxonox::SimpleRocket | SimpleRocket is a target seeking, intelligent rocket |
| Corxonox::WagnisProjectile | |
| ►Corxonox::GametypeMessageListener | |
| Corxonox::AnnounceMessage | |
| Corxonox::DeathMessage | |
| Corxonox::GametypeFadingMessage | |
| Corxonox::GametypeStaticMessage | |
| Corxonox::KillMessage | |
| ►Corxonox::GSLevelMemento | This class is an interface for all instances that want to maintain a state beyond the reloading of a level |
| Corxonox::Gametype | |
| ►Corxonox::LevelInfoItem | Stores information regarding a Level and makes that information accessible through the LevelManager |
| Corxonox::LevelInfo | Can be used to store information regarding a Level in its level file |
| ►Corxonox::MoodListener | |
| Corxonox::AmbientSound | Used to play background music |
| ►Corxonox::NotificationListener | NotificationListener interface |
| Corxonox::NotificationManager | The Singleton NotificationManager is a NotificationListener and functions as a gateway between Notifications and NotificationQueues |
| ►Corxonox::Pickupable | An Interface (or more precisely an abstract class) to model and represent different (all kinds of) pickups |
| ►Corxonox::CollectiblePickup | Encompasses all Pickupables that can be added to a PickupCollection and thus be part of such |
| Corxonox::Pickup | Offers (useful) base functionality for a wide range of pickups |
| Corxonox::PickupCollection | The PickupCollection combines different Pickupables (more precisely CollectiblePickups) to a coherent, single pickup and makes them seem (from the outside looking in) just as if they were just one Pickupable |
| ►Corxonox::PickupCarrier | The PickupCarrier interface provides the means, for any class implementing it, to possess Pickupables |
| Corxonox::Pawn | Everything in Orxonox that has a health attribute is a Pawn |
| ►Corxonox::PickupListener | Facilitates the flow of information regarding the picking up, dropping, using and unusing of Pickupables to interested parties (such as the PickupManager) |
| Corxonox::PickupManager | Manages Pickupables |
| ►Corxonox::PlayerTrigger | PlayerTrigger is an interface if implemented by a specific trigger can be used to recover the Player (or the Pawn) that triggered it |
| Corxonox::DistanceTrigger | The DistanceTrigger is a Trigger that triggers whenever an object (that is of the specified target type) is in a specified range of the DistanceTrigger |
| Corxonox::MultiTriggerContainer | This class is used by the MultiTrigger class to transport additional data via Events |
| ►Corxonox::RadarListener | |
| Corxonox::HUDNavigation | |
| Corxonox::HUDRadar | |
| Corxonox::WagnisHUD | |
| ►Corxonox::RadarViewable | Interface for receiving window events |
| Corxonox::CheckPoint | |
| Corxonox::GravityBomb | This class implements how long the bomb flies before it places the GravityField at it's last possition |
| Corxonox::GravityBombField | This class is used by GravityBomb to place the ForceField and Visual effect to the environment |
| Corxonox::Pawn | Everything in Orxonox that has a health attribute is a Pawn |
| Corxonox::PortalEndPoint | A PortalEndPoint serves as portal entrance and/or exit |
| Corxonox::RaceCheckPoint | Enables the creation of a check point to use in a SpaceRace level |
| Corxonox::Rocket | Rocket that can be steered by the player |
| Corxonox::RocketOld | RocketOld that can be steered by the player |
| Corxonox::SimpleRocket | SimpleRocket is a target seeking, intelligent rocket |
| ►Corxonox::Rewardable | Rewardable is an Interface, that can be implemented by any object to enable it to be given as reward to a player through QuestEffects |
| Corxonox::Pickupable | An Interface (or more precisely an abstract class) to model and represent different (all kinds of) pickups |
| ►Corxonox::Synchronisable | This class is the base class of all the Objects in the universe that need to be synchronised over the network Every class, that inherits from this class has to link the DATA THAT NEEDS TO BE SYNCHRONISED into the linked list |
| Corxonox::CollisionShape | Wrapper for bullet collision shape class btCollisionShape |
| Corxonox::GlobalShader | |
| Corxonox::Info | |
| Corxonox::Item | |
| Corxonox::Level | |
| Corxonox::NotificationDispatcher | A NotificationDispatcher is an entity that, upon being triggered, dispatches (or sends) a specified Notification |
| Corxonox::NotificationQueue | Displays Notifications from specific senders |
| Corxonox::PickupRepresentation | Specific pickup type |
| Corxonox::Scene | |
| Corxonox::Test | |
| Corxonox::WorldAmbientSound | This class is used to play and control ambient sound in a level file |
| Corxonox::WorldEntity | The WorldEntity represents everything that can be put in a Scene at a certain location |
| ►Corxonox::TeamColourable | |
| Corxonox::Billboard | |
| Corxonox::Light | |
| ►Corxonox::Tickable | The Tickable interface provides a tick(dt) function, that gets called every frame |
| Corxonox::ActionpointController | |
| Corxonox::AIController | |
| Corxonox::AnimatedModel | |
| Corxonox::ArrowController | |
| Corxonox::Asteroids2DHUDinfo | |
| Corxonox::AutonomousDroneController | Controller for the AutonomousDrone of the PPS tutorial |
| Corxonox::BlinkingBillboard | |
| Corxonox::Camera | |
| Corxonox::CountDown | |
| Corxonox::DamageBoostPickup | |
| Corxonox::DebugFPSText | |
| Corxonox::DebugPositionText | |
| Corxonox::DebugRTRText | |
| Corxonox::DockingController | |
| Corxonox::DodgeRaceHUDinfo | |
| Corxonox::DroneController | Controller for the Drone of the PPS tutorial |
| Corxonox::DronePickup | The DronePickup adds a Drone to the Pawn upon being picked up |
| Corxonox::FadeoutText | |
| Corxonox::FadingBillboard | |
| Corxonox::FlagHUD | |
| Corxonox::FlappyOrxHUDinfo | |
| Corxonox::ForceField | Implements a force field, that applies a force to any MobileEntity that enters its range |
| Corxonox::Gametype | |
| Corxonox::HealthPickup | The HealthPickup is a Pickupable that can do (dependent upon the parameters) lots of different things to the health of a Pawn |
| Corxonox::HUDBoostBar | |
| Corxonox::HUDHealthBar | |
| Corxonox::HUDNavigation | |
| Corxonox::HUDPickupSystem | |
| Corxonox::HUDRocketFuelBar | |
| Corxonox::HUDShieldBar | The HUDShieldBar displays the the status of the shield of its owner (a Pawn) |
| Corxonox::HUDSpeedBar | |
| Corxonox::HUDTimer | |
| Corxonox::HUDWeapon | |
| Corxonox::HUDWeaponMode | |
| Corxonox::HumanController | |
| Corxonox::InvaderHUDinfo | |
| Corxonox::JumpScore | |
| Corxonox::LastManStandingInfos | |
| Corxonox::LastTeamStandingInfos | |
| Corxonox::LensFlare | This class adds a configurable LensFlare effect by adding multiple billboards for the several components of lens flare |
| Corxonox::MasterController | Calles action(), maneuver() and canFire() methods of all the ActionpointControllers in level |
| Corxonox::MobileEntity | The MobileEntity is a derived class from orxonox::WorldEntity and orxonox::Tickable |
| Corxonox::NotificationQueue | Displays Notifications from specific senders |
| Corxonox::OrxyRoadHUDinfo | |
| Corxonox::PacmanHUDinfo | |
| Corxonox::PickupSpawner | The PickupSpawner class is responsible for spawning @ref orxonox::Pickupable "Pickupables" of a specific type. |
| Corxonox::Planet | |
| Corxonox::PongAI | The PongAI is an artificial intelligence for the Pong gametype |
| Corxonox::PongScore | Displays the score for a game of Pong |
| Corxonox::Radar | |
| Corxonox::RocketController | Controller for the SimpleRocket (target seeking) |
| Corxonox::Scene | |
| Corxonox::Scoreboard | |
| Corxonox::ScriptController | |
| Corxonox::ShrinkPickup | The ShrinkPickup is a Pickupable that causes the pawn to shrink to a certain size for a certain time with a certain speed, all of them specified in the following variables: |
| Corxonox::ShroomHUD | |
| Corxonox::SkyboxGenerator | Singleton that allows for the creation of a skybox from a level by taking pictures to all 6 sides |
| Corxonox::SOBHUDInfo | |
| Corxonox::SpaceBoundaries | SpaceBoundaries gives level creators the possibility to bar Pawns from leaving a defined area (until now this area is a ball) |
| Corxonox::SpaceRaceController | Conventions: -first Checkpoint has index 0 -staticCheckPoint= static Point (see def over = constructor) |
| Corxonox::SpaceRaceManager | Controls a space race level, where the player has to reach check points in a given order |
| Corxonox::SpicedAsteroidBelt | |
| Corxonox::SpicedAsteroidField | |
| Corxonox::Stats | |
| Corxonox::StoryModeHUD | |
| Corxonox::TeamBaseMatchScore | |
| Corxonox::TeamTargetProxy | A controller, that just copies the team and the target of a parent for itself and it's controllable entity |
| Corxonox::Test | |
| Corxonox::TetrisScore | Displays the score for a game of Tetris |
| Corxonox::TimeHUD | |
| Corxonox::TimeHUD | |
| Corxonox::TowerDefenseHUDController | This subclass of OverlayText is used to display the stats of the player in the HUD |
| Corxonox::TriggerBase | Base class for the two types of triggers, the (normal) Triggers and the MultiTriggers, it encompasses the shared data and functionality between these two types of triggers, but is in itself not a trigger that has any meaningful behavior and thus should not be instantiated |
| Corxonox::TurretController | Controller for turrets |
| Corxonox::WagnisHUD | |
| Corxonox::WagnisHUDinfo | |
| Corxonox::WagnisPlayer | |
| Corxonox::WaypointController | |
| Corxonox::WorldSound | To be used for sounds with position and orientation |
| Corxonox::PluginReference | |
| Corxonox::DestructionHelper< T > | Utility class that helps to create a special kind of destructor that also executes if the destruction fails |
| ►Corxonox::DestructionListener | This listener is used to inform weak pointers if an object of type Destroyable gets destroyed |
| ►Corxonox::FunctorMember< O > | FunctorMember is a child class of Functor and expands it with an object-pointer, that is used for member-functions, as well as an overloaded execution operator |
| ►Corxonox::FunctorPointer< detail::FunctionType< F, R, O, isconst, Params... >::Type, O > | |
| Corxonox::FunctorTemplate< F, R, O, isconst, Params > | FunctorTemplate is a child class of FunctorPointer and implements all functions that need to know the exact types of the parameters, return-value, and class |
| Corxonox::FunctorPointer< F, O > | FunctorPointer is a child class of FunctorMember and extends it with a function-pointer (or a function-object) |
| Corxonox::WeakPtr< T > | WeakPtr wraps a pointer to an object, which becomes nullptr if the object is deleted |
| Corxonox::WeakPtr< orxonox::ActionpointController > | |
| Corxonox::WeakPtr< orxonox::Asteroids2D > | |
| Corxonox::WeakPtr< orxonox::Asteroids2DCenterPoint > | |
| Corxonox::WeakPtr< orxonox::Camera > | |
| Corxonox::WeakPtr< orxonox::ClassIdentifier< T > > | |
| Corxonox::WeakPtr< orxonox::ControllableEntity > | |
| Corxonox::WeakPtr< orxonox::Controller > | |
| Corxonox::WeakPtr< orxonox::Destroyer > | |
| Corxonox::WeakPtr< orxonox::DistanceTrigger > | |
| Corxonox::WeakPtr< orxonox::DodgeRace > | |
| Corxonox::WeakPtr< orxonox::DodgeRaceCenterPoint > | |
| Corxonox::WeakPtr< orxonox::FlappyOrx > | |
| Corxonox::WeakPtr< orxonox::FlappyOrxShip > | |
| Corxonox::WeakPtr< orxonox::Gametype > | |
| Corxonox::WeakPtr< orxonox::GametypeInfo > | |
| Corxonox::WeakPtr< orxonox::GlobalShader > | |
| Corxonox::WeakPtr< orxonox::HoverOrigin > | |
| Corxonox::WeakPtr< orxonox::HUDWeapon > | |
| Corxonox::WeakPtr< orxonox::HUDWeaponMode > | |
| Corxonox::WeakPtr< orxonox::Invader > | |
| Corxonox::WeakPtr< orxonox::InvaderCenterPoint > | |
| Corxonox::WeakPtr< orxonox::InvaderEnemy > | |
| Corxonox::WeakPtr< orxonox::InvaderShip > | |
| Corxonox::WeakPtr< orxonox::JumpCenterpoint > | |
| Corxonox::WeakPtr< orxonox::JumpFigure > | |
| Corxonox::WeakPtr< orxonox::Level > | |
| Corxonox::WeakPtr< orxonox::Namespace > | |
| Corxonox::WeakPtr< orxonox::OrxoKartOrigin > | |
| Corxonox::WeakPtr< orxonox::OrxyRoad > | |
| Corxonox::WeakPtr< orxonox::OrxyRoadCenterPoint > | |
| Corxonox::WeakPtr< orxonox::Pawn > | |
| Corxonox::WeakPtr< orxonox::Pickupable > | |
| Corxonox::WeakPtr< orxonox::PlayerInfo > | |
| Corxonox::WeakPtr< orxonox::PongBall > | |
| Corxonox::WeakPtr< orxonox::PongBat > | |
| Corxonox::WeakPtr< orxonox::PongCenterpoint > | |
| Corxonox::WeakPtr< orxonox::Projectile > | |
| Corxonox::WeakPtr< orxonox::Scene > | |
| Corxonox::WeakPtr< orxonox::SOBCenterpoint > | |
| Corxonox::WeakPtr< orxonox::SOBFigure > | |
| Corxonox::WeakPtr< orxonox::SpaceShip > | |
| Corxonox::WeakPtr< orxonox::SphereCollisionShape > | |
| Corxonox::WeakPtr< orxonox::TetrisBrick > | |
| Corxonox::WeakPtr< orxonox::TetrisCenterpoint > | |
| Corxonox::WeakPtr< orxonox::TowerDefense > | |
| Corxonox::WeakPtr< orxonox::TowerDefenseCenterpoint > | |
| Corxonox::WeakPtr< orxonox::Weapon > | |
| Corxonox::WeakPtr< orxonox::WeaponMode > | |
| Corxonox::WeakPtr< orxonox::WorldEntity > | |
| Corxonox::DodgeRaceShip::Velocity | |
| Corxonox::dontcare_keyword_t | INTERNAL ONLY The type of the 'dontcare' keyword |
| Corxonox::DynLib | Resource holding data about a dynamic library |
| Corxonox::EmptyType | |
| Corxonox::event | Structure to describe a single event |
| Corxonox::Event | The Event struct contains information about a fired Event |
| Corxonox::EventState | The EventState contains information about an event state |
| ►Corxonox::Executor | This class is used to wrap a Functor and to store default values for any of its parameters |
| Corxonox::ExecutorMember< T > | A child class of Executor, used for easier handling of non-static member-functions |
| Corxonox::ExecutorStatic | A child class of Executor, used to distinguish executors that wrap static functions from executors that wrap member-functions |
| Corxonox::ExprParser | Parser for expressions like "3 * cos(5 + 4) / a" where a is a predeclared variable |
| ►Corxonox::Factory | Base-class of all factories |
| ►Corxonox::ClassFactory< T > | The ClassFactory is the base-class of all class-spezific factories |
| Corxonox::ClassFactoryNoArgs< T > | The ClassFactoryNoArgs is able to create new objects of a specific class that require no constructor arguments |
| Corxonox::ClassFactoryWithContext< T > | The ClassFactoryWithContext is able to create new objects of a specific class that require a context as constructor argument |
| Corxonox::FunctionCall | |
| Corxonox::FunctionCallManager | |
| ►Corxonox::Functor | The Functor classes are used to wrap function pointers |
| Corxonox::FunctorMember< O > | FunctorMember is a child class of Functor and expands it with an object-pointer, that is used for member-functions, as well as an overloaded execution operator |
| Corxonox::FunctorMember< void > | Specialization of FunctorMember with T = void |
| ►Corxonox::Game::GameStateFactory | |
| Corxonox::Game::TemplateGameStateFactory< T > | |
| Corxonox::Game::StatisticsTickInfo | |
| Corxonox::GameMode | Helper class, stores and returns the current mode of the game |
| ►Corxonox::GameState | An implementation of a tree to manage game states |
| Corxonox::GSClient | |
| Corxonox::GSGraphics | Game state used when displaying graphics of any kind |
| Corxonox::GSLevel | |
| Corxonox::GSMainMenu | |
| Corxonox::GSMasterServer | |
| Corxonox::GSRoot | |
| Corxonox::GSServer | |
| Corxonox::GSStandalone | |
| Corxonox::GameState::State | Gives information about what the GameState is currently doing |
| ►Corxonox::GamestateHandler | An interface for any class that wants to handle gamestates |
| ►Corxonox::GamestateManager | This Class implements a manager for gamestates: |
| ►Corxonox::Host | Base class of Server and Client This is the Base class of the Server and Client classes |
| Corxonox::Client | Client *client; The network/Client class This class implements all necessary function for the network communication It is the root class of the network module |
| Corxonox::Server | This class is the root class of the network module for a server |
| Corxonox::GameStateInfo | Helper object required before GameStates are being constructed |
| Corxonox::GamestateManager::peerInfo | |
| Corxonox::GameStateTreeNode | Represents one node of the game state tree |
| ►Corxonox::GSLevelMementoState | Represents the state of a memento |
| Corxonox::GametypeMementoState | Keeps position and orientation of the camera, as well as the name of current scene |
| Corxonox::HUDNavigation::ObjectInfo | |
| Corxonox::IcoSphere | Copy-pasted from |
| Corxonox::IcoSphere::LineIndices | |
| Corxonox::IcoSphere::TriangleIndices | |
| ►Corxonox::Identifiable | Identifiable is needed to create the class-hierarchy at startup and to store the Identifier |
| ►Corxonox::Listable | Listable stores the entries of all object lists pointing to this instance |
| ►Corxonox::BaseSound | Base class for all sound file loader classes |
| Corxonox::AmbientSound | Used to play background music |
| Corxonox::WorldSound | To be used for sounds with position and orientation |
| ►Corxonox::ChatListener | Classes inheriting from this interface get a notification whenever a chat message was sent through ChatManager |
| Corxonox::ChatHistory | |
| Corxonox::ChatInputHandler | |
| Corxonox::ChatOverlay | |
| ►Corxonox::ClientConnectionListener | An abstract base class |
| Corxonox::MovableEntity | |
| Corxonox::PlayerManager | |
| Corxonox::Script | Lets you execute a piece of code, either the normal way or in lua, through XML |
| Corxonox::TrafficControl | |
| ►Corxonox::Configurable | This is the base class of all objects which may contain config values |
| Corxonox::CoreConfig | |
| Corxonox::GameConfig | |
| Corxonox::GraphicsManager | Graphics engine manager class |
| Corxonox::GSMainMenu | |
| Corxonox::Highscore | |
| Corxonox::InputBuffer | |
| Corxonox::JoyStick | Wraps around an OIS::JoyStick and forwards the input events to a list of input states |
| Corxonox::KeyBinderManager | Handles the KeyBinders and supplies them throughout the game |
| ►Corxonox::LANDiscoverable | |
| Corxonox::Server | This class is the root class of the network module for a server |
| Corxonox::LevelManager | The LevelManager keeps track of Levels whose activity has been requested and activates the Levels in the list in a FIFO manner with exactly one Level (the first in the list) being active at all times (unless the list is empty) |
| Corxonox::MoodManager | |
| Corxonox::OrxonoxClass | This is the class from which all objects of the game-logic (not the engine) are derived from |
| Corxonox::OrxonoxInterface | This is the class from which all interfaces of the game-logic (not the engine) are derived from |
| Corxonox::PluginManager | |
| Corxonox::ScreenshotManager | Class encapsulates screenshot functionality and provides a method for making multi grid (i.e |
| Corxonox::SkyboxGenerator | Singleton that allows for the creation of a skybox from a level by taking pictures to all 6 sides |
| Corxonox::SoundManager | Manages the OpenAL device, context and listener position |
| ►Corxonox::WANDiscoverable | |
| Corxonox::Server | This class is the root class of the network module for a server |
| Corxonox::WANDiscovery | |
| ►Corxonox::Context | |
| Corxonox::Level | |
| Corxonox::Namespace | |
| Corxonox::Scene | |
| ►Corxonox::DevModeListener | Informs about changes in the Development Mode |
| Corxonox::Shell | The Shell is the logical component of the console that displays output to the user and allows him to enter commands |
| ►Corxonox::JoyStickQuantityListener | Derive from this class to get informed when joy sticks get added/removed |
| Corxonox::InputState | InputStates allow you to customise the input event targets at runtime |
| ►Corxonox::KeyBinder | Maps mouse, keyboard and joy stick input to command strings and executes them |
| Corxonox::KeyDetector | |
| ►Corxonox::NetworkChatListener | The only function of this interface, incomingChat(), gets called whenever a chat message was received through the network |
| Corxonox::ChatManager | This class collects and distributes chat messages |
| ►Corxonox::TimeFactorListener | |
| Corxonox::Backlight | |
| Corxonox::Camera | |
| Corxonox::GSRoot | |
| Corxonox::ParticleInterface | |
| Corxonox::PauseNotice | |
| ►Corxonox::Timer | Timer is a helper class that executes a function after a given amount of seconds in game-time |
| Corxonox::RealTimer | RealTimer is a helper class that executes a function after a given amount of seconds in real-time |
| ►Corxonox::UpdateListener | Inherit from UpdateListener if you need to receive calls before or after the game is ticked |
| Corxonox::DestroyLaterManager | |
| Corxonox::InGameConsole | |
| Corxonox::SoundManager | Manages the OpenAL device, context and listener position |
| ►Corxonox::ViewportEventListener | |
| Corxonox::Shader | Shader is a wrapper class around Ogre::CompositorInstance |
| ►Corxonox::WindowEventListener | Interface for receiving window events like resize, moved and focusChanged |
| Corxonox::Camera | |
| Corxonox::GUIManager | Provides a simple interface to CEGUI with tolua methods and console commands. |
| Corxonox::InGameConsole | |
| Corxonox::InputManager | Manages the input devices (mouse, keyboard, joy sticks) and the input states |
| Corxonox::Mouse | Wraps around an OIS::Mouse and forwards the input events to a list of input states |
| Corxonox::OrxonoxOverlay | Base class to display content directly onto the screen |
| ►Corxonox::XMLNameListener | |
| Corxonox::Attacher | |
| Corxonox::EventListener | |
| Corxonox::EventTarget | |
| ►Corxonox::Identifier::InheritsFrom | Helper class to manually define inheritance |
| Corxonox::StaticallyInitializedIdentifier::InheritsFromClass< T > | |
| Corxonox::incomingEvent | |
| ►Corxonox::InputDevice | Abstract base class for all input devices (mouse, keyboard and joy sticks) |
| ►Corxonox::InputDeviceTemplated< JoyStickTraits > | |
| Corxonox::JoyStick | Wraps around an OIS::JoyStick and forwards the input events to a list of input states |
| ►Corxonox::InputDeviceTemplated< KeyboardTraits > | |
| Corxonox::Keyboard | Wraps around an OIS::Mouse and forwards the input events to a list of input states |
| ►Corxonox::InputDeviceTemplated< MouseTraits > | |
| Corxonox::Mouse | Wraps around an OIS::Mouse and forwards the input events to a list of input states |
| Corxonox::InputDeviceTemplated< Traits > | Heavily templated base class for all three input devices |
| ►Corxonox::InputHandler | Base class for all input handlers like KeyBinder, InputBuffer, etc |
| Corxonox::GUIManager | Provides a simple interface to CEGUI with tolua methods and console commands. |
| Corxonox::InputBuffer | |
| Corxonox::KeyBinder | Maps mouse, keyboard and joy stick input to command strings and executes them |
| Corxonox::IntVector2 | A Vector class containing two integers x and y |
| Corxonox::InvaderEnemy::Velocity | |
| Corxonox::InvaderShip::Velocity | |
| Corxonox::IRC | Creates a Tcl-thread (see TclThreadManager) and connects to an IRC server |
| Corxonox::JoyStickTraits | Template parameter collection for the base class |
| Corxonox::KeyBinder::JoyStickAxisVector | Helper class to use something like std:vector<HalfAxis[48]> |
| Corxonox::KeyBinder::JoyStickButtonVector | Helper class to use something like std:vector<Button[64]> |
| Corxonox::KeyboardTraits | Template parameter collection for the base class |
| Corxonox::KeyEvent | Event argument for key events |
| Corxonox::LanguageEntry | Stores the default- and the translated string of a given entry in the language file |
| Corxonox::LensFlare::Lens | This is a nested Class used to easily set properties of the different sublenses of a LensFlare effect |
| Corxonox::LevelInfoCompare | Struct that overloads the compare operation between two LevelInfoItem pointers |
| Corxonox::LuaFunctor | Callback class that executes lua code |
| Corxonox::LuaState | Representation of an interface to lua |
| Corxonox::MasterServer | |
| Corxonox::MasterServerComm | |
| Corxonox::MazeGenerator | |
| Corxonox::mbool | Mbool is a small helper class that acts like a bool, but keeps track of the number of its state changes |
| Corxonox::MemoryWriter::Message | A helper struct which is used to store output and its properties |
| Corxonox::Mesh | |
| Corxonox::Mini4DgamePosition | |
| Corxonox::Mini4DgameWinner | |
| Corxonox::ModuleInstance | |
| Corxonox::MouseTraits | Template parameter collection for the base class |
| Corxonox::MultiStateEngine::EngineState | |
| Corxonox::MultiTriggerState | Struct to handle MultiTrigger states internally |
| Corxonox::MultiType | The MultiType can hold a value of many possible types and convert them to other types |
| ►Corxonox::MultiType::MT_ValueBase | MT_ValueBase is an almost pure virtual baseclass of MT_Value<T>, which holds the value of the MultiType |
| Corxonox::MT_Value< T > | The MT_Value<T> class is used to hold a value of type T within a MultiType |
| Corxonox::Munition::Magazine | |
| Corxonox::NamespaceNode | |
| ►Corxonox::NetworkCallbackBase | |
| Corxonox::NetworkCallback< T > | |
| Corxonox::NetworkCallbackNotify< T, U > | |
| Corxonox::NetworkCallbackManager | |
| ►Corxonox::NetworkFunctionBase | |
| Corxonox::NetworkFunctionStatic | |
| ►Corxonox::NetworkMemberFunctionBase | |
| Corxonox::NetworkMemberFunction< T > | |
| Corxonox::NetworkFunctionPointer | |
| Corxonox::NilValue< T > | Provides zero value symbols that can be returned as reference |
| Corxonox::Notification | A Notification represents a short message used to inform the player about something that just happened |
| Corxonox::NotificationContainer | Container to allow easy handling of the Notifications |
| Corxonox::NotificationContainerCompare | Struct to allow ordering of NotificationContainers |
| Corxonox::obj | List of objects of this type will be given by the Server's Gamestate Manager |
| Corxonox::ObjectList< T > | The ObjectList contains all objects of the given class |
| Corxonox::ObjectListBase | The ObjectListBase contains all objects of a given class |
| ►Corxonox::ObjectListBaseElement | The list-element of the ObjectListBase |
| Corxonox::ObjectListElement< T > | The list-element that actually contains the object |
| ►Corxonox::ObjectListElementRemovalListener | Gets called by the object list if an element is removed |
| ►Corxonox::IteratorBase< orxonox::BaseObject, Iterator< orxonox::BaseObject > > | |
| Corxonox::Iterator< orxonox::BaseObject > | |
| ►Corxonox::IteratorBase< T, Iterator< T > > | |
| Corxonox::Iterator< T > | The Iterator allows to iterate through a given ObjectList |
| ►Corxonox::IteratorBase< T, ObjectListIterator< T > > | |
| Corxonox::ObjectListIterator< T > | ObjectListIterator<T> allows to iterate through the ObjectList of class T |
| Corxonox::IteratorBase< T, I > | The Iterator allows to iterate through object lists |
| Corxonox::objInfo | List of objects of this type will be given by the Server's Gamestate Manager |
| Corxonox::OrxEnum< T > | Lightweight enumeration class that can be extended at run time |
| Corxonox::OrxyRoadShip::Velocity | |
| Corxonox::outgoingEvent | |
| Corxonox::OutputContextContainer | Stores all information about a context |
| ►Corxonox::OutputListener | OutputListener is an interface which is used to receive output of a certain level and context from OutputManager |
| Corxonox::MemoryWriter | MemoryWriter is a singleton which is derived from OutputListener and writes all output to a list |
| ►Corxonox::SubcontextOutputListener | This class extends the basic OutputListener interface and adds the ability to filter sub-contexts |
| ►Corxonox::BaseWriter | BaseWriter is an output listener and makes the accepted output levels and contexts configurable |
| Corxonox::ConsoleWriter | ConsoleWriter inherits from BaseWriter and writes output to the console |
| Corxonox::LogWriter | Inherits from BaseWriter and writes output to a log-file |
| Corxonox::Shell | The Shell is the logical component of the console that displays output to the user and allows him to enter commands |
| Corxonox::OutputManager::Testing | |
| Corxonox::packet::GamestateHeader | |
| ►Corxonox::packet::Packet | |
| Corxonox::packet::Acknowledgement | |
| Corxonox::packet::Chat | |
| Corxonox::packet::ClassID | |
| Corxonox::packet::DeleteObjects | |
| Corxonox::packet::FunctionCalls | |
| Corxonox::packet::FunctionIDs | |
| Corxonox::packet::Gamestate | |
| Corxonox::packet::Welcome | |
| Corxonox::packet::ServerInformation | |
| Corxonox::PeerList | This class keeps a list of open connections and some info about them |
| Corxonox::PickupInventoryContainer | Data structure to store collected data for one specific Pickupable |
| Corxonox::Player | |
| Corxonox::Plugin | |
| Corxonox::Point | |
| Corxonox::Resource | Provides simple functions to easily access the Ogre::ResourceGroupManager |
| Corxonox::ResourceInfo | Stores basic information about a Resource from Ogre |
| Corxonox::Scope< scope > | A scope for a given template argument is either active or not |
| ►Corxonox::ScopeListener | ScopeListeners register themselves in the corresponding Scope and wait for notifications |
| ►Corxonox::ScopedSingletonWrapper | Base class of ClassScopedSingletonWrapper |
| Corxonox::ClassScopedSingletonWrapper< T, allowedToFail > | Manages a scoped singleton |
| Corxonox::ClassScopedSingletonWrapper< T, true > | This class partially spezializes ClassScopedSingletonWrapper for classes T that are allowed to fail |
| Corxonox::ScriptableController | Runs a scripts on a per-level basis and handles the connection to orxonox |
| Corxonox::ScriptableControllerAPI | API for ScriptableController's lua-scripts |
| Corxonox::ScriptableControllerAPI::AreaHandler | Groups everything together that is needed to handle an area enter/leave event |
| Corxonox::ScriptableControllerAPI::NearObjectHandler | Groups everything together that is needed to handle a near-object event |
| Corxonox::ScriptableControllerAPI::NearPointHandler | Groups everything together that is needed to handle a near-poinb event |
| Corxonox::ServerList | This class is keeps a list of game servers and some info about them |
| Corxonox::ServerListElem | |
| Corxonox::ServerListSearchResult | |
| Corxonox::Shader::ParameterContainer | Helper struct to store parameters for shader programs |
| ►Corxonox::ShellListener | An interface, used to get a notification if the state of the Shell changes |
| Corxonox::InGameConsole | |
| Corxonox::IOConsole | |
| Corxonox::SignalCallbackRec | |
| Corxonox::SignalRec | |
| ►Corxonox::Singleton< T > | Base for singleton classes |
| Corxonox::DynLibManager | Manager for Dynamic-loading Libraries |
| Corxonox::ScreenshotManager | Class encapsulates screenshot functionality and provides a method for making multi grid (i.e |
| Corxonox::SignalHandler | The SignalHandler is used to catch signals like SIGSEGV and write a backtrace to the logfile |
| Corxonox::SmallObjectAllocator | This class is used to allocate and free small objects (usually not polymorphic) |
| Corxonox::SmallObjectAllocator::Chunk | The memory chunk is at the same time an element of a single linked list |
| Corxonox::SoundBuffer | |
| Corxonox::SoundStreamer | |
| Corxonox::SpaceBoundaries::BillboardAdministration | |
| ►Corxonox::StaticallyInitializedInstance | |
| Corxonox::StaticallyInitializedCommandLineArgument | |
| Corxonox::StaticallyInitializedConsoleCommand | |
| Corxonox::StaticallyInitializedIdentifier | The static initializer stores the parent classes of this identifier |
| Corxonox::StaticallyInitializedNetworkFunction | |
| Corxonox::StaticallyInitializedScopedSingletonWrapper | |
| Corxonox::StaticallyInitializedStaticInitializationHandler | |
| ►Corxonox::StaticInitializationHandler | |
| Corxonox::CoreStaticInitializationHandler | |
| Corxonox::NetworkStaticInitializationHandler | |
| Corxonox::StrongPtr< T > | A strong pointer which wraps a pointer to an object and keeps this object alive as long as the strong pointer exists |
| Corxonox::SubclassIdentifier< T > | The SubclassIdentifier acts almost like an Identifier, but has some prerequisites |
| Corxonox::SubString | A class that splits a string into multiple tokens using different options |
| Corxonox::SuperFunctionCondition< functionnumber, T, templatehack1, templatehack2 > | Creates the SuperFunctionCaller if T is a child of the super-functions baseclass |
| Corxonox::SuperFunctionDestruction< functionnumber, T > | Deletes the SuperFunctionCaller |
| Corxonox::SuperFunctionInitialization< functionnumber, T > | Initializes the SuperFunctionCaller-pointer with zero |
| ►Corxonox::SynchronisableHeaderLight | : stores information about a Synchronisable (light version) |
| Corxonox::SynchronisableHeader | : stores information about a Synchronisable |
| ►Corxonox::SynchronisableVariableBase | |
| ►Corxonox::SynchronisableVariable< T > | |
| Corxonox::SynchronisableVariableBidirectional< T > | |
| Corxonox::TclInterpreterBundle | A struct containing all information about a Tcl-interpreter |
| Corxonox::TclThreadList< T > | A thread-safe implementation of a message queue, used by TclThreadManager |
| Corxonox::TDCoordinate | |
| Corxonox::TextureGenerator | |
| Corxonox::Thread | |
| Corxonox::ThreadPool | |
| Corxonox::ToluaBindingsHelper | Helper class that registers/unregisters tolua bindings |
| Corxonox::tribool | A 3-state boolean type |
| Corxonox::WagnisHUD::ObjectInfo | |
| Corxonox::XMLFile | |
| Corxonox::XMLPortClassParamContainer< T >::ParseParams | |
| ►Corxonox::XMLPortObjectContainer | |
| Corxonox::XMLPortClassObjectContainer< T, O > | |
| ►Corxonox::XMLPortParamContainer | |
| Corxonox::XMLPortClassParamContainer< T > | |
| Corxonox::XMLPortVariableHelperClass | Helper class to load and save simple variables with XMLPort |
| ►CRenderer | |
| CCEGUI::OgreCEGUIRenderer | Renderer class to interface with Ogre engine |
| ►CResourceProvider | |
| CCEGUI::OgreCEGUIResourceProvider | |
| Corxonox::Scope< ScopeID::GRAPHICS > | |
| Corxonox::Scope< ScopeID::ROOT > | |
| Ctesting::internal::scoped_ptr< ::std::string > | |
| Ctesting::internal::scoped_ptr< ::std::stringstream > | |
| Ctesting::internal::scoped_ptr< const ::std::string > | |
| ►CSimpleRenderable | |
| ►COgre::DynamicRenderable | Abstract base class providing mechanisms for dynamically growing hardware buffers |
| COgre::DynamicLines | |
| ►Corxonox::Singleton< ApplicationPaths > | |
| Corxonox::ApplicationPaths | Singleton which provides static paths of the application |
| ►Corxonox::Singleton< CameraManager > | |
| Corxonox::CameraManager | |
| ►Corxonox::Singleton< ChatHistory > | |
| Corxonox::ChatHistory | |
| ►Corxonox::Singleton< ChatInputHandler > | |
| Corxonox::ChatInputHandler | |
| ►Corxonox::Singleton< ChatManager > | |
| Corxonox::ChatManager | This class collects and distributes chat messages |
| ►Corxonox::Singleton< Client > | |
| Corxonox::Client | Client *client; The network/Client class This class implements all necessary function for the network communication It is the root class of the network module |
| ►Corxonox::Singleton< CommandLineParser > | |
| Corxonox::CommandLineParser | Global interface to command line options |
| ►Corxonox::Singleton< ConfigFileManager > | |
| Corxonox::ConfigFileManager | Manages the different config files (settings, calibration, etc) |
| ►Corxonox::Singleton< ConfigurablePaths > | |
| Corxonox::ConfigurablePaths | Singleton used to configure different paths |
| ►Corxonox::Singleton< ConsoleCommandManager > | |
| Corxonox::ConsoleCommandManager | A singleton that stores all existing ConsoleCommands |
| ►Corxonox::Singleton< Core > | |
| Corxonox::Core | Singleton used to configure the program basics |
| ►Corxonox::Singleton< DestroyLaterManager > | |
| Corxonox::DestroyLaterManager | |
| ►Corxonox::Singleton< DialogManager > | |
| Corxonox::DialogManager | This class is used for calling on a dialog form luascript |
| Corxonox::Singleton< DynLibManager > | |
| ►Corxonox::Singleton< Game > | |
| Corxonox::Game | Main class responsible for running the game |
| ►Corxonox::Singleton< GraphicsManager > | |
| Corxonox::GraphicsManager | Graphics engine manager class |
| ►Corxonox::Singleton< GUIManager > | |
| Corxonox::GUIManager | Provides a simple interface to CEGUI with tolua methods and console commands. |
| ►Corxonox::Singleton< Highscore > | |
| Corxonox::Highscore | |
| ►Corxonox::Singleton< IdentifierManager > | |
| Corxonox::IdentifierManager | |
| ►Corxonox::Singleton< InGameConsole > | |
| Corxonox::InGameConsole | |
| ►Corxonox::Singleton< InputManager > | |
| Corxonox::InputManager | Manages the input devices (mouse, keyboard, joy sticks) and the input states |
| ►Corxonox::Singleton< IOConsole > | |
| Corxonox::IOConsole | |
| ►Corxonox::Singleton< KeyBinderManager > | |
| Corxonox::KeyBinderManager | Handles the KeyBinders and supplies them throughout the game |
| ►Corxonox::Singleton< KeyDetector > | |
| Corxonox::KeyDetector | |
| ►Corxonox::Singleton< LANDiscovery > | |
| Corxonox::LANDiscovery | |
| ►Corxonox::Singleton< Language > | |
| Corxonox::Language | Manges the language files and entries and stores the LanguageEntry objects in a map |
| ►Corxonox::Singleton< LevelManager > | |
| Corxonox::LevelManager | The LevelManager keeps track of Levels whose activity has been requested and activates the Levels in the list in a FIFO manner with exactly one Level (the first in the list) being active at all times (unless the list is empty) |
| ►Corxonox::Singleton< Loader > | |
| Corxonox::Loader | |
| ►Corxonox::Singleton< MoodManager > | |
| Corxonox::MoodManager | |
| ►Corxonox::Singleton< NetworkFunctionManager > | |
| Corxonox::NetworkFunctionManager | |
| ►Corxonox::Singleton< NotificationManager > | |
| Corxonox::NotificationManager | The Singleton NotificationManager is a NotificationListener and functions as a gateway between Notifications and NotificationQueues |
| ►Corxonox::Singleton< PickupManager > | |
| Corxonox::PickupManager | Manages Pickupables |
| ►Corxonox::Singleton< PlayerManager > | |
| Corxonox::PlayerManager | |
| ►Corxonox::Singleton< PluginManager > | |
| Corxonox::PluginManager | |
| ►Corxonox::Singleton< QuestManager > | |
| Corxonox::QuestManager | Is a Singleton and manages Quests, by registering every Quest / QuestHint (through registerX()) and making them globally accessible (through findX()) |
| ►Corxonox::Singleton< ScopeManager > | |
| Corxonox::ScopeManager | The ScopeManager stores the variables of the Scope templates in a statically linked context |
| Corxonox::Singleton< ScreenshotManager > | |
| ►Corxonox::Singleton< SettingsConfigFile > | |
| Corxonox::SettingsConfigFile | Child class of ConfigFile, used to store the settings of the game |
| Corxonox::Singleton< SignalHandler > | |
| ►Corxonox::Singleton< SkyboxGenerator > | |
| Corxonox::SkyboxGenerator | Singleton that allows for the creation of a skybox from a level by taking pictures to all 6 sides |
| ►Corxonox::Singleton< SoundManager > | |
| Corxonox::SoundManager | Manages the OpenAL device, context and listener position |
| ►Corxonox::Singleton< StaticInitializationManager > | |
| Corxonox::StaticInitializationManager | |
| ►Corxonox::Singleton< TclBind > | |
| Corxonox::TclBind | A wrapper class for a Tcl interpreter |
| ►Corxonox::Singleton< TclThreadManager > | |
| Corxonox::TclThreadManager | |
| ►Ctype | |
| CIsCallable< T > | Checks if a type is callable |
| ►Cstd::exception | STL class |
| COIS::Exception | |
| Corxonox::Exception | Base class for all exceptions (derived from std::exception) |
| ►Cstd::ios_base | STL class |
| ►Cstd::basic_ios< Char > | STL class |
| ►Cstd::basic_ostream< Char > | STL class |
| ►Cstd::basic_ostringstream< Char > | STL class |
| ►Cstd::ostringstream | STL class |
| Corxonox::OutputStream | This class is used to buffer output and send it to OutputManager whenever std::endl is passed to it |
| Cstd::tr1::gtest_internal::AddRef< T > | |
| Cstd::tr1::gtest_internal::AddRef< T & > | |
| Cstd::tr1::gtest_internal::ByRef< T > | |
| Cstd::tr1::gtest_internal::ByRef< T & > | |
| Cstd::tr1::gtest_internal::Get< k > | |
| Cstd::tr1::gtest_internal::Get< 0 > | |
| Cstd::tr1::gtest_internal::Get< 1 > | |
| Cstd::tr1::gtest_internal::Get< 2 > | |
| Cstd::tr1::gtest_internal::Get< 3 > | |
| Cstd::tr1::gtest_internal::Get< 4 > | |
| Cstd::tr1::gtest_internal::Get< 5 > | |
| Cstd::tr1::gtest_internal::Get< 6 > | |
| Cstd::tr1::gtest_internal::Get< 7 > | |
| Cstd::tr1::gtest_internal::Get< 8 > | |
| Cstd::tr1::gtest_internal::Get< 9 > | |
| Cstd::tr1::gtest_internal::SameSizeTuplePrefixComparator< kSize1, kSize2 > | |
| Cstd::tr1::gtest_internal::SameSizeTuplePrefixComparator< 0, 0 > | |
| Cstd::tr1::gtest_internal::SameSizeTuplePrefixComparator< k, k > | |
| Cstd::tr1::gtest_internal::TupleElement< kIndexValid, kIndex, Tuple > | |
| Cstd::tr1::gtest_internal::TupleElement< true, 0, GTEST_10_TUPLE_(T)> | |
| Cstd::tr1::gtest_internal::TupleElement< true, 1, GTEST_10_TUPLE_(T)> | |
| Cstd::tr1::gtest_internal::TupleElement< true, 2, GTEST_10_TUPLE_(T)> | |
| Cstd::tr1::gtest_internal::TupleElement< true, 3, GTEST_10_TUPLE_(T)> | |
| Cstd::tr1::gtest_internal::TupleElement< true, 4, GTEST_10_TUPLE_(T)> | |
| Cstd::tr1::gtest_internal::TupleElement< true, 5, GTEST_10_TUPLE_(T)> | |
| Cstd::tr1::gtest_internal::TupleElement< true, 6, GTEST_10_TUPLE_(T)> | |
| Cstd::tr1::gtest_internal::TupleElement< true, 7, GTEST_10_TUPLE_(T)> | |
| Cstd::tr1::gtest_internal::TupleElement< true, 8, GTEST_10_TUPLE_(T)> | |
| Cstd::tr1::gtest_internal::TupleElement< true, 9, GTEST_10_TUPLE_(T)> | |
| Cstd::tr1::tuple<> | |
| Cstd::tr1::tuple<> | |
| Cstd::tr1::tuple_element< k, Tuple > | |
| Cstd::tr1::tuple_size< Tuple > | |
| Cstd::tr1::tuple_size< GTEST_0_TUPLE_(T)> | |
| Cstd::tr1::tuple_size< GTEST_10_TUPLE_(T)> | |
| Cstd::tr1::tuple_size< GTEST_1_TUPLE_(T)> | |
| Cstd::tr1::tuple_size< GTEST_2_TUPLE_(T)> | |
| Cstd::tr1::tuple_size< GTEST_3_TUPLE_(T)> | |
| Cstd::tr1::tuple_size< GTEST_4_TUPLE_(T)> | |
| Cstd::tr1::tuple_size< GTEST_5_TUPLE_(T)> | |
| Cstd::tr1::tuple_size< GTEST_6_TUPLE_(T)> | |
| Cstd::tr1::tuple_size< GTEST_7_TUPLE_(T)> | |
| Cstd::tr1::tuple_size< GTEST_8_TUPLE_(T)> | |
| Cstd::tr1::tuple_size< GTEST_9_TUPLE_(T)> | |
| ►Cunary_function | |
| CFindAxisCookie | |
| Corxonox::BaseObject::StrongOrWeakPtr< orxonox::Gametype > | |
| Corxonox::BaseObject::StrongOrWeakPtr< orxonox::Level > | |
| Corxonox::BaseObject::StrongOrWeakPtr< orxonox::Namespace > | |
| Corxonox::BaseObject::StrongOrWeakPtr< orxonox::Scene > | |
| Corxonox::StrongPtr< orxonox::AmbientSound > | |
| Corxonox::StrongPtr< orxonox::CameraPosition > | |
| Corxonox::StrongPtr< orxonox::Destroyable > | |
| Corxonox::StrongPtr< orxonox::Gametype > | |
| Corxonox::StrongPtr< orxonox::Level > | |
| Corxonox::StrongPtr< orxonox::Namespace > | |
| Corxonox::StrongPtr< orxonox::OrxonoxOverlay > | |
| Corxonox::StrongPtr< orxonox::OverlayText > | |
| Corxonox::StrongPtr< orxonox::Radar > | |
| Corxonox::StrongPtr< orxonox::Scene > | |
| Corxonox::StrongPtr< orxonox::TetrisStone > | |
| Corxonox::SubclassIdentifier< orxonox::Bot > | |
| Corxonox::SubclassIdentifier< orxonox::ControllableEntity > | |
| Corxonox::SubclassIdentifier< orxonox::Controller > | |
| Corxonox::SubclassIdentifier< orxonox::Munition > | |
| Corxonox::SubclassIdentifier< orxonox::Pawn > | |
| ►CT | |
| CIsCallableImpl< T >::Derived | |
| Corxonox::TclThreadList< std::string > | |
| Corxonox::TclThreadList< unsigned int > | |
| Ctesting::Action< F > | |
| ►Ctesting::ActionInterface< F > | |
| Ctesting::internal::DoBothAction< Action1, Action2 >::Impl< F > | |
| Ctesting::internal::IgnoreResultAction< A >::Impl< F > | |
| Ctesting::internal::ReturnAction< R >::Impl< F > | |
| Ctesting::internal::ReturnRefAction< T >::Impl< F > | |
| Ctesting::internal::ReturnRefOfCopyAction< T >::Impl< F > | |
| Ctesting::internal::WithArgsAction< InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 >::Impl< F > | |
| Ctesting::PolymorphicAction< Impl >::MonomorphicImpl< F > | |
| Ctesting::AssertionResult | |
| Ctesting::Cardinality | |
| Ctesting::CardinalityInterface | |
| Ctesting::DefaultValue< T > | |
| Ctesting::DefaultValue< T & > | |
| Ctesting::DefaultValue< void > | |
| Ctesting::Environment | |
| Ctesting::Environment::Setup_should_be_spelled_SetUp | |
| Ctesting::Expectation | |
| Ctesting::Expectation::Less | |
| Ctesting::ExpectationSet | |
| Ctesting::InSequence | |
| Ctesting::internal2::TypeWithoutFormatter< T, kTypeKind > | |
| Ctesting::internal2::TypeWithoutFormatter< T, kConvertibleToInteger > | |
| Ctesting::internal2::TypeWithoutFormatter< T, kProtobuf > | |
| Ctesting::internal::ActionHelper< Result, Impl > | |
| Ctesting::internal::AddReference< T > | |
| Ctesting::internal::AddReference< T & > | |
| Ctesting::internal::AnythingMatcher | |
| Ctesting::internal::ArgsMatcher< InnerMatcher, k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 > | |
| Ctesting::internal::AssertHelper | |
| Ctesting::internal::AssertHelper::AssertHelperData | |
| Ctesting::internal::AssignAction< T1, T2 > | |
| ►Ctesting::internal::bool_constant< bool_value > | |
| Ctesting::internal::is_pointer< T > | |
| Ctesting::internal::is_pointer< T * > | |
| Ctesting::internal::is_reference< T > | |
| Ctesting::internal::is_reference< T & > | |
| Ctesting::internal::LosslessArithmeticConvertibleImpl< kFromKind, From, kToKind, To > | |
| Ctesting::internal::LosslessArithmeticConvertibleImpl< kBool, bool, kBool, bool > | |
| Ctesting::internal::LosslessArithmeticConvertibleImpl< kBool, bool, kFloatingPoint, To > | |
| Ctesting::internal::LosslessArithmeticConvertibleImpl< kBool, bool, kInteger, To > | |
| Ctesting::internal::LosslessArithmeticConvertibleImpl< kFloatingPoint, From, kBool, bool > | |
| Ctesting::internal::LosslessArithmeticConvertibleImpl< kFloatingPoint, From, kInteger, To > | |
| Ctesting::internal::LosslessArithmeticConvertibleImpl< kInteger, From, kBool, bool > | |
| Ctesting::internal::LosslessArithmeticConvertibleImpl< kInteger, From, kFloatingPoint, To > | |
| Ctesting::internal::type_equals< T1, T2 > | |
| Ctesting::internal::type_equals< T, T > | |
| Ctesting::internal::BothOfMatcher< Matcher1, Matcher2 > | |
| Ctesting::internal::BuiltInDefaultValue< T > | |
| Ctesting::internal::BuiltInDefaultValue< const T > | |
| Ctesting::internal::BuiltInDefaultValue< T * > | |
| Ctesting::internal::CallableHelper< R > | |
| Ctesting::internal::CallableTraits< Functor > | |
| Ctesting::internal::CallableTraits< ResType(*)(ArgType)> | |
| Ctesting::internal::CompileAssert< bool > | |
| Ctesting::internal::CompileAssertTypesEqual< T1, T2 > | |
| Ctesting::internal::CompileAssertTypesEqual< T, T > | |
| Ctesting::internal::ConstCharPtr | |
| Ctesting::internal::ContainerEqMatcher< Container > | |
| Ctesting::internal::ContainsMatcher< M > | |
| Ctesting::internal::DoBothAction< Action1, Action2 > | |
| Ctesting::internal::DoDefaultAction | |
| Ctesting::internal::EachMatcher< M > | |
| Ctesting::internal::EitherOfMatcher< Matcher1, Matcher2 > | |
| Ctesting::internal::ElementsAreArrayMatcher< T > | |
| Ctesting::internal::ElementsAreMatcher0 | |
| Ctesting::internal::ElementsAreMatcher1< T1 > | |
| Ctesting::internal::ElementsAreMatcher10< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 > | |
| Ctesting::internal::ElementsAreMatcher2< T1, T2 > | |
| Ctesting::internal::ElementsAreMatcher3< T1, T2, T3 > | |
| Ctesting::internal::ElementsAreMatcher4< T1, T2, T3, T4 > | |
| Ctesting::internal::ElementsAreMatcher5< T1, T2, T3, T4, T5 > | |
| Ctesting::internal::ElementsAreMatcher6< T1, T2, T3, T4, T5, T6 > | |
| Ctesting::internal::ElementsAreMatcher7< T1, T2, T3, T4, T5, T6, T7 > | |
| Ctesting::internal::ElementsAreMatcher8< T1, T2, T3, T4, T5, T6, T7, T8 > | |
| Ctesting::internal::ElementsAreMatcher9< T1, T2, T3, T4, T5, T6, T7, T8, T9 > | |
| Ctesting::internal::EnableIf< bool > | |
| Ctesting::internal::EnableIf< true > | |
| Ctesting::internal::EndsWithMatcher< StringType > | |
| Ctesting::internal::EqHelper< lhs_is_null_literal > | |
| Ctesting::internal::EqHelper< true > | |
| Ctesting::internal::ExcessiveArg | |
| ►Ctesting::internal::ExpectationBase | |
| Ctesting::internal::TypedExpectation< F > | |
| Ctesting::internal::FieldMatcher< Class, FieldType > | |
| Ctesting::internal::FilePath | |
| Ctesting::internal::FloatingEqMatcher< FloatType > | |
| Ctesting::internal::FloatingPoint< RawType > | |
| Ctesting::internal::FloatingPoint< RawType >::FloatingPointUnion | |
| Ctesting::internal::Function< F > | |
| ►Ctesting::internal::Function< R()> | |
| ►Ctesting::internal::Function< R(A1)> | |
| ►Ctesting::internal::Function< R(A1, A2)> | |
| ►Ctesting::internal::Function< R(A1, A2, A3)> | |
| ►Ctesting::internal::Function< R(A1, A2, A3, A4)> | |
| ►Ctesting::internal::Function< R(A1, A2, A3, A4, A5)> | |
| ►Ctesting::internal::Function< R(A1, A2, A3, A4, A5, A6)> | |
| ►Ctesting::internal::Function< R(A1, A2, A3, A4, A5, A6, A7)> | |
| ►Ctesting::internal::Function< R(A1, A2, A3, A4, A5, A6, A7, A8)> | |
| ►Ctesting::internal::Function< R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> | |
| Ctesting::internal::Function< R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> | |
| Ctesting::internal::FunctionMocker< F > | |
| Ctesting::internal::GTestFlagSaver | |
| Ctesting::internal::GTestLog | |
| Ctesting::internal::GTestMutexLock | |
| Ctesting::internal::HasSubstrMatcher< StringType > | |
| Ctesting::internal::IgnoredValue | |
| Ctesting::internal::IgnoreResultAction< A > | |
| Ctesting::internal::ImplicitlyConvertible< From, To > | |
| Ctesting::internal::InvokeAction< FunctionImpl > | |
| Ctesting::internal::InvokeHelper< Result, ArgumentTuple > | |
| Ctesting::internal::InvokeHelper< R,::std::tr1::tuple< A1 > > | |
| Ctesting::internal::InvokeHelper< R,::std::tr1::tuple< A1, A2 > > | |
| Ctesting::internal::InvokeHelper< R,::std::tr1::tuple< A1, A2, A3 > > | |
| Ctesting::internal::InvokeHelper< R,::std::tr1::tuple< A1, A2, A3, A4 > > | |
| Ctesting::internal::InvokeHelper< R,::std::tr1::tuple< A1, A2, A3, A4, A5 > > | |
| Ctesting::internal::InvokeHelper< R,::std::tr1::tuple< A1, A2, A3, A4, A5, A6 > > | |
| Ctesting::internal::InvokeHelper< R,::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7 > > | |
| Ctesting::internal::InvokeHelper< R,::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7, A8 > > | |
| Ctesting::internal::InvokeHelper< R,::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7, A8, A9 > > | |
| Ctesting::internal::InvokeHelper< R,::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 > > | |
| Ctesting::internal::InvokeHelper< R,::std::tr1::tuple<> > | |
| Ctesting::internal::InvokeMethodAction< Class, MethodPtr > | |
| Ctesting::internal::InvokeMethodWithoutArgsAction< Class, MethodPtr > | |
| Ctesting::internal::InvokeWithoutArgsAction< FunctionImpl > | |
| Ctesting::internal::IsNullMatcher | |
| Ctesting::internal::IteratorTraits< Iterator > | |
| Ctesting::internal::IteratorTraits< const T * > | |
| Ctesting::internal::IteratorTraits< T * > | |
| Ctesting::internal::KeyMatcher< M > | |
| Ctesting::internal::KindOf< T > | |
| Ctesting::internal::linked_ptr< T > | |
| Ctesting::internal::linked_ptr_internal | |
| Ctesting::internal::LinkedPtrLessThan< T > | |
| Ctesting::internal::MatcherAsPredicate< M > | |
| ►Ctesting::internal::MatcherBase< T > | |
| Ctesting::Matcher< const ArgumentTuple & > | |
| Ctesting::Matcher< const Element & > | |
| Ctesting::Matcher< const FieldType & > | |
| Ctesting::Matcher< const FirstType & > | |
| Ctesting::Matcher< const KeyType & > | |
| Ctesting::Matcher< const Pointee & > | |
| Ctesting::Matcher< const SecondType & > | |
| Ctesting::Matcher< RefToConstProperty > | |
| Ctesting::Matcher< ResultType > | |
| Ctesting::Matcher< std::tr1::tuple > | |
| Ctesting::Matcher< U > | |
| Ctesting::Matcher< T > | |
| Ctesting::internal::MatcherCastImpl< T, M > | |
| Ctesting::internal::MatcherCastImpl< T, Matcher< T > > | |
| Ctesting::internal::MatcherCastImpl< T, Matcher< U > > | |
| Ctesting::internal::MatcherTuple< Tuple > | |
| Ctesting::internal::MatcherTuple< ::std::tr1::tuple< A1 > > | |
| Ctesting::internal::MatcherTuple< ::std::tr1::tuple< A1, A2 > > | |
| Ctesting::internal::MatcherTuple< ::std::tr1::tuple< A1, A2, A3 > > | |
| Ctesting::internal::MatcherTuple< ::std::tr1::tuple< A1, A2, A3, A4 > > | |
| Ctesting::internal::MatcherTuple< ::std::tr1::tuple< A1, A2, A3, A4, A5 > > | |
| Ctesting::internal::MatcherTuple< ::std::tr1::tuple< A1, A2, A3, A4, A5, A6 > > | |
| Ctesting::internal::MatcherTuple< ::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7 > > | |
| Ctesting::internal::MatcherTuple< ::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7, A8 > > | |
| Ctesting::internal::MatcherTuple< ::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7, A8, A9 > > | |
| Ctesting::internal::MatcherTuple< ::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 > > | |
| Ctesting::internal::MatcherTuple< ::std::tr1::tuple<> > | |
| Ctesting::internal::MatchesRegexMatcher | |
| Ctesting::internal::MockSpec< F > | |
| Ctesting::internal::Mutex | |
| Ctesting::internal::NativeArray< Element > | |
| Ctesting::internal::NotMatcher< InnerMatcher > | |
| Ctesting::internal::NotNullMatcher | |
| ►Ctesting::internal::OsStackTraceGetterInterface | |
| Ctesting::internal::OsStackTraceGetter | |
| Ctesting::internal::PairMatcher< FirstMatcher, SecondMatcher > | |
| Ctesting::internal::PointeeMatcher< InnerMatcher > | |
| Ctesting::internal::PointeeOf< Pointer > | |
| Ctesting::internal::PointeeOf< T * > | |
| Ctesting::internal::PointwiseMatcher< TupleMatcher, RhsContainer > | |
| Ctesting::internal::PredicateFormatterFromMatcher< M > | |
| Ctesting::internal::PropertyMatcher< Class, PropertyType > | |
| Ctesting::internal::Random | |
| Ctesting::internal::RE | |
| Ctesting::internal::ReferenceWrapper< T > | |
| Ctesting::internal::RefMatcher< T > | |
| Ctesting::internal::RefMatcher< T & > | |
| Ctesting::internal::remove_reference< T > | |
| Ctesting::internal::remove_reference< T & > | |
| Ctesting::internal::RemoveConst< T > | |
| Ctesting::internal::RemoveConst< const T > | |
| Ctesting::internal::RemoveReference< T > | |
| Ctesting::internal::RemoveReference< T & > | |
| Ctesting::internal::ResultOfMatcher< Callable > | |
| Ctesting::internal::ReturnAction< R > | |
| Ctesting::internal::ReturnNullAction | |
| Ctesting::internal::ReturnRefAction< T > | |
| Ctesting::internal::ReturnRefOfCopyAction< T > | |
| Ctesting::internal::ReturnVoidAction | |
| Ctesting::internal::scoped_ptr< T > | |
| Ctesting::internal::ScopedTrace | |
| Ctesting::internal::SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > | |
| Ctesting::internal::SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, k7, k8, k9,-1 > | |
| Ctesting::internal::SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, k7, k8,-1,-1 > | |
| Ctesting::internal::SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, k7,-1,-1,-1 > | |
| Ctesting::internal::SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6,-1,-1,-1,-1 > | |
| Ctesting::internal::SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5,-1,-1,-1,-1,-1 > | |
| Ctesting::internal::SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4,-1,-1,-1,-1,-1,-1 > | |
| Ctesting::internal::SelectArgs< Result, ArgumentTuple, k1, k2, k3,-1,-1,-1,-1,-1,-1,-1 > | |
| Ctesting::internal::SelectArgs< Result, ArgumentTuple, k1, k2,-1,-1,-1,-1,-1,-1,-1,-1 > | |
| Ctesting::internal::SelectArgs< Result, ArgumentTuple, k1,-1,-1,-1,-1,-1,-1,-1,-1,-1 > | |
| Ctesting::internal::SelectArgs< Result, ArgumentTuple,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 > | |
| Ctesting::internal::SetArgumentPointeeAction< N, A, kIsProto > | |
| Ctesting::internal::SetArgumentPointeeAction< N, Proto, true > | |
| Ctesting::internal::SetErrnoAndReturnAction< T > | |
| Ctesting::internal::SingleFailureChecker | |
| Ctesting::internal::StartsWithMatcher< StringType > | |
| Ctesting::internal::StaticAssertTypeEqHelper< T1, T2 > | |
| Ctesting::internal::StaticAssertTypeEqHelper< T, T > | |
| Ctesting::internal::StlContainerView< RawContainer > | |
| Ctesting::internal::StlContainerView< ::std::tr1::tuple< ElementPointer, Size > > | |
| Ctesting::internal::StlContainerView< Element[N]> | |
| Ctesting::internal::StrEqualityMatcher< StringType > | |
| Ctesting::internal::String | |
| Ctesting::internal::TestCaseNameIs | |
| ►Ctesting::internal::TestFactoryBase | |
| Ctesting::internal::TestFactoryImpl< TestClass > | |
| Ctesting::internal::TestPropertyKeyIs | |
| Ctesting::internal::TestResultAccessor | |
| Ctesting::internal::ThreadLocal< T > | |
| Ctesting::internal::TraceInfo | |
| Ctesting::internal::TrulyMatcher< Predicate > | |
| Ctesting::internal::TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 > | |
| Ctesting::internal::TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8,-1 > | |
| Ctesting::internal::TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7,-1,-1 > | |
| Ctesting::internal::TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6,-1,-1,-1 > | |
| Ctesting::internal::TupleFields< Tuple, k0, k1, k2, k3, k4, k5,-1,-1,-1,-1 > | |
| Ctesting::internal::TupleFields< Tuple, k0, k1, k2, k3, k4,-1,-1,-1,-1,-1 > | |
| Ctesting::internal::TupleFields< Tuple, k0, k1, k2, k3,-1,-1,-1,-1,-1,-1 > | |
| Ctesting::internal::TupleFields< Tuple, k0, k1, k2,-1,-1,-1,-1,-1,-1,-1 > | |
| Ctesting::internal::TupleFields< Tuple, k0, k1,-1,-1,-1,-1,-1,-1,-1,-1 > | |
| Ctesting::internal::TupleFields< Tuple, k0,-1,-1,-1,-1,-1,-1,-1,-1,-1 > | |
| Ctesting::internal::TupleFields< Tuple,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 > | |
| Ctesting::internal::TuplePrefix< N > | |
| Ctesting::internal::TuplePrefix< 0 > | |
| Ctesting::internal::TypeIdHelper< T > | |
| Ctesting::internal::TypeWithSize< size > | |
| Ctesting::internal::TypeWithSize< 4 > | |
| Ctesting::internal::TypeWithSize< 8 > | |
| Ctesting::internal::UnitTestImpl | |
| Ctesting::internal::UnitTestOptions | |
| Ctesting::internal::UniversalPrinter< T > | |
| Ctesting::internal::UniversalPrinter< T & > | |
| Ctesting::internal::UniversalPrinter< T[N]> | |
| ►Ctesting::internal::UntypedActionResultHolderBase | |
| Ctesting::internal::ActionResultHolder< T > | |
| Ctesting::internal::ActionResultHolder< void > | |
| ►Ctesting::internal::UntypedFunctionMockerBase | |
| Ctesting::internal::FunctionMockerBase< R() > | |
| ►Ctesting::internal::FunctionMockerBase< R()> | |
| Ctesting::internal::FunctionMocker< R()> | |
| Ctesting::internal::FunctionMockerBase< R(A1) > | |
| ►Ctesting::internal::FunctionMockerBase< R(A1)> | |
| Ctesting::internal::FunctionMocker< R(A1)> | |
| Ctesting::internal::FunctionMockerBase< R(A1, A2) > | |
| ►Ctesting::internal::FunctionMockerBase< R(A1, A2)> | |
| Ctesting::internal::FunctionMocker< R(A1, A2)> | |
| Ctesting::internal::FunctionMockerBase< R(A1, A2, A3) > | |
| ►Ctesting::internal::FunctionMockerBase< R(A1, A2, A3)> | |
| Ctesting::internal::FunctionMocker< R(A1, A2, A3)> | |
| Ctesting::internal::FunctionMockerBase< R(A1, A2, A3, A4) > | |
| ►Ctesting::internal::FunctionMockerBase< R(A1, A2, A3, A4)> | |
| Ctesting::internal::FunctionMocker< R(A1, A2, A3, A4)> | |
| Ctesting::internal::FunctionMockerBase< R(A1, A2, A3, A4, A5) > | |
| ►Ctesting::internal::FunctionMockerBase< R(A1, A2, A3, A4, A5)> | |
| Ctesting::internal::FunctionMocker< R(A1, A2, A3, A4, A5)> | |
| Ctesting::internal::FunctionMockerBase< R(A1, A2, A3, A4, A5, A6) > | |
| ►Ctesting::internal::FunctionMockerBase< R(A1, A2, A3, A4, A5, A6)> | |
| Ctesting::internal::FunctionMocker< R(A1, A2, A3, A4, A5, A6)> | |
| Ctesting::internal::FunctionMockerBase< R(A1, A2, A3, A4, A5, A6, A7) > | |
| ►Ctesting::internal::FunctionMockerBase< R(A1, A2, A3, A4, A5, A6, A7)> | |
| Ctesting::internal::FunctionMocker< R(A1, A2, A3, A4, A5, A6, A7)> | |
| Ctesting::internal::FunctionMockerBase< R(A1, A2, A3, A4, A5, A6, A7, A8) > | |
| ►Ctesting::internal::FunctionMockerBase< R(A1, A2, A3, A4, A5, A6, A7, A8)> | |
| Ctesting::internal::FunctionMocker< R(A1, A2, A3, A4, A5, A6, A7, A8)> | |
| Ctesting::internal::FunctionMockerBase< R(A1, A2, A3, A4, A5, A6, A7, A8, A9) > | |
| ►Ctesting::internal::FunctionMockerBase< R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> | |
| Ctesting::internal::FunctionMocker< R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> | |
| Ctesting::internal::FunctionMockerBase< R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) > | |
| ►Ctesting::internal::FunctionMockerBase< R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> | |
| Ctesting::internal::FunctionMocker< R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> | |
| Ctesting::internal::FunctionMockerBase< F > | |
| ►Ctesting::internal::UntypedOnCallSpecBase | |
| Ctesting::internal::OnCallSpec< F > | |
| Ctesting::internal::WithArgsAction< InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10 > | |
| ►Ctesting::MatcherInterface< T > | |
| Ctesting::internal::AnyMatcherImpl< T > | |
| Ctesting::internal::BothOfMatcherImpl< T > | |
| Ctesting::internal::EitherOfMatcherImpl< T > | |
| Ctesting::internal::FloatingEqMatcher< FloatType >::Impl< T > | |
| Ctesting::internal::MatcherCastImpl< T, Matcher< U > >::Impl | |
| Ctesting::internal::NotMatcherImpl< T > | |
| Ctesting::internal::ResultOfMatcher< Callable >::Impl< T > | |
| Ctesting::PolymorphicMatcher< Impl >::MonomorphicImpl< T > | |
| ►Ctesting::MatchResultListener | |
| Ctesting::internal::DummyMatchResultListener | |
| Ctesting::internal::StreamMatchResultListener | |
| Ctesting::internal::StringMatchResultListener | |
| Ctesting::Message | |
| Ctesting::Mock | |
| Ctesting::MockFunction< F > | |
| Ctesting::MockFunction< R()> | |
| Ctesting::MockFunction< R(A0)> | |
| Ctesting::MockFunction< R(A0, A1)> | |
| Ctesting::MockFunction< R(A0, A1, A2)> | |
| Ctesting::MockFunction< R(A0, A1, A2, A3)> | |
| Ctesting::MockFunction< R(A0, A1, A2, A3, A4)> | |
| Ctesting::MockFunction< R(A0, A1, A2, A3, A4, A5)> | |
| Ctesting::MockFunction< R(A0, A1, A2, A3, A4, A5, A6)> | |
| Ctesting::MockFunction< R(A0, A1, A2, A3, A4, A5, A6, A7)> | |
| Ctesting::MockFunction< R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> | |
| Ctesting::MockFunction< R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> | |
| Ctesting::PolymorphicAction< Impl > | |
| Ctesting::PolymorphicMatcher< Impl > | |
| Ctesting::SafeMatcherCastImpl< T > | |
| Ctesting::Sequence | |
| Ctesting::Test | |
| Ctesting::Test::Setup_should_be_spelled_SetUp | |
| Ctesting::TestCase | |
| ►Ctesting::TestEventListener | |
| ►Ctesting::EmptyTestEventListener | |
| Ctesting::internal::XmlUnitTestResultPrinter | |
| Ctesting::internal::PrettyUnitTestResultPrinter | |
| Ctesting::internal::TestEventRepeater | |
| Ctesting::TestEventListeners | |
| Ctesting::TestInfo | |
| Ctesting::TestPartResult | |
| Ctesting::TestPartResultArray | |
| ►Ctesting::TestPartResultReporterInterface | |
| Ctesting::internal::DefaultGlobalTestPartResultReporter | |
| Ctesting::internal::DefaultPerThreadTestPartResultReporter | |
| Ctesting::internal::HasNewFatalFailureHelper | |
| Ctesting::ScopedFakeTestPartResultReporter | |
| Ctesting::TestProperty | |
| Ctesting::TestResult | |
| Ctesting::UnitTest | |
| ►CTexture | |
| CCEGUI::OgreCEGUITexture | Texture class that is created by OgreCEGUIRenderer objects |
| Ctesting::internal::ThreadLocal< std::vector< testing::internal::TraceInfo > > | |
| Ctesting::internal::ThreadLocal< testing::TestPartResultReporterInterface * > | |
| CTiXmlAttributeSet | |
| ►CTiXmlBase | TiXmlBase is a base class for every class in TinyXml |
| CTiXmlAttribute | An attribute is a name-value pair |
| ►CTiXmlNode | The parent class for everything in the Document Object Model |
| CTiXmlComment | An XML comment |
| CTiXmlDeclaration | In correct XML the declaration is the first entry in the file |
| CTiXmlDocument | Always the top level node |
| CTiXmlElement | The element is a container class |
| CTiXmlStylesheetReference | A stylesheet reference looks like this: |
| CTiXmlText | XML text |
| CTiXmlUnknown | Any tag that tinyXml doesn't recognize is saved as an unknown |
| CTiXmlBase::Entity | |
| CTiXmlCursor | |
| CTiXmlHandle | A TiXmlHandle is a class that wraps a node pointer with null checks; this is an incredibly useful thing |
| CTiXmlParsingData | |
| ►CTiXmlString | |
| CTiXmlOutStream | |
| CTiXmlString::Rep | |
| ►CTiXmlVisitor | If you call the Accept() method, it requires being passed a TiXmlVisitor class to handle callbacks |
| CTiXmlPrinter | Print to memory functionality |
| Ctesting::internal::TypeWithSize< sizeof(RawType)> | |
1.8.11
