SuperTuxKart
device_manager.hpp
1 //
2 // SuperTuxKart - a fun racing game with go-kart
3 // Copyright (C) 2010-2015 SuperTuxKart-Team
4 //
5 // This program is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU General Public License
7 // as published by the Free Software Foundation; either version 3
8 // of the License, or (at your option) any later version.
9 //
10 // This program is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with this program; if not, write to the Free Software
17 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 
19 #ifndef DEVICE_MANAGER_HPP
20 #define DEVICE_MANAGER_HPP
21 
22 #include "input/gamepad_config.hpp"
23 #include "input/input_manager.hpp"
24 #include "input/keyboard_config.hpp"
25 #include "states_screens/state_manager.hpp"
26 #include "utils/no_copy.hpp"
27 #include "utils/ptr_vector.hpp"
28 
29 #include <irrArray.h>
30 #include <IEventReceiver.h>
31 using namespace irr;
32 
33 class DeviceConfig;
34 class InputDevice;
35 class GamePadDevice;
36 class KeyboardDevice;
37 class MultitouchDevice;
38 
39 
40 enum PlayerAssignMode
41 {
42  NO_ASSIGN,
43  DETECT_NEW,
44  ASSIGN
45 };
46 
62 class DeviceManager: public NoCopy
63 {
64 private:
65 
68  PtrVector<KeyboardConfig, HOLD> m_keyboard_configs;
69  PtrVector<GamepadConfig, HOLD> m_gamepad_configs;
70  MultitouchDevice* m_multitouch_device;
71 
72  InputDevice* m_latest_used_device;
73  PlayerAssignMode m_assign_mode;
74 
75 
78 
84 
85 
86  InputDevice *mapGamepadInput( Input::InputType type, int deviceID,
87  int btnID, int axisDir,
88  int* value /* inout */,
89  InputManager::InputDriverMode mode,
90  StateManager::ActivePlayer **player /* out */,
91  PlayerAction *action /* out */);
92  InputDevice *mapKeyboardInput(int button_id,
93  InputManager::InputDriverMode mode,
94  StateManager::ActivePlayer **player /* out */,
95  PlayerAction *action /* out */);
96 
97  bool load();
98  void shutdown();
99 
100 public:
101 
102 
103  DeviceManager();
104  ~DeviceManager();
105 
106  // ---- Assign mode ----
107  PlayerAssignMode getAssignMode() const { return m_assign_mode; }
108  void setAssignMode(const PlayerAssignMode assignMode);
109 
110  // ---- Gamepads ----
111  void addGamepad(GamePadDevice* d);
112  int getGamePadAmount() const { return m_gamepads.size(); }
113  int getGamePadConfigAmount() const { return m_gamepad_configs.size(); }
114  GamePadDevice* getGamePad(const int i) { return m_gamepads.get(i); }
115  GamepadConfig* getGamepadConfig(const int i) { return m_gamepad_configs.get(i); }
116  GamePadDevice* getGamePadFromIrrID(const int i);
117  void clearGamepads();
119  bool getConfigForGamepad(const int sdl_id,
120  const std::string& name,
121  GamepadConfig **config);
122 
123  // ---- Keyboard(s) ----
124  void addEmptyKeyboard();
125  void addKeyboard(KeyboardDevice* d);
126  void clearKeyboard();
127  int getKeyboardAmount() { return m_keyboards.size(); }
128  int getActiveKeyboardAmount()
129  {
130  int active = 0;
131  for (unsigned int i=0;i<m_keyboard_configs.size();i++)
132  {
133  if (m_keyboard_configs[i].isEnabled()) active++;
134  }
135  return active;
136  }
137  int getKeyboardConfigAmount() const { return m_keyboard_configs.size(); }
138  KeyboardDevice* getKeyboard(const int i) { return m_keyboards.get(i); }
139  KeyboardConfig* getKeyboardConfig(const int i) { return m_keyboard_configs.get(i); }
140  KeyboardDevice* getKeyboardFromBtnID(const int btnID);
141 
142  // ---- Multitouch device ----
143  MultitouchDevice* getMultitouchDevice() { return m_multitouch_device; }
144  void clearMultitouchDevices();
145  void updateMultitouchDevice();
146 
147 
151  bool deleteConfig(DeviceConfig* config);
152 
162  bool translateInput( Input::InputType type,
163  int deviceID,
164  int btnID,
165  int axisDir,
166  int *value /* inout */,
167  InputManager::InputDriverMode mode,
168  StateManager::ActivePlayer** player /* out */,
169  PlayerAction* action /* out */ );
170 
171  void clearLatestUsedDevice();
172  InputDevice* getLatestUsedDevice();
173  bool initialize();
174  void save();
175 
176  // ------------------------------------------------------------------------
179  StateManager::ActivePlayer* getSinglePlayer() { return m_single_player; }
180  // ------------------------------------------------------------------------
188  {
189  m_single_player = p;
190  } // setSinglePlayer
191  // ------------------------------------------------------------------------
194  void mapFireToSelect(bool v) {m_map_fire_to_select = v; }
195 
196 }; // DeviceManager
197 
198 
199 #endif
bool m_map_fire_to_select
If this is flag is set the next fire event (if the fire key is not mapped to anything else) will be m...
Definition: device_manager.hpp:83
Represents a player that is currently playing.
Definition: state_manager.hpp:75
Definition: multitouch_device.hpp:75
contains the key bindings information related to one input device
Definition: device_config.hpp:41
PlayerAction
types of input events / what actions the players can do
Definition: input.hpp:116
StateManager::ActivePlayer * m_single_player
Will be non-null in single-player mode.
Definition: device_manager.hpp:77
specialisation of Inputdevice for gamepad type devices
Definition: gamepad_device.hpp:32
Definition: three_d_animation.hpp:32
specialisation of InputDevice for keyboard type devices
Definition: keyboard_device.hpp:33
specialisation of DeviceConfig for gamepad type devices
Definition: gamepad_config.hpp:42
specialisation of DeviceConfig for keyboard type devices
Definition: keyboard_config.hpp:34
base class for input devices
Definition: input_device.hpp:47
void setSinglePlayer(StateManager::ActivePlayer *p)
Sets the ActivePlayer if there is only a single local player.
Definition: device_manager.hpp:187
Utility class, you can inherit from this class to disallow the assignment operator and copy construct...
Definition: no_copy.hpp:25
void mapFireToSelect(bool v)
Sets or reset the &#39;map fire to select&#39; option.
Definition: device_manager.hpp:194
StateManager::ActivePlayer * getSinglePlayer()
Returns the active player if there is only a single local player.
Definition: device_manager.hpp:179
This class holds the list of all known devices (ands their configurations), as well as the list of cu...
Definition: device_manager.hpp:62