| ►Nboost | |
| ►Nfilesystem | |
| Cbasic_path | |
| ►NCEGUI | |
| CCEGUIRQListener | RenderQueueListener based class used to hook into the ogre rendering system |
| ►COgreCEGUIRenderer | Renderer class to interface with Ogre engine |
| CQuadInfo | Structure holding details about a quad to be drawn |
| CQuadVertex | Structure used for all vertices |
| COgreCEGUIResourceProvider | |
| COgreCEGUITexture | Texture class that is created by OgreCEGUIRenderer objects |
| ►NLoki | |
| ►NPrivate | |
| CAddParameterType | |
| CAddParameterType< U & > | |
| CAddParameterType< void > | |
| CAddPointer | |
| CAddPointer< U & > | |
| CAddReference | |
| CAddReference< U & > | |
| CAddReference< void > | |
| CCompileTimeError | |
| CCompileTimeError< true > | |
| CInt2Type | |
| CIsCustomFloat | |
| CIsCustomSignedInt | |
| CIsCustomUnsignedInt | |
| CIsSameType | |
| CIsSameType< T, T > | |
| CNullType | |
| CObjScopeGuardImpl0 | Implementation class for a class per-instance member function with no parameters |
| CObjScopeGuardImpl1 | Implementation class for a class per-instance member function with one parameter |
| CObjScopeGuardImpl2 | Implementation class for a class per-instance member function with two parameters |
| CObjScopeGuardImpl3 | Implementation class for a class per-instance member function with three parameters |
| CRefToValue | Transports a reference as a value Serves to implement the Colvin/Gibbons trick for SmartPtr/ScopeGuard |
| CScopeGuardImpl0 | Implementation class for a standalone function or class static function with no parameters |
| CScopeGuardImpl1 | Implementation class for a standalone function or class static function with one parameter |
| CScopeGuardImpl2 | Implementation class for a standalone function or class static function with two parameters |
| CScopeGuardImpl3 | Implementation class for a standalone function or class static function with three parameters |
| CScopeGuardImpl4 | Implementation class for a standalone function or class static function with four parameters |
| CScopeGuardImpl5 | Implementation class for a standalone function or class static function with five parameters |
| CScopeGuardImplBase | Base class used by all ScopeGuard implementations |
| CSelect | |
| CSelect< false, T, U > | |
| CType2Type | |
| ►CTypeTraits | |
| CPointerTraits | |
| CPointerTraits< U * > | |
| CPointerTraits< U *& > | |
| CPToMTraits | |
| CPToMTraits< U V::* > | |
| CPToMTraits< U V::*& > | |
| CReferenceTraits | |
| CReferenceTraits< U & > | |
| CUnConst | |
| CUnConst< const U & > | |
| CUnConst< const U > | |
| CUnVolatile | |
| CUnVolatile< volatile U & > | |
| CUnVolatile< volatile U > | |
| ►NOgre | |
| CController | |
| CControllerFunction | |
| CControllerValue | |
| CDynamicLines | |
| CDynamicRenderable | Abstract base class providing mechanisms for dynamically growing hardware buffers |
| CSharedPtr | |
| ►NOIS | |
| CAxis | Axis component |
| CAxisInfo | |
| CButton | Button can be a keyboard key, mouse button, etc |
| CComponent | Base of all device components (button, axis, etc) |
| CConditionalEffect | Use this class when dealing with Force type of Condional |
| CConstantEffect | Use this class when dealing with Force type of Constant |
| Ccookie_struct | |
| CEffect | Force Feedback is a relatively complex set of properties to upload to a device |
| CEnvelope | An optional envelope to be applied to the start/end of an effect |
| CEventArg | Base class of all events |
| CEventUtils | |
| CException | |
| CFactoryCreator | Interface for creating devices - all devices ultimately get enumerated/created via a factory |
| CForceEffect | Base class of all effect property classes |
| CForceFeedback | Interface class for dealing with Force Feedback devices |
| CHidInfo | |
| CInputManager | Base Manager class |
| CInterface | An Object's interface is a way to gain write access to devices which support it |
| CJoyStick | Joystick base class |
| CJoyStickEvent | Specialised for joystick events |
| CJoyStickInfo | |
| CJoyStickListener | To recieve buffered joystick input, derive a class from this, and implement the methods here |
| CJoyStickState | 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 |
| CKeyboard | Keyboard base class |
| CKeyEvent | Specialised for key events |
| CKeyListener | To recieve buffered keyboard input, derive a class from this, and implement the methods here |
| CLinuxForceFeedback | |
| CLinuxInputManager | Linux X11 InputManager specialization - Using lowlevel joys |
| CLinuxJoyStick | Linux specialization of JoyStick class |
| CLinuxKeyboard | Linux implementation of Keyboard object - uses x11 |
| CLinuxMouse | |
| CMac_KeyStackEvent | |
| CMac_MouseStackEvent | |
| CMacHIDManager | |
| CMacInputManager | |
| CMacJoyStick | |
| CMacKeyboard | |
| CMacMouse | |
| CMouse | Mouse base class |
| CMouseEvent | Specialised for mouse events |
| CMouseListener | To recieve buffered mouse input, derive a class from this, and implement the methods here |
| CMouseState | Represents the state of the mouse All members are valid for both buffered and non buffered mode |
| CMultiTouch | MultiTouch base class |
| CMultiTouchEvent | Specialised for multi-touch events |
| CMultiTouchListener | To receive buffered touch input, derive a class from this, and implement the methods here |
| CMultiTouchState | |
| CObject | The base class of all input types |
| COIS_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 |
| CPeriodicEffect | Use this class when dealing with Force type of Periodic |
| CPov | POV / HAT Joystick component |
| CRampEffect | Use this class when dealing with Force type of Ramp |
| CRange | |
| CSlider | A sliding axis - only used in Win32 Right Now |
| CVector3 | A 3D Vector component (perhaps an orientation, as in the WiiMote) |
| CWin32ForceFeedback | |
| CWin32InputManager | Win32InputManager specialization - Using DirectInput8 |
| CWin32JoyStick | |
| CWin32Keyboard | |
| CWin32Mouse | |
| ►Norxonox | Die Wagnis Klasse hat die folgenden Aufgaben: |
| ►Nautocompletion | |
| ►NButtonEvent | |
| CEnumToType | Enables function overloading with integer values |
| ►Ncontext | |
| ►Npacket | |
| CAcknowledgement | |
| CChat | |
| CClassID | |
| CDeleteObjects | |
| CFunctionCalls | |
| CFunctionIDs | |
| CGamestate | |
| CGamestateHeader | |
| CPacket | |
| CServerInformation | |
| CWelcome | |
| CAbstractRadiusHeightCollisionShape | Wrapper for the bullet collision shapes with radius and height |
| CActionpoint | Actionpoints are used by ActionpointController and all derived classes |
| CActionpointController | |
| CAdditionalContextListener | AdditionalContextListener is an interface which is used to notify OutputManager about additional contexts in OutputListeners |
| CAddQuest | Adds a Quest, resp |
| CAddQuestHint | Adds a QuestHint, resp |
| CAddReward | Adds a list of Rewardables to a player |
| CAIController | |
| CAmbientSound | Used to play background music |
| CAnimatedModel | |
| CAnnounceMessage | |
| CAnswer | Class containing the pc side of the Dialog |
| CAnswerId | Container class for answerids in xml |
| CApplicationPaths | Singleton which provides static paths of the application |
| CArgumentCompleter | This class executes an argument completion function and returns a list of the possible arguments |
| CArgumentCompletionListElement | This class is used in argument completion lists and contains up to three different strings, used in different situations |
| CArrow | |
| CArrowController | |
| CArtificialController | |
| CAsteroidMinable | |
| CAsteroids | |
| CAsteroids2D | |
| CAsteroids2DCenterPoint | |
| CAsteroids2DHUDinfo | |
| CAsteroids2DShip | |
| CAsteroids2DStone | |
| CAsteroids2DWeapon | |
| CAttacher | |
| CAutonomousDrone | Drone, that is made to move upon a specified pattern |
| CAutonomousDroneController | Controller for the AutonomousDrone of the PPS tutorial |
| CBacklight | |
| CBarColour | |
| CBaseCommand | |
| CBaseInputBufferListenerTuple | |
| ►CBaseObject | The BaseObject is the parent of all classes representing an instance in the game |
| CStrongOrWeakPtr | |
| CBaseSound | Base class for all sound file loader classes |
| CBaseWriter | BaseWriter is an output listener and makes the accepted output levels and contexts configurable |
| CBasicProjectile | Baseclass of all projectiles |
| CBillboard | |
| CBillboardProjectile | A BillboardProjectile is a projectile that is represented by a Billboard |
| CBillboardSet | |
| CBlinkingBillboard | |
| CBoostPickup | |
| CBot | |
| CBoxCollisionShape | Wrapper for the bullet box collision shape class btBoxShape |
| CBufferedParamCommand | |
| ►CBulletDebugDrawer | Originally from http://www.ogre3d.org/tikiwiki/BulletDebugDrawer&structure=Cookbook This source code is released into the Public Domain |
| CContactPoint | |
| CButton | |
| CCamera | |
| CCameraManager | |
| CCameraPosition | |
| CCEGUILogger | |
| CChangeQuestStatus | A QuestEffect which changes the status of a specified Quest for the player invoking the QuestEffect |
| CChatHistory | |
| CChatInputHandler | |
| CChatListener | Classes inheriting from this interface get a notification whenever a chat message was sent through ChatManager |
| CChatManager | This class collects and distributes chat messages |
| CChatOverlay | |
| CCheckPoint | |
| CCircle | |
| CClassFactory | The ClassFactory is the base-class of all class-spezific factories |
| CClassFactoryNoArgs | The ClassFactoryNoArgs is able to create new objects of a specific class that require no constructor arguments |
| CClassFactoryWithContext | The ClassFactoryWithContext is able to create new objects of a specific class that require a context as constructor argument |
| CClassIdentifier | The ClassIdentifier is derived from Identifier and holds all class-specific functions and variables the Identifier cannot have |
| CClassScopedSingletonWrapper | Manages a scoped singleton |
| CClassScopedSingletonWrapper< T, true > | This class partially spezializes ClassScopedSingletonWrapper for classes T that are allowed to fail |
| CClassTreeMask | The ClassTreeMask is a set of rules, containing the information for each class whether it's included or not |
| CClassTreeMaskIterator | The ClassTreeMaskIterator moves through all ClassTreeMaskNodes of the internal tree of a ClassTreeMask which contains the rules |
| CClassTreeMaskNode | The ClassTreeMaskNode is a node in the internal tree of the ClassTreeMask, containing the rules of the mask |
| CClassTreeMaskObjectIterator | The ClassTreeMaskObjectIterator iterates through all objects of the classes that were included by a ClassTreeMask |
| CClient | 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 |
| CClientConnection | |
| CClientConnectionListener | An abstract base class |
| CClock | Simple real time clock based on Ogre::Timer |
| CCollectiblePickup | Encompasses all Pickupables that can be added to a PickupCollection and thus be part of such |
| CCollisionShape | Wrapper for bullet collision shape class btCollisionShape |
| CCommandEvaluation | CommandEvaluation is used to gather information about a command and to evaluate its arguments |
| ►CCommandExecutor | This class is used to execute and evaluate command-strings |
| CCacheEntry | Helper struct, used to store cached entries |
| CCommandLineArgument | Container class for a command line argument of any type supported by MultiType |
| CCommandLineParser | Global interface to command line options |
| CCommandNotification | This class implements a method of displaying a Notification with information to an input command and the key the command is mapped to |
| CCommonController | |
| CCompleteQuest | Completes a Quest (with a specified id) for the player invoking the QuestEffect |
| CCompoundCollisionShape | Wrapper for the bullet compound collision shape class btCompoundShape |
| CConeCollisionShape | Wrapper for the bullet cone collision shape class btConeShape |
| CConfigFile | This class represents a config file, which is stored on the hard-disk and contains config values in different sections |
| CConfigFileEntry | This class represents an entry in the config file |
| CConfigFileEntryComment | This class represents a line in the config file which contains only a comment |
| CConfigFileEntryValue | This class represents a normal value in the config file |
| CConfigFileEntryVectorValue | Subclass of ConfigFileEntryValue, represents an element of a vector |
| CConfigFileManager | Manages the different config files (settings, calibration, etc) |
| CConfigFileSection | Represents a section in a config file |
| CConfigurable | This is the base class of all objects which may contain config values |
| CConfigurablePaths | Singleton used to configure different paths |
| CConfigValueCallback | |
| CConfigValueCallbackBase | |
| CConfigValueContainer | The ConfigValuecontainer contains all needed information about a configurable variable |
| CConnection | |
| ►CConsoleCommand | Stores all information about a console command which can be executed by CommandExecutor |
| CCommand | Helper class that is used to put the current state of the ConsoleCommand on a stack |
| CCommandName | Defines the name of a command, consisting of an optional group ("" means no group) and the name itself |
| CConsoleCommandManipulator | Helper class that is used to manipulate console commands |
| CConsoleCommandManager | A singleton that stores all existing ConsoleCommands |
| CConsoleWriter | ConsoleWriter inherits from BaseWriter and writes output to the console |
| CContext | |
| CControllableEntity | The ControllableEntity is derived from the orxonox::MobileEntity |
| CController | |
| CControllerDirector | |
| CConverterExplicit | Default template if no orxonox::ConverterExplicit is available |
| CConverterExplicit< bool, std::string > | Conversion from bool to std::string |
| CConverterExplicit< btQuaternion, orxonox::Quaternion > | |
| CConverterExplicit< btVector3, orxonox::Vector3 > | |
| CConverterExplicit< char, std::string > | Conversion would exhibit ambiguous << or >> operators when using iostream |
| CConverterExplicit< const char *, ToType > | Delegates conversion from const char* to std::string |
| CConverterExplicit< orxonox::ColourValue, std::string > | Ogre::ColourValue to std::string conversion |
| CConverterExplicit< orxonox::Quaternion, btQuaternion > | |
| CConverterExplicit< orxonox::Quaternion, std::string > | Ogre::Quaternion to std::string conversion |
| CConverterExplicit< orxonox::Vector2, std::string > | Ogre::Vector2 to std::string conversion |
| CConverterExplicit< orxonox::Vector3, btVector3 > | |
| CConverterExplicit< orxonox::Vector3, std::string > | Ogre::Vector3 to std::string conversion |
| CConverterExplicit< orxonox::Vector4, std::string > | Ogre::Vector4 to std::string conversion |
| CConverterExplicit< std::string, bool > | Conversion from std::string to bool |
| CConverterExplicit< std::string, char > | Conversion would exhibit ambiguous << or >> operators when using iostream |
| CConverterExplicit< std::string, Ogre::DisplayString > | |
| CConverterExplicit< std::string, unsigned char > | Conversion would exhibit ambiguous << or >> operators when using iostream |
| CConverterExplicit< unsigned char, std::string > | Conversion would exhibit ambiguous << or >> operators when using iostream |
| CConverterFallback | Default template. No conversion available at all |
| CConverterFallback< FromType *, ToType * > | If all else fails, try a dynamic_cast for pointer types |
| CConverterFallback< FromType, orxonox::Degree > | Delegates conversions to Degree to conversions to float |
| CConverterFallback< FromType, orxonox::Radian > | Delegates conversions to Radian to conversions to float |
| CConverterFallback< orxonox::Degree, ToType > | Delegates conversions from Degree to conversions from float |
| CConverterFallback< orxonox::Radian, ToType > | Delegates conversions from Radian to conversions from float |
| CConverterFallback< std::string, orxonox::ColourValue > | Std::string to Ogre::ColourValue conversion |
| CConverterFallback< std::string, orxonox::Quaternion > | Std::string to Ogre::Quaternion conversion |
| CConverterFallback< std::string, orxonox::Vector2 > | Std::string to Ogre::Vector2 conversion |
| CConverterFallback< std::string, orxonox::Vector3 > | Std::string to Ogre::Vector3 conversion |
| CConverterFallback< std::string, orxonox::Vector4 > | Std::string to Ogre::Vector4 conversion |
| CCore | Singleton used to configure the program basics |
| CCoreConfig | |
| CCoreStaticInitializationHandler | |
| CCountDown | |
| CCreateLines | |
| CCreateStars | |
| CCylinderCollisionShape | Wrapper for the bullet Cylinder collision shape class btCylinderShape |
| CDamageBoostPickup | |
| CDeathmatch | |
| CDeathMessage | |
| CDebugDrawer | DebugDrawer is a utility to draw debug shapes (lines, triangles, spheres) with Ogre |
| CDebugFPSText | |
| CDebugPositionText | |
| CDebugRTRText | |
| CDefaultWeaponmodeLink | |
| CDestroyable | Classes must inherit from this class if they should be used with StrongPtr or WeakPtr |
| CDestroyer | |
| CDestroyLaterManager | |
| CDestructionHelper | Utility class that helps to create a special kind of destructor that also executes if the destruction fails |
| CDestructionListener | This listener is used to inform weak pointers if an object of type Destroyable gets destroyed |
| CDevModeListener | Informs about changes in the Development Mode |
| CDialog | Class containing core of one dialog with one npc |
| CDialogManager | This class is used for calling on a dialog form luascript |
| CDistanceMultiTrigger | 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 |
| CDistanceTrigger | 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 |
| CDistanceTriggerBeacon | A DistanceTriggerBeacon can be used together with a DistanceTrigger or a DistanceMultiTrigger to make them only react to specific objects |
| CDivisionController | |
| CDock | |
| CDockingAnimation | Base class for docking animations used by Docks |
| CDockingController | |
| CDockingEffect | Handles DockingEffects for Docks |
| CDockingTarget | DockingTargets for Docks |
| CDockToShip | Allows players to dock onto a ship |
| CDodgeRace | |
| CDodgeRaceCenterPoint | |
| CDodgeRaceCube | |
| CDodgeRaceHUDinfo | |
| ►CDodgeRaceShip | |
| CVelocity | |
| Cdontcare_keyword_t | INTERNAL ONLY The type of the 'dontcare' keyword |
| CDrone | Drone, that is made to move upon a specified pattern |
| CDroneController | Controller for the Drone of the PPS tutorial |
| CDronePickup | The DronePickup adds a Drone to the Pawn upon being picked up |
| CDynamicmatch | Short Gaming Manual: There are three different parties a player can belong to: victim, chaser or killer Every player starts as chaser |
| CDynLib | Resource holding data about a dynamic library |
| CDynLibManager | Manager for Dynamic-loading Libraries |
| CEffectContainer | |
| CEmptyType | |
| CEnergyDrink | Shoots a can |
| CEngine | Propulsion to the SpaceShip |
| Cevent | Structure to describe a single event |
| CEvent | The Event struct contains information about a fired Event |
| CEventDispatcher | |
| CEventFilter | |
| CEventListener | |
| CEventMultiTrigger | Equivalent of the EventTrigger class for MultiTriggers |
| CEventName | |
| CEventState | The EventState contains information about an event state |
| CEventTarget | |
| CEventTrigger | Way to have a Trigger triggered by any kinds of Events |
| CException | Base class for all exceptions (derived from std::exception) |
| CExecutor | This class is used to wrap a Functor and to store default values for any of its parameters |
| CExecutorMember | A child class of Executor, used for easier handling of non-static member-functions |
| CExecutorStatic | A child class of Executor, used to distinguish executors that wrap static functions from executors that wrap member-functions |
| CExplosionChunk | |
| CExplosionPart | |
| CExprParser | Parser for expressions like "3 * cos(5 + 4) / a" where a is a predeclared variable |
| CFactory | Base-class of all factories |
| CFadeoutText | |
| CFadingBillboard | |
| CFailQuest | Fails a Quest (with a specified id) for the player invoking the QuestEffect |
| CFightingController | FightingController stores all the fighting methods and member variables of AI |
| CFlagHUD | |
| CFlameGun | A WeaponMode that fires burning projectiles |
| CFlameGunProjectile | |
| CFlameMunition | FlameMunition |
| CFlappyOrx | |
| CFlappyOrxHUDinfo | |
| CFlappyOrxShip | |
| CFlyingController | |
| CForceField | Implements a force field, that applies a force to any MobileEntity that enters its range |
| CFormationController | |
| CFpsPlayer | |
| CFunctionCall | |
| CFunctionCallManager | |
| CFunctor | The Functor classes are used to wrap function pointers |
| CFunctorMember | 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 |
| CFunctorMember< void > | Specialization of FunctorMember with T = void |
| CFunctorPointer | FunctorPointer is a child class of FunctorMember and extends it with a function-pointer (or a function-object) |
| CFunctorTemplate | 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 |
| CFusionFire | FusionFire |
| CFusionMunition | FusionMunition |
| ►CGame | Main class responsible for running the game |
| CGameStateFactory | |
| CStatisticsTickInfo | |
| CTemplateGameStateFactory | |
| CGameConfig | |
| CGameMode | Helper class, stores and returns the current mode of the game |
| ►CGameState | An implementation of a tree to manage game states |
| CState | Gives information about what the GameState is currently doing |
| CGamestateHandler | An interface for any class that wants to handle gamestates |
| CGameStateInfo | Helper object required before GameStates are being constructed |
| ►CGamestateManager | This Class implements a manager for gamestates: |
| CpeerInfo | |
| CGameStateTreeNode | Represents one node of the game state tree |
| CGametype | |
| CGametypeFadingMessage | |
| CGametypeInfo | Keeps track of the state of the game and provides facilities to inform the player about it |
| CGametypeMementoState | Keeps position and orientation of the camera, as well as the name of current scene |
| CGametypeMessageListener | |
| CGametypeStaticMessage | |
| CGlobalQuest | GlobalQuests are Quests, that have the same status for all players |
| CGlobalShader | |
| CGlowMaterialListener | |
| CGraphicsManager | Graphics engine manager class |
| CGravityBomb | This class implements how long the bomb flies before it places the GravityField at it's last possition |
| CGravityBombField | This class is used by GravityBomb to place the ForceField and Visual effect to the environment |
| CGravityBombFire | Fires the GravityBomb |
| CGravityBombMunition | This class is used to set the behaviour of various munition specific attributes of the GravityBomb like max count of munition per magazine |
| CGSClient | |
| CGSGraphics | Game state used when displaying graphics of any kind |
| CGSLevel | |
| CGSLevelMemento | This class is an interface for all instances that want to maintain a state beyond the reloading of a level |
| CGSLevelMementoState | Represents the state of a memento |
| CGSMainMenu | |
| CGSMasterServer | |
| CGSRoot | |
| CGSServer | |
| CGSStandalone | |
| CGUIManager | Provides a simple interface to CEGUI with tolua methods and console commands. |
| CGUIOverlay | |
| CGUISheet | Simple XML loadable interface to the otherwise Lua coded GUI framework |
| CHalfAxis | |
| CHealthPickup | The HealthPickup is a Pickupable that can do (dependent upon the parameters) lots of different things to the health of a Pawn |
| CHighscore | |
| CHost | Base class of Server and Client This is the Base class of the Server and Client classes |
| CHover | |
| CHoverFlag | |
| CHoverOrigin | The HoverOrigin implements the playing field Hover takes place in and allows for many parameters of the minigame to be set |
| CHoverShip | |
| CHoverWall | |
| CHsW01 | Shoots laser beams |
| CHUDBar | |
| CHUDBoostBar | |
| CHUDEnemyHealthBar | |
| CHUDEnemyShieldBar | This class displays the shield status of the target enemy of it's owner |
| CHUDHealthBar | |
| ►CHUDNavigation | |
| CObjectInfo | |
| CHUDPickupSystem | |
| CHUDRadar | |
| CHUDRocketFuelBar | |
| CHUDShieldBar | The HUDShieldBar displays the the status of the shield of its owner (a Pawn) |
| CHUDSpeedBar | |
| CHUDTimer | |
| CHUDWeapon | |
| CHUDWeaponMode | |
| CHUDWeaponSystem | |
| CHumanController | |
| CHumanPlayer | |
| CIceGun | A Gun that fires ice arrows that slow down any SpaceShip object that gets hit |
| CIceGunFreezer | This is the WorldEntity that gets attached to a victim hit by a IceGunProjectile |
| CIceGunProjectile | The IceGunProjectile is a projectile that attaches a IceGunFreezer to the hit object |
| CIceMunition | IceMunition |
| ►CIcoSphere | Copy-pasted from |
| CLineIndices | |
| CTriangleIndices | |
| CIdentifiable | Identifiable is needed to create the class-hierarchy at startup and to store the Identifier |
| ►CIdentifier | The Identifier is used to identify the class of an object and to store information about the class |
| CInheritsFrom | Helper class to manually define inheritance |
| CIdentifierManager | |
| CincomingEvent | |
| CInfo | |
| CInGameConsole | |
| CInputBuffer | |
| CInputBufferListenerTuple | |
| CInputDevice | Abstract base class for all input devices (mouse, keyboard and joy sticks) |
| CInputDeviceTemplated | Heavily templated base class for all three input devices |
| CInputHandler | Base class for all input handlers like KeyBinder, InputBuffer, etc |
| CInputManager | Manages the input devices (mouse, keyboard, joy sticks) and the input states |
| CInputState | InputStates allow you to customise the input event targets at runtime |
| CInputStatePriority | Enumeration wrapper for input state priorities |
| CIntVector2 | A Vector class containing two integers x and y |
| CInvader | |
| CInvaderCenterPoint | |
| ►CInvaderEnemy | |
| CVelocity | |
| CInvaderEnemyShooter | |
| CInvaderHUDinfo | |
| ►CInvaderShip | |
| CVelocity | |
| CInvaderWeapon | |
| CInvaderWeaponEnemy | |
| CInvisiblePickup | A pickup that makes the Pawn invisible |
| CIOConsole | |
| CIRC | Creates a Tcl-thread (see TclThreadManager) and connects to an IRC server |
| CItem | |
| CIterator | The Iterator allows to iterate through a given ObjectList |
| CIteratorBase | The Iterator allows to iterate through object lists |
| CJoyStick | Wraps around an OIS::JoyStick and forwards the input events to a list of input states |
| CJoyStickQuantityListener | Derive from this class to get informed when joy sticks get added/removed |
| CJoyStickTraits | Template parameter collection for the base class |
| CJump | |
| CJumpBoots | |
| CJumpCenterpoint | The JumpCenterpoint is a StaticEntity which represents the level of the minigame |
| CJumpEnemy | |
| CJumpFigure | |
| CJumpItem | |
| CJumpPlatform | |
| CJumpPlatformDisappear | |
| CJumpPlatformFake | |
| CJumpPlatformHMove | |
| CJumpPlatformStatic | |
| CJumpPlatformTimer | |
| CJumpPlatformVMove | |
| CJumpProjectile | |
| CJumpPropeller | |
| CJumpRocket | |
| CJumpScore | |
| CJumpShield | |
| CJumpSpring | |
| ►CKeyBinder | Maps mouse, keyboard and joy stick input to command strings and executes them |
| CJoyStickAxisVector | Helper class to use something like std:vector<HalfAxis[48]> |
| CJoyStickButtonVector | Helper class to use something like std:vector<Button[64]> |
| CKeyBinderManager | Handles the KeyBinders and supplies them throughout the game |
| CKeyboard | Wraps around an OIS::Mouse and forwards the input events to a list of input states |
| CKeyboardTraits | Template parameter collection for the base class |
| CKeyDetector | |
| CKeyEvent | Event argument for key events |
| CKillMessage | |
| CLANDiscoverable | |
| CLANDiscovery | |
| CLanguage | Manges the language files and entries and stores the LanguageEntry objects in a map |
| CLanguageEntry | Stores the default- and the translated string of a given entry in the language file |
| CLaserFire | Shoots a particle laser |
| CLaserMunition | LaserMunition |
| CLastManStanding | |
| CLastManStandingInfos | |
| CLastTeamStanding | |
| CLastTeamStandingInfos | |
| ►CLensFlare | This class adds a configurable LensFlare effect by adding multiple billboards for the several components of lens flare |
| CLens | This is a nested Class used to easily set properties of the different sublenses of a LensFlare effect |
| CLevel | |
| CLevelInfo | Can be used to store information regarding a Level in its level file |
| CLevelInfoCompare | Struct that overloads the compare operation between two LevelInfoItem pointers |
| CLevelInfoItem | Stores information regarding a Level and makes that information accessible through the LevelManager |
| CLevelManager | 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) |
| CLight | |
| CLightningGun | A slow ball of lightning |
| CLightningGunProjectile | The LightningGunProjectile is a projectile that is represented by a looped series of billboards |
| CLightningMunition | LightningMunition |
| CListable | Listable stores the entries of all object lists pointing to this instance |
| CLoader | |
| CLocalQuest | Handles Quests which have different states for different players |
| CLogWriter | Inherits from BaseWriter and writes output to a log-file |
| CLuaFunctor | Callback class that executes lua code |
| CLuaScriptModuleWorkaround | Class with the same memory layout as CEGUI::LuaScriptModule |
| CLuaState | Representation of an interface to lua |
| CMasterController | Calles action(), maneuver() and canFire() methods of all the ActionpointControllers in level |
| CMasterServer | |
| CMasterServerComm | |
| CMazeGenerator | |
| Cmbool | Mbool is a small helper class that acts like a bool, but keeps track of the number of its state changes |
| ►CMemoryWriter | MemoryWriter is a singleton which is derived from OutputListener and writes all output to a list |
| CMessage | A helper struct which is used to store output and its properties |
| CMesh | |
| CMeshLodInformation | |
| CMetaPickup | The MetaPickup is a Pickupable that can, depending on the parameter metaTye, do different things |
| CMineGun | A Weapon that drops mines to space |
| CMineMunition | MineMunition |
| CMineProjectile | TODO |
| CMini4Dgame | |
| CMini4DgameAI | The Mini4DgameAI is an artificial intelligence for the Mini4Dgame gametype |
| CMini4DgameBoard | This class manages the board for Mini4Dgame |
| CMini4DgamePosition | |
| CMini4DgameWinner | |
| CMission | |
| CMobileEntity | The MobileEntity is a derived class from orxonox::WorldEntity and orxonox::Tickable |
| CModel | |
| CModularSpaceShip | The SpaceShip is the principal entity through which the player interacts with the game |
| CModuleInstance | |
| CMoodListener | |
| CMoodManager | |
| CMouse | Wraps around an OIS::Mouse and forwards the input events to a list of input states |
| CMouseTraits | Template parameter collection for the base class |
| CMovableEntity | |
| CMoveToDockingTarget | Base class for docking animations used by Docks |
| CMT_Value | The MT_Value<T> class is used to hold a value of type T within a MultiType |
| ►CMultiStateEngine | |
| CEngineState | |
| CMultiTrigger | Implements a trigger that has a distinct state for each object triggering it |
| CMultiTriggerContainer | This class is used by the MultiTrigger class to transport additional data via Events |
| CMultiTriggerState | Struct to handle MultiTrigger states internally |
| ►CMultiType | The MultiType can hold a value of many possible types and convert them to other types |
| CMT_ValueBase | MT_ValueBase is an almost pure virtual baseclass of MT_Value<T>, which holds the value of the MultiType |
| ►CMunition | |
| CMagazine | |
| CMunitionContainer | |
| CMunitionPickup | The MunitionPickup gives munition to the user (a Pawn) |
| CMuzzleFlash | A muzzle flash that destroys itself after some time |
| CNameableStaticEntity | |
| CNamespace | |
| CNamespaceNode | |
| CNetworkCallback | |
| CNetworkCallbackBase | |
| CNetworkCallbackManager | |
| CNetworkCallbackNotify | |
| CNetworkChatListener | The only function of this interface, incomingChat(), gets called whenever a chat message was received through the network |
| CNetworkFunctionBase | |
| CNetworkFunctionManager | |
| CNetworkFunctionPointer | |
| CNetworkFunctionStatic | |
| CNetworkMemberFunction | |
| CNetworkMemberFunctionBase | |
| CNetworkStaticInitializationHandler | |
| CNewHumanController | |
| CNilValue | Provides zero value symbols that can be returned as reference |
| CNotification | A Notification represents a short message used to inform the player about something that just happened |
| CNotificationContainer | Container to allow easy handling of the Notifications |
| CNotificationContainerCompare | Struct to allow ordering of NotificationContainers |
| CNotificationDispatcher | A NotificationDispatcher is an entity that, upon being triggered, dispatches (or sends) a specified Notification |
| CNotificationListener | NotificationListener interface |
| CNotificationManager | The Singleton NotificationManager is a NotificationListener and functions as a gateway between Notifications and NotificationQueues |
| CNotificationQueue | Displays Notifications from specific senders |
| CNotificationQueueCEGUI | Displays Notifications using CEGUI |
| Cobj | List of objects of this type will be given by the Server's Gamestate Manager |
| CObjectList | The ObjectList contains all objects of the given class |
| CObjectListBase | The ObjectListBase contains all objects of a given class |
| CObjectListBaseElement | The list-element of the ObjectListBase |
| CObjectListElement | The list-element that actually contains the object |
| CObjectListElementRemovalListener | Gets called by the object list if an element is removed |
| CObjectListIterator | ObjectListIterator<T> allows to iterate through the ObjectList of class T |
| CobjInfo | List of objects of this type will be given by the Server's Gamestate Manager |
| COgreWindowEventListener | |
| COrxEnum | Lightweight enumeration class that can be extended at run time |
| COrxoKart | |
| COrxoKartFlag | |
| COrxoKartKart | |
| COrxoKartOrigin | The OrxoKartOrigin implements the playing field OrxoKart takes place in and allows for many parameters of the minigame to be set |
| COrxoKartTile | |
| COrxonoxClass | This is the class from which all objects of the game-logic (not the engine) are derived from |
| COrxonoxInterface | This is the class from which all interfaces of the game-logic (not the engine) are derived from |
| COrxonoxOverlay | Base class to display content directly onto the screen |
| COrxyRoad | |
| COrxyRoadCenterPoint | |
| COrxyRoadCube | |
| COrxyRoadHUDinfo | |
| ►COrxyRoadShip | |
| CVelocity | |
| CoutgoingEvent | |
| COutputContextContainer | Stores all information about a context |
| COutputListener | OutputListener is an interface which is used to receive output of a certain level and context from OutputManager |
| ►COutputManager | OutputManager acts as the center of the output system and is implemented as a singleton |
| CTesting | |
| COutputStream | This class is used to buffer output and send it to OutputManager whenever std::endl is passed to it |
| COverlayGroup | OverlayGroup does almost exactly what it says: It groups OrxonoxOverlays together |
| COverlayText | |
| CPacman | |
| CPacmanGelb | |
| CPacmanGhost | |
| CPacmanHUDinfo | |
| CPacmanPointAfraid | |
| CPacmanPointSphere | |
| CParamCommand | |
| CPartDestructionEvent | 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. |
| CParticleEmitter | |
| CParticleInterface | |
| CParticleProjectile | A projectile that is represented by particles |
| CParticleSpawner | |
| CPauseNotice | |
| CPawn | Everything in Orxonox that has a health attribute is a Pawn |
| CPeerList | This class keeps a list of open connections and some info about them |
| CPickup | Offers (useful) base functionality for a wide range of pickups |
| CPickupable | An Interface (or more precisely an abstract class) to model and represent different (all kinds of) pickups |
| CPickupCarrier | The PickupCarrier interface provides the means, for any class implementing it, to possess Pickupables |
| CPickupCollection | 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 |
| CPickupInventoryContainer | Data structure to store collected data for one specific Pickupable |
| CPickupListener | Facilitates the flow of information regarding the picking up, dropping, using and unusing of Pickupables to interested parties (such as the PickupManager) |
| CPickupManager | Manages Pickupables |
| CPickupRepresentation | Specific pickup type |
| CPickupSpawner | The PickupSpawner class is responsible for spawning @ref orxonox::Pickupable "Pickupables" of a specific type. |
| CPlaneCollisionShape | Wrapper for the bullet plane collision shape class btStaticPlaneShape |
| CPlanet | |
| CPlayer | |
| CPlayerInfo | |
| CPlayerManager | |
| CPlayerTrigger | PlayerTrigger is an interface if implemented by a specific trigger can be used to recover the Player (or the Pawn) that triggered it |
| CPlugin | |
| CPluginManager | |
| CPluginReference | |
| CPoint | |
| CPong | Implements a Pong minigame (Wikipedia::Pong) |
| CPongAI | The PongAI is an artificial intelligence for the Pong gametype |
| CPongBall | This class manages the ball for Pong |
| CPongBat | Manages the bats for Pong, which are the elements controlled by the players |
| CPongBot | A bot especially for Pong |
| CPongCenterpoint | The PongCenterpoint implements the playing field Pong takes place in and allows for many parameters of the minigame to be set |
| CPongScore | Displays the score for a game of Pong |
| CPortalEndPoint | A PortalEndPoint serves as portal entrance and/or exit |
| CPortalLink | A PortalLink represents the connection between two @ref orxonox::PortalEndPoint "PortalEndPoints"
|
| CProjectile | Represents all 'standard' projectiles |
| CQuest | Represents a Quest in the game |
| CQuestDescription | This class is a description of a QuestItem (Quest and QuestHint) |
| CQuestEffect | Handles QuestEffects for Quests |
| CQuestEffectBeacon | 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) |
| CQuestHint | Represents a hint in the game that gives aid towards completing a Quest |
| CQuestion | Class containing the npc side of the Dialog |
| CQuestItem | Functions as a base class for quest classes such as Quest or QuestHint |
| CQuestListener | Provides a way to react to the starting, completing and failing of Quests |
| CQuestManager | Is a Singleton and manages Quests, by registering every Quest / QuestHint (through registerX()) and making them globally accessible (through findX()) |
| CRaceCheckPoint | Enables the creation of a check point to use in a SpaceRace level |
| CRadar | |
| CRadarListener | |
| CRadarViewable | Interface for receiving window events |
| CRealTimer | RealTimer is a helper class that executes a function after a given amount of seconds in real-time |
| CRenderQueueListener | This class derives from the Ogre-Class RenderQueueListener and provides a way to define new rendering stages to enable use of e.g |
| CReplenishingMunition | Munition that is replenished by a certain amount each time interval |
| CResource | Provides simple functions to easily access the Ogre::ResourceGroupManager |
| CResourceCollection | |
| CResourceInfo | Stores basic information about a Resource from Ogre |
| CResourceLocation | |
| CRewardable | Rewardable is an Interface, that can be implemented by any object to enable it to be given as reward to a player through QuestEffects |
| CRocket | Rocket that can be steered by the player |
| CRocketController | Controller for the SimpleRocket (target seeking) |
| CRocketFire | Fires the (steerable) Rocket |
| CRocketFireOld | Fires the (steerable) RocketOld |
| CRocketMunition | Munition for the Rocket |
| CRocketOld | RocketOld that can be steered by the player |
| CScene | |
| CScope | A scope for a given template argument is either active or not |
| CScopedSingletonWrapper | Base class of ClassScopedSingletonWrapper |
| CScopeListener | ScopeListeners register themselves in the corresponding Scope and wait for notifications |
| CScopeManager | The ScopeManager stores the variables of the Scope templates in a statically linked context |
| CScoreboard | |
| CScreenshotManager | Class encapsulates screenshot functionality and provides a method for making multi grid (i.e |
| CScript | Lets you execute a piece of code, either the normal way or in lua, through XML |
| CScriptableController | Runs a scripts on a per-level basis and handles the connection to orxonox |
| ►CScriptableControllerAPI | API for ScriptableController's lua-scripts |
| CAreaHandler | Groups everything together that is needed to handle an area enter/leave event |
| CNearObjectHandler | Groups everything together that is needed to handle a near-object event |
| CNearPointHandler | Groups everything together that is needed to handle a near-poinb event |
| CScriptableControllerDrone | Drone, that is made to move upon a specified pattern |
| CScriptController | |
| CSectionController | |
| CServer | This class is the root class of the network module for a server |
| CServerConnection | |
| CServerList | This class is keeps a list of game servers and some info about them |
| CServerListElem | |
| CServerListSearchResult | |
| CSettingsConfigFile | Child class of ConfigFile, used to store the settings of the game |
| ►CShader | Shader is a wrapper class around Ogre::CompositorInstance |
| CParameterContainer | Helper struct to store parameters for shader programs |
| CShell | The Shell is the logical component of the console that displays output to the user and allows him to enter commands |
| CShellListener | An interface, used to get a notification if the state of the Shell changes |
| CShieldPickup | A Pickup which can add a Shield to the Pawn |
| CShipPart | |
| CShootableObstacle | This class encapsulates a pawn (so an object with health) with the addition, that it damages other objects when it hits them |
| CShrinkPickup | 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: |
| CShroomHUD | |
| CSignalCallbackRec | |
| CSignalHandler | The SignalHandler is used to catch signals like SIGSEGV and write a backtrace to the logfile |
| CSignalRec | |
| CSimpleCommand | |
| CSimpleNotification | Enables the sending of (in XML) predefined Notifications upon some kind of triggering event |
| CSimpleRocket | SimpleRocket is a target seeking, intelligent rocket |
| CSimpleRocketFire | FireMode for target-seeking Rocket |
| CSingleton | Base for singleton classes |
| CSkyboxGenerator | Singleton that allows for the creation of a skybox from a level by taking pictures to all 6 sides |
| ►CSmallObjectAllocator | This class is used to allocate and free small objects (usually not polymorphic) |
| CChunk | The memory chunk is at the same time an element of a single linked list |
| CSOB | |
| CSOBCastlestone | |
| CSOBCenterpoint | The SOBCenterpoint is a StaticEntity which represents the level of the minigame |
| CSOBCoin | |
| CSOBFigure | |
| CSOBFireball | |
| CSOBFlagstone | |
| CSOBGumba | |
| CSOBGumbaBoss | |
| CSOBHUDInfo | |
| CSOBItem | |
| CSOBMushroom | |
| CSOBQBlock | |
| CSOBTube | |
| CSoundBuffer | |
| CSoundManager | Manages the OpenAL device, context and listener position |
| CSoundStreamer | |
| ►CSpaceBoundaries | SpaceBoundaries gives level creators the possibility to bar Pawns from leaving a defined area (until now this area is a ball) |
| CBillboardAdministration | |
| CSpaceRace | Enables the creation of a space race level, where the player has to reach check points in a given order |
| CSpaceRaceBot | |
| CSpaceRaceController | Conventions: -first Checkpoint has index 0 -staticCheckPoint= static Point (see def over = constructor) |
| CSpaceRaceManager | Controls a space race level, where the player has to reach check points in a given order |
| CSpaceShip | The SpaceShip is the principal entity through which the player interacts with the game |
| CSpawnPoint | |
| CSpectator | |
| CSpeedPickup | A Pickup which can manipulate the Speed of a Pawn |
| CSphereCollisionShape | Wrapper for the bullet sphere collision shape class btSphereShape |
| CSpicedAsteroidBelt | |
| CSpicedAsteroidField | |
| CSplitGun | A WeaponMode that fires projectiles that may split up into many other projectiles, that may again split up .. |
| CSplitGunProjectile | The SplitGunProjectile is a projectile that may split up into many child projectiles |
| CSplitMunition | SplitMunition |
| CStaticallyInitializedCommandLineArgument | |
| CStaticallyInitializedConsoleCommand | |
| ►CStaticallyInitializedIdentifier | The static initializer stores the parent classes of this identifier |
| CInheritsFromClass | |
| CStaticallyInitializedInstance | |
| CStaticallyInitializedNetworkFunction | |
| CStaticallyInitializedScopedSingletonWrapper | |
| CStaticallyInitializedStaticInitializationHandler | |
| CStaticEntity | The StaticEntity is the simplest derivative of the orxonox::WorldEntity class |
| CStaticInitializationHandler | |
| CStaticInitializationManager | |
| CStats | |
| CStoryMode | |
| CStoryModeHUD | |
| CStoryModePawn | |
| CStrongPtr | A strong pointer which wraps a pointer to an object and keeps this object alive as long as the strong pointer exists |
| CSubclassIdentifier | The SubclassIdentifier acts almost like an Identifier, but has some prerequisites |
| CSubcontextOutputListener | This class extends the basic OutputListener interface and adds the ability to filter sub-contexts |
| CSubString | A class that splits a string into multiple tokens using different options |
| CSuperFunctionCondition | Creates the SuperFunctionCaller if T is a child of the super-functions baseclass |
| CSuperFunctionDestruction | Deletes the SuperFunctionCaller |
| CSuperFunctionInitialization | Initializes the SuperFunctionCaller-pointer with zero |
| CSynchronisable | 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 |
| CSynchronisableHeader | : stores information about a Synchronisable |
| CSynchronisableHeaderLight | : stores information about a Synchronisable (light version) |
| CSynchronisableVariable | |
| CSynchronisableVariableBase | |
| CSynchronisableVariableBidirectional | |
| CTclBind | A wrapper class for a Tcl interpreter |
| CTclInterpreterBundle | A struct containing all information about a Tcl-interpreter |
| CTclThreadList | A thread-safe implementation of a message queue, used by TclThreadManager |
| CTclThreadManager | |
| CTDCoordinate | |
| CTeamBaseMatch | |
| CTeamBaseMatchBase | |
| CTeamBaseMatchScore | |
| CTeamColourable | |
| CTeamDeathmatch | |
| CTeamGametype | |
| CTeamSpawnPoint | |
| CTeamTargetProxy | A controller, that just copies the team and the target of a parent for itself and it's controllable entity |
| CTemplate | |
| CTest | |
| CTetris | |
| CTetrisBrick | ContainerClass in order to create TetrisBricks by combining TetrisStones |
| CTetrisCenterpoint | |
| CTetrisScore | Displays the score for a game of Tetris |
| CTetrisStone | |
| CTextureGenerator | |
| CThread | |
| CThreadPool | |
| CTickable | The Tickable interface provides a tick(dt) function, that gets called every frame |
| CTimeFactorListener | |
| CTimeHUD | |
| CTimer | Timer is a helper class that executes a function after a given amount of seconds in game-time |
| CToluaBindingsHelper | Helper class that registers/unregisters tolua bindings |
| CTowerDefense | GameType class for TowerDefense |
| CTowerDefenseCenterpoint | See TowerDefenseReadme.txt for Information |
| CTowerDefenseEnemy | See TowerDefenseReadme.txt for Information |
| CTowerDefenseField | See TowerDefenseReadme.txt for Information |
| CTowerDefenseHUDController | This subclass of OverlayText is used to display the stats of the player in the HUD |
| CTowerDefenseSelecter | |
| CTowerDefenseTower | See TowerDefenseTowerDefenseReadme.txt for Information |
| CTrafficControl | |
| Ctribool | A 3-state boolean type |
| CTrigger | A Trigger is an object that can either be active or inactive, with a specified behavior how to switch between the two |
| CTriggerBase | 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 |
| CTurret | Creates a turret with limited rotation |
| CTurretController | Controller for turrets |
| CUnderAttack | |
| CUpdateListener | Inherit from UpdateListener if you need to receive calls before or after the game is ticked |
| CViewportEventListener | |
| CWagnis | |
| CWagnisGameboard | |
| CWagnisGun | Shoots laser beams |
| ►CWagnisHUD | |
| CObjectInfo | |
| CWagnisHUDinfo | |
| CWagnisPlayer | |
| CWagnisProjectile | |
| CWagnisProvince | |
| CWANDiscoverable | |
| CWANDiscovery | |
| CWaypointController | |
| CWaypointPatrolController | |
| CWeakPtr | WeakPtr wraps a pointer to an object, which becomes nullptr if the object is deleted |
| CWeapon | A Weapon is a StaticEntity that can be attached to a WeaponSlot |
| CWeaponMode | A WeaponMode defines how a Weapon is used |
| CWeaponPack | |
| CWeaponSet | |
| CWeaponSlot | The a WeaponSlot defines where a Weapon is placed on a pawn |
| CWeaponSystem | An orxonox::Pawn that is able to fire weapons always need to have a WeaponSystem |
| CWindowEventListener | Interface for receiving window events like resize, moved and focusChanged |
| CWingmanController | |
| CWorldAmbientSound | This class is used to play and control ambient sound in a level file |
| CWorldEntity | The WorldEntity represents everything that can be put in a Scene at a certain location |
| CWorldEntityCollisionShape | |
| CWorldSound | To be used for sounds with position and orientation |
| CXMLFile | |
| CXMLNameListener | |
| CXMLPortClassObjectContainer | |
| ►CXMLPortClassParamContainer | |
| CParseParams | |
| CXMLPortObjectContainer | |
| CXMLPortParamContainer | |
| CXMLPortVariableHelperClass | Helper class to load and save simple variables with XMLPort |
| ►Nstd | STL namespace |
| ►Ntr1 | |
| ►Ngtest_internal | |
| CAddRef | |
| CAddRef< T & > | |
| CByRef | |
| CByRef< T & > | |
| CGet | |
| CGet< 0 > | |
| CGet< 1 > | |
| CGet< 2 > | |
| CGet< 3 > | |
| CGet< 4 > | |
| CGet< 5 > | |
| CGet< 6 > | |
| CGet< 7 > | |
| CGet< 8 > | |
| CGet< 9 > | |
| CSameSizeTuplePrefixComparator | |
| CSameSizeTuplePrefixComparator< 0, 0 > | |
| CSameSizeTuplePrefixComparator< k, k > | |
| CTupleElement | |
| CTupleElement< true, 0, GTEST_10_TUPLE_(T)> | |
| CTupleElement< true, 1, GTEST_10_TUPLE_(T)> | |
| CTupleElement< true, 2, GTEST_10_TUPLE_(T)> | |
| CTupleElement< true, 3, GTEST_10_TUPLE_(T)> | |
| CTupleElement< true, 4, GTEST_10_TUPLE_(T)> | |
| CTupleElement< true, 5, GTEST_10_TUPLE_(T)> | |
| CTupleElement< true, 6, GTEST_10_TUPLE_(T)> | |
| CTupleElement< true, 7, GTEST_10_TUPLE_(T)> | |
| CTupleElement< true, 8, GTEST_10_TUPLE_(T)> | |
| CTupleElement< true, 9, GTEST_10_TUPLE_(T)> | |
| Ctuple | |
| Ctuple<> | |
| Ctuple_element | |
| Ctuple_size | |
| Ctuple_size< GTEST_0_TUPLE_(T)> | |
| Ctuple_size< GTEST_10_TUPLE_(T)> | |
| Ctuple_size< GTEST_1_TUPLE_(T)> | |
| Ctuple_size< GTEST_2_TUPLE_(T)> | |
| Ctuple_size< GTEST_3_TUPLE_(T)> | |
| Ctuple_size< GTEST_4_TUPLE_(T)> | |
| Ctuple_size< GTEST_5_TUPLE_(T)> | |
| Ctuple_size< GTEST_6_TUPLE_(T)> | |
| Ctuple_size< GTEST_7_TUPLE_(T)> | |
| Ctuple_size< GTEST_8_TUPLE_(T)> | |
| Ctuple_size< GTEST_9_TUPLE_(T)> | |
| ►Ntesting | |
| ►Ninternal | |
| CActionAdaptor | |
| CActionHelper | |
| CActionResultHolder | |
| CActionResultHolder< void > | |
| CAddReference | |
| CAddReference< T & > | |
| CAnyMatcherImpl | |
| CAnythingMatcher | |
| CArgsMatcher | |
| CArgsMatcherImpl | |
| ►CAssertHelper | |
| CAssertHelperData | |
| CAssignAction | |
| Cbool_constant | |
| CBothOfMatcher | |
| CBothOfMatcherImpl | |
| CBuiltInDefaultValue | |
| CBuiltInDefaultValue< const T > | |
| CBuiltInDefaultValue< T * > | |
| CCallableHelper | |
| CCallableTraits | |
| CCallableTraits< ResType(*)(ArgType)> | |
| CCompileAssert | |
| CCompileAssertTypesEqual | |
| CCompileAssertTypesEqual< T, T > | |
| CConstCharPtr | |
| CContainerEqMatcher | |
| CContainsMatcher | |
| CContainsMatcherImpl | |
| CDefaultGlobalTestPartResultReporter | |
| CDefaultPerThreadTestPartResultReporter | |
| ►CDoBothAction | |
| CImpl | |
| CDoDefaultAction | |
| CDummyMatchResultListener | |
| CEachMatcher | |
| CEachMatcherImpl | |
| CEitherOfMatcher | |
| CEitherOfMatcherImpl | |
| CElementsAreArrayMatcher | |
| CElementsAreMatcher0 | |
| CElementsAreMatcher1 | |
| CElementsAreMatcher10 | |
| CElementsAreMatcher2 | |
| CElementsAreMatcher3 | |
| CElementsAreMatcher4 | |
| CElementsAreMatcher5 | |
| CElementsAreMatcher6 | |
| CElementsAreMatcher7 | |
| CElementsAreMatcher8 | |
| CElementsAreMatcher9 | |
| CElementsAreMatcherImpl | |
| CEnableIf | |
| CEnableIf< true > | |
| CEndsWithMatcher | |
| CEqHelper | |
| CEqHelper< true > | |
| CExcessiveArg | |
| CExpectationBase | |
| CFieldMatcher | |
| CFilePath | |
| ►CFloatingEqMatcher | |
| CImpl | |
| ►CFloatingPoint | |
| CFloatingPointUnion | |
| CFunction | |
| CFunction< R()> | |
| CFunction< R(A1)> | |
| CFunction< R(A1, A2)> | |
| CFunction< R(A1, A2, A3)> | |
| CFunction< R(A1, A2, A3, A4)> | |
| CFunction< R(A1, A2, A3, A4, A5)> | |
| CFunction< R(A1, A2, A3, A4, A5, A6)> | |
| CFunction< R(A1, A2, A3, A4, A5, A6, A7)> | |
| CFunction< R(A1, A2, A3, A4, A5, A6, A7, A8)> | |
| CFunction< R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> | |
| CFunction< R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> | |
| CFunctionMocker | |
| CFunctionMocker< R()> | |
| CFunctionMocker< R(A1)> | |
| CFunctionMocker< R(A1, A2)> | |
| CFunctionMocker< R(A1, A2, A3)> | |
| CFunctionMocker< R(A1, A2, A3, A4)> | |
| CFunctionMocker< R(A1, A2, A3, A4, A5)> | |
| CFunctionMocker< R(A1, A2, A3, A4, A5, A6)> | |
| CFunctionMocker< R(A1, A2, A3, A4, A5, A6, A7)> | |
| CFunctionMocker< R(A1, A2, A3, A4, A5, A6, A7, A8)> | |
| CFunctionMocker< R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> | |
| CFunctionMocker< R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> | |
| CFunctionMockerBase | |
| CGoogleTestFailureReporter | |
| CGTestFlagSaver | |
| CGTestLog | |
| CGTestMutexLock | |
| CHasNewFatalFailureHelper | |
| CHasSubstrMatcher | |
| CIgnoredValue | |
| ►CIgnoreResultAction | |
| CImpl | |
| CImplicitlyConvertible | |
| CInvokeAction | |
| CInvokeHelper | |
| CInvokeHelper< R,::std::tr1::tuple< A1 > > | |
| CInvokeHelper< R,::std::tr1::tuple< A1, A2 > > | |
| CInvokeHelper< R,::std::tr1::tuple< A1, A2, A3 > > | |
| CInvokeHelper< R,::std::tr1::tuple< A1, A2, A3, A4 > > | |
| CInvokeHelper< R,::std::tr1::tuple< A1, A2, A3, A4, A5 > > | |
| CInvokeHelper< R,::std::tr1::tuple< A1, A2, A3, A4, A5, A6 > > | |
| CInvokeHelper< R,::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7 > > | |
| CInvokeHelper< R,::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7, A8 > > | |
| CInvokeHelper< R,::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7, A8, A9 > > | |
| CInvokeHelper< R,::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 > > | |
| CInvokeHelper< R,::std::tr1::tuple<> > | |
| CInvokeMethodAction | |
| CInvokeMethodWithoutArgsAction | |
| CInvokeWithoutArgsAction | |
| Cis_pointer | |
| Cis_pointer< T * > | |
| Cis_reference | |
| Cis_reference< T & > | |
| CIsAProtocolMessage | |
| CIsNullMatcher | |
| CIteratorTraits | |
| CIteratorTraits< const T * > | |
| CIteratorTraits< T * > | |
| CKeyMatcher | |
| CKeyMatcherImpl | |
| CKindOf | |
| Clinked_ptr | |
| Clinked_ptr_internal | |
| CLinkedPtrLessThan | |
| CLosslessArithmeticConvertibleImpl | |
| CLosslessArithmeticConvertibleImpl< kBool, bool, kBool, bool > | |
| CLosslessArithmeticConvertibleImpl< kBool, bool, kFloatingPoint, To > | |
| CLosslessArithmeticConvertibleImpl< kBool, bool, kInteger, To > | |
| CLosslessArithmeticConvertibleImpl< kFloatingPoint, From, kBool, bool > | |
| CLosslessArithmeticConvertibleImpl< kFloatingPoint, From, kInteger, To > | |
| CLosslessArithmeticConvertibleImpl< kInteger, From, kBool, bool > | |
| CLosslessArithmeticConvertibleImpl< kInteger, From, kFloatingPoint, To > | |
| CLosslessArithmeticConvertibleImpl< kInteger, From, kInteger, To > | |
| CMatcherAsPredicate | |
| CMatcherBase | |
| CMatcherCastImpl | |
| CMatcherCastImpl< T, Matcher< T > > | |
| ►CMatcherCastImpl< T, Matcher< U > > | |
| CImpl | |
| CMatcherTuple | |
| CMatcherTuple< ::std::tr1::tuple< A1 > > | |
| CMatcherTuple< ::std::tr1::tuple< A1, A2 > > | |
| CMatcherTuple< ::std::tr1::tuple< A1, A2, A3 > > | |
| CMatcherTuple< ::std::tr1::tuple< A1, A2, A3, A4 > > | |
| CMatcherTuple< ::std::tr1::tuple< A1, A2, A3, A4, A5 > > | |
| CMatcherTuple< ::std::tr1::tuple< A1, A2, A3, A4, A5, A6 > > | |
| CMatcherTuple< ::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7 > > | |
| CMatcherTuple< ::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7, A8 > > | |
| CMatcherTuple< ::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7, A8, A9 > > | |
| CMatcherTuple< ::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 > > | |
| CMatcherTuple< ::std::tr1::tuple<> > | |
| CMatchesRegexMatcher | |
| CMockSpec | |
| CMutex | |
| CNativeArray | |
| CNotMatcher | |
| CNotMatcherImpl | |
| CNotNullMatcher | |
| COnCallSpec | |
| COsStackTraceGetter | |
| COsStackTraceGetterInterface | |
| CPairMatcher | |
| CPairMatcherImpl | |
| ►CPointeeMatcher | |
| CImpl | |
| CPointeeOf | |
| CPointeeOf< T * > | |
| ►CPointwiseMatcher | |
| CImpl | |
| CPredicateFormatterFromMatcher | |
| CPrettyUnitTestResultPrinter | |
| CPropertyMatcher | |
| CQuantifierMatcherImpl | |
| CRandom | |
| CRE | |
| CReferenceWrapper | |
| CRefMatcher | |
| ►CRefMatcher< T & > | |
| CImpl | |
| Cremove_reference | |
| Cremove_reference< T & > | |
| CRemoveConst | |
| CRemoveConst< const T > | |
| CRemoveReference | |
| CRemoveReference< T & > | |
| ►CResultOfMatcher | |
| CImpl | |
| ►CReturnAction | |
| CImpl | |
| CReturnNullAction | |
| ►CReturnRefAction | |
| CImpl | |
| ►CReturnRefOfCopyAction | |
| CImpl | |
| CReturnVoidAction | |
| Cscoped_ptr | |
| CScopedTrace | |
| CSelectArgs | |
| CSelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, k7, k8, k9,-1 > | |
| CSelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, k7, k8,-1,-1 > | |
| CSelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, k7,-1,-1,-1 > | |
| CSelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6,-1,-1,-1,-1 > | |
| CSelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5,-1,-1,-1,-1,-1 > | |
| CSelectArgs< Result, ArgumentTuple, k1, k2, k3, k4,-1,-1,-1,-1,-1,-1 > | |
| CSelectArgs< Result, ArgumentTuple, k1, k2, k3,-1,-1,-1,-1,-1,-1,-1 > | |
| CSelectArgs< Result, ArgumentTuple, k1, k2,-1,-1,-1,-1,-1,-1,-1,-1 > | |
| CSelectArgs< Result, ArgumentTuple, k1,-1,-1,-1,-1,-1,-1,-1,-1,-1 > | |
| CSelectArgs< Result, ArgumentTuple,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 > | |
| CSetArgumentPointeeAction | |
| CSetArgumentPointeeAction< N, Proto, true > | |
| CSetErrnoAndReturnAction | |
| CSingleFailureChecker | |
| CStartsWithMatcher | |
| CStaticAssertTypeEqHelper | |
| CStaticAssertTypeEqHelper< T, T > | |
| CStlContainerView | |
| CStlContainerView< ::std::tr1::tuple< ElementPointer, Size > > | |
| CStlContainerView< Element[N]> | |
| CStreamMatchResultListener | |
| CStrEqualityMatcher | |
| CString | |
| CStringMatchResultListener | |
| CTestCaseNameIs | |
| CTestEventRepeater | |
| CTestFactoryBase | |
| CTestFactoryImpl | |
| CTestPropertyKeyIs | |
| CTestResultAccessor | |
| CThreadLocal | |
| CTraceInfo | |
| CTrulyMatcher | |
| CTupleFields | |
| CTupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8,-1 > | |
| CTupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7,-1,-1 > | |
| CTupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6,-1,-1,-1 > | |
| CTupleFields< Tuple, k0, k1, k2, k3, k4, k5,-1,-1,-1,-1 > | |
| CTupleFields< Tuple, k0, k1, k2, k3, k4,-1,-1,-1,-1,-1 > | |
| CTupleFields< Tuple, k0, k1, k2, k3,-1,-1,-1,-1,-1,-1 > | |
| CTupleFields< Tuple, k0, k1, k2,-1,-1,-1,-1,-1,-1,-1 > | |
| CTupleFields< Tuple, k0, k1,-1,-1,-1,-1,-1,-1,-1,-1 > | |
| CTupleFields< Tuple, k0,-1,-1,-1,-1,-1,-1,-1,-1,-1 > | |
| CTupleFields< Tuple,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 > | |
| CTuplePrefix | |
| CTuplePrefix< 0 > | |
| Ctype_equals | |
| Ctype_equals< T, T > | |
| CTypedExpectation | |
| CTypeIdHelper | |
| CTypeWithSize | |
| CTypeWithSize< 4 > | |
| CTypeWithSize< 8 > | |
| CUnitTestImpl | |
| CUnitTestOptions | |
| CUniversalPrinter | |
| CUniversalPrinter< T & > | |
| CUniversalPrinter< T[N]> | |
| CUntypedActionResultHolderBase | |
| CUntypedFunctionMockerBase | |
| CUntypedOnCallSpecBase | |
| ►CWithArgsAction | |
| CImpl | |
| CXmlUnitTestResultPrinter | |
| ►Ninternal2 | |
| CTypeWithoutFormatter | |
| CTypeWithoutFormatter< T, kConvertibleToInteger > | |
| CTypeWithoutFormatter< T, kProtobuf > | |
| CAction | |
| CActionInterface | |
| CAssertionResult | |
| CCardinality | |
| CCardinalityInterface | |
| CDefaultValue | |
| CDefaultValue< T & > | |
| CDefaultValue< void > | |
| CEmptyTestEventListener | |
| ►CEnvironment | |
| CSetup_should_be_spelled_SetUp | |
| ►CExpectation | |
| CLess | |
| CExpectationSet | |
| CInSequence | |
| CMatcher | |
| CMatcher< const internal::string & > | |
| CMatcher< internal::string > | |
| CMatcherInterface | |
| CMatchResultListener | |
| CMessage | |
| CMock | |
| CMockFunction | |
| CMockFunction< R()> | |
| CMockFunction< R(A0)> | |
| CMockFunction< R(A0, A1)> | |
| CMockFunction< R(A0, A1, A2)> | |
| CMockFunction< R(A0, A1, A2, A3)> | |
| CMockFunction< R(A0, A1, A2, A3, A4)> | |
| CMockFunction< R(A0, A1, A2, A3, A4, A5)> | |
| CMockFunction< R(A0, A1, A2, A3, A4, A5, A6)> | |
| CMockFunction< R(A0, A1, A2, A3, A4, A5, A6, A7)> | |
| CMockFunction< R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> | |
| CMockFunction< R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> | |
| CNiceMock | |
| ►CPolymorphicAction | |
| CMonomorphicImpl | |
| ►CPolymorphicMatcher | |
| CMonomorphicImpl | |
| CSafeMatcherCastImpl | |
| CScopedFakeTestPartResultReporter | |
| CSequence | |
| CStrictMock | |
| ►CTest | |
| CSetup_should_be_spelled_SetUp | |
| CTestCase | |
| CTestEventListener | |
| CTestEventListeners | |
| CTestInfo | |
| CTestPartResult | |
| CTestPartResultArray | |
| CTestPartResultReporterInterface | |
| CTestProperty | |
| CTestResult | |
| CUnitTest | |
| 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 | |
| CConverterStringStream | 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 |
| CDeviceComponentInfo | |
| CENetBuffer | |
| CFindAxisCookie | |
| CIsCallable | Checks if a type is callable |
| ►CIsCallableImpl | Implementation of IsCallable |
| CCheck | |
| CDerived | |
| CFallback | |
| CLuaTB | Makes certain functions visible to lua while staying type-safe on the C++ side |
| ►CLuaTBTypedStack | Represents a typed version of the lua stack |
| CGetLuaCallback | |
| Cfunction< Ret(Args...)> | Needed to get a lambda to call a lua function |
| COrxonoxAppDelegate | |
| CTiXmlAttribute | An attribute is a name-value pair |
| CTiXmlAttributeSet | |
| ►CTiXmlBase | TiXmlBase is a base class for every class in TinyXml |
| CEntity | |
| CTiXmlComment | An XML comment |
| CTiXmlCursor | |
| 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 |
| CTiXmlHandle | A TiXmlHandle is a class that wraps a node pointer with null checks; this is an incredibly useful thing |
| CTiXmlNode | The parent class for everything in the Document Object Model |
| CTiXmlOutStream | |
| CTiXmlParsingData | |
| CTiXmlPrinter | Print to memory functionality |
| ►CTiXmlString | |
| CRep | |
| CTiXmlStylesheetReference | A stylesheet reference looks like this: |
| CTiXmlText | XML text |
| CTiXmlUnknown | Any tag that tinyXml doesn't recognize is saved as an unknown |
| CTiXmlVisitor | If you call the Accept() method, it requires being passed a TiXmlVisitor class to handle callbacks |
1.8.11
