Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/libraries/core/input/InputManager.h @ 6417

Last change on this file since 6417 was 6417, checked in by rgrieder, 14 years ago

Merged presentation2 branch back to trunk.
Major new features:

  • Actual GUI with settings, etc.
  • Improved space ship steering (human interaction)
  • Rocket fire and more particle effects
  • Advanced sound framework
  • Property svn:eol-style set to native
File size: 8.8 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Reto Grieder
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29#ifndef _InputManager_H__
30#define _InputManager_H__
31
32#include "InputPrereqs.h"
33
34#include <map>
35#include <set>
36#include <string>
37#include <vector>
38
39#include "util/Singleton.h"
40#include "core/WindowEventListener.h"
41#include "InputState.h"
42
43// tolua_begin
44namespace orxonox
45{
46    /**
47    @brief
48        Manages the input devices (mouse, keyboard, joy sticks) and the input states.
49
50        Every input device has its own wrapper class which does the actually input event
51        distribution. The InputManager only creates reloads (on request) those devices.
52
53        The other functionality concerns handling InputStates. They act as a layer
54        between InputHandlers (like the KeyBinder or the GUIManager) and InputDevices.
55        InputStates are memory managed by the IputManager. You cannot create or destroy
56        them on your own. Therefore all states get destroyed with the InputManager d'tor.
57    @note
58        - The actual lists containing all the InputStates for a specific device are stored
59          in the InputDevices themselves.
60        - The devices_ vector always has at least two elements: Keyboard (first) and mouse.
61          You best access them internally with InputDeviceEnumerator::Keyboard/Mouse
62          The first joy stick is accessed with InputDeviceEnumerator::FirstJoyStick.
63        - Keyboard construction is mandatory , mouse and joy sticks are not.
64          If the OIS::InputManager or the Keyboard fail, an exception is thrown.
65    */
66    class _CoreExport InputManager
67// tolua_end
68        : public Singleton<InputManager>, public WindowEventListener
69    { // tolua_export
70        friend class Singleton<InputManager>;
71    public:
72        //! Represents internal states of the InputManager.
73        enum State
74        {
75            Nothing       = 0x00,
76            Bad           = 0x02,
77            Ticking       = 0x04,
78            Calibrating   = 0x08,
79            ReloadRequest = 0x10,
80        };
81
82        /**
83        @brief
84            Loads the devices and initialises the KeyDetector and the Calibrator.
85
86            If either the OIS input system and/or the keyboard could not be created,
87            the constructor fails with an std::exception.
88        */
89        InputManager();
90        //! Destroys all devices AND all input states!
91        ~InputManager();
92        void setConfigValues();
93
94        /**
95        @brief
96            Updates the devices (which distribute the input events) and the input states.
97
98            Any InpuStates changes (destroy, enter, leave) and happens here. If a reload request
99            was submitted while updating, the request will be postponed until the next update call.
100        */
101        void preUpdate(const Clock& time);
102        //! Clears all input device buffers. This usually only includes the pressed button list.
103        void clearBuffers();
104        //! Starts joy stick calibration.
105        void calibrate();
106        /**
107        @brief
108            Reloads all the input devices. Use this method to initialise new joy sticks.
109        @note
110            Only reloads immediately if the call stack doesn't include the preUpdate() method.
111        */
112        void reload();
113
114        //-------------------------------
115        // Input States
116        //-------------------------------
117        /**
118        @brief
119            Creates a new InputState that gets managed by the InputManager.
120        @remarks
121            The InputManager will take care of the state completely. That also
122            means it gets deleted when the InputManager is destroyed!
123        @param name
124            Unique name of the InputState when referenced as string
125        @param priority
126            Priority matters when multiple states are active. You can specify any
127            number, but 1 - 99 is preferred (99 means high priority).
128        */
129        InputState* createInputState(const std::string& name, bool bAlwaysGetsInput = false, bool bTransparent = false, InputStatePriority priority = InputStatePriority::Dynamic);
130        /**
131        @brief
132            Returns a pointer to a InputState referenced by name.
133        @return
134            Returns NULL if state was not found.
135        */
136        InputState* getState(const std::string& name);
137        /**
138        @brief
139            Activates a specific input state.
140            It might not actually be activated if the priority is too low!
141        @return
142            False if name was not found, true otherwise.
143        */
144        bool enterState(const std::string& name); // tolua_export
145        /**
146        @brief
147            Deactivates a specific input state.
148        @return
149            False if name was not found, true otherwise.
150        */
151        bool leaveState(const std::string& name); // tolua_export
152        /**
153        @brief
154            Removes and destroys an input state.
155        @return
156            True if removal was successful, false if name was not found.
157        @remarks
158            - You can't remove the internal states "empty", "calibrator" and "detector".
159            - The removal process is being postponed if InputManager::preUpdate() is currently running.
160        */
161        bool destroyState(const std::string& name);
162
163        //-------------------------------
164        // Various getters and setters
165        //-------------------------------
166        //! Returns the number of joy stick that have been created since the c'tor or last call to reload().
167        unsigned int getJoyStickQuantity() const
168            { return devices_.size() - InputDeviceEnumerator::FirstJoyStick; }
169        //! Returns a pointer to the OIS InputManager. Only you if you know what you're doing!
170        OIS::InputManager* getOISInputManager() { return this->oisInputManager_; }
171        std::pair<int, int> getMousePosition() const;
172
173        static InputManager& getInstance() { return Singleton<InputManager>::getInstance(); } // tolua_export
174
175    private: // functions
176        // don't mess with a Singleton
177        InputManager(const InputManager&);
178
179        // Internal methods
180        void loadDevices();
181        void loadMouse();
182        void loadJoySticks();
183        void destroyDevices();
184
185        void stopCalibration();
186        void reloadInternal();
187
188        void destroyStateInternal(InputState* state);
189        void updateActiveStates();
190
191        // From WindowEventListener
192        void windowFocusChanged();
193
194    private: // variables
195        State                               internalState_;        //!< Current internal state
196        OIS::InputManager*                  oisInputManager_;      //!< OIS input manager
197        std::vector<InputDevice*>           devices_;              //!< List of all input devices (keyboard, mouse, joy sticks)
198        MouseMode::Value                    mouseMode_;            //!< Currently applied mouse mode
199
200        // some internally handled states and handlers
201        InputState*                         emptyState_;           //!< Lowest priority states (makes handling easier)
202        //! InputBuffer that reacts to the Enter key when calibrating the joy sticks
203        InputBuffer*                        calibratorCallbackHandler_;
204
205        std::map<std::string, InputState*>  statesByName_;         //!< Contains all the created input states by name
206        std::map<int, InputState*>          activeStates_;         //!< Contains all active input states by priority (std::map is sorted!)
207        std::vector<InputState*>            activeStatesTicked_;   //!< Like activeStates_, but only contains the ones that currently receive events
208
209        std::set<InputState*>               stateEnterRequests_;   //!< Requests to enter a new state
210        std::set<InputState*>               stateLeaveRequests_;   //!< Requests to leave a running state
211        std::set<InputState*>               stateDestroyRequests_; //!< Requests to destroy a state
212
213        static InputManager*                singletonPtr_s;        //!< Pointer reference to the singleton
214    }; // tolua_export
215} // tolua_export
216
217#endif /* _InputManager_H__ */
Note: See TracBrowser for help on using the repository browser.