Debian Codegraph @

src/input/LibretroDeviceInput.cpp

raw
1 /*
2 * Copyright (C) 2015-2021 Team Kodi (https://kodi.tv)
3 *
4 * SPDX-License-Identifier: GPL-2.0-or-later
5 * See LICENSE.md for more information.
6 */
7
8 #include "LibretroDeviceInput.h"
9 #include "LibretroDevice.h"
10 #include "ButtonMapper.h"
11 #include "libretro/ClientBridge.h"
12 #include "libretro/LibretroEnvironment.h"
13 #include "libretro/LibretroTranslator.h"
14 #include "libretro-common/libretro.h"
15 #include "log/Log.h"
16
17 using namespace LIBRETRO;
18
19 #define LIBRETRO_JOYPAD_BUTTON_COUNT 16
20 #define LIBRETRO_ANALOG_STICK_COUNT 2
21 #define LIBRETRO_ACCELEROMETER_COUNT 1
22 #define LIBRETRO_MOUSE_BUTTON_COUNT 11
23 #define LIBRETRO_LIGHTGUN_BUTTON_COUNT 17
24 #define LIBRETRO_RELATIVE_POINTER_COUNT 1
25 #define LIBRETRO_ABSOLUTE_POINTER_COUNT 10
26
27 #define ANALOG_DIGITAL_THRESHHOLD 0.5f
28
29 CLibretroDeviceInput::CLibretroDeviceInput(const std::string &controllerId)
30 {
31 unsigned int type = CButtonMapper::Get().GetLibretroType(controllerId);
32
33 switch (type)
34 {
35 case RETRO_DEVICE_JOYPAD:
36 m_buttons.resize(LIBRETRO_JOYPAD_BUTTON_COUNT);
37 m_analogButtons.resize(LIBRETRO_JOYPAD_BUTTON_COUNT);
38 m_analogSticks.resize(LIBRETRO_ANALOG_STICK_COUNT);
39 break;
40
41 case RETRO_DEVICE_MOUSE:
42 m_buttons.resize(LIBRETRO_MOUSE_BUTTON_COUNT);
43 m_relativePointers.resize(LIBRETRO_RELATIVE_POINTER_COUNT);
44 break;
45
46 case RETRO_DEVICE_LIGHTGUN:
47 m_buttons.resize(LIBRETRO_LIGHTGUN_BUTTON_COUNT);
48 m_relativePointers.resize(LIBRETRO_RELATIVE_POINTER_COUNT);
49 break;
50
51 case RETRO_DEVICE_ANALOG:
52 m_buttons.resize(LIBRETRO_JOYPAD_BUTTON_COUNT);
53 m_analogButtons.resize(LIBRETRO_JOYPAD_BUTTON_COUNT);
54 m_analogSticks.resize(LIBRETRO_ANALOG_STICK_COUNT);
55 break;
56
57 case RETRO_DEVICE_POINTER:
58 m_absolutePointers.resize(LIBRETRO_ABSOLUTE_POINTER_COUNT);
59 break;
60
61 case RETRO_DEVICE_KEYBOARD:
62 m_buttons.resize(RETROK_LAST - 1);
63 break;
64
65 default:
66 break;
67 }
68
69 m_accelerometers.resize(LIBRETRO_ACCELEROMETER_COUNT);
70 }
71
72 bool CLibretroDeviceInput::ButtonState(unsigned int buttonIndex) const
73 {
74 bool buttonState = false;
75
76 if (buttonIndex < m_buttons.size())
77 buttonState = m_buttons[buttonIndex].pressed;
78
79 return buttonState;
80 }
81
82 float CLibretroDeviceInput::AnalogButtonState(unsigned int buttonIndex) const
83 {
84 float axisState = 0.0f;
85
86 if (buttonIndex < m_analogButtons.size())
87 axisState = m_analogButtons[buttonIndex].magnitude;
88
89 return axisState;
90 }
91
92 bool CLibretroDeviceInput::AnalogStickState(unsigned int analogStickIndex, float& x, float& y) const
93 {
94 bool bSuccess = false;
95
96 if (analogStickIndex < m_analogSticks.size())
97 {
98 x = m_analogSticks[analogStickIndex].x;
99 y = m_analogSticks[analogStickIndex].y;
100 bSuccess = true;
101 }
102
103 return bSuccess;
104 }
105
106 bool CLibretroDeviceInput::AccelerometerState(float& x, float& y, float& z) const
107 {
108 bool bSuccess = false;
109
110 if (!m_accelerometers.empty())
111 {
112 x = m_accelerometers[0].x;
113 y = m_accelerometers[0].y;
114 z = m_accelerometers[0].z;
115 bSuccess = true;
116 }
117
118 return bSuccess;
119 }
120
121 int CLibretroDeviceInput::RelativePointerDeltaX(void)
122 {
123 int deltaX = 0;
124
125 if (!m_relativePointers.empty())
126 {
127 std::unique_lock<std::mutex> lock(m_relativePtrMutex);
128
129 deltaX = m_relativePointers[0].x;
130 m_relativePointers[0].x = 0;
131 }
132
133 return deltaX;
134 }
135
136 int CLibretroDeviceInput::RelativePointerDeltaY(void)
137 {
138 int deltaY = 0;
139
140 if (!m_relativePointers.empty())
141 {
142 std::unique_lock<std::mutex> lock(m_relativePtrMutex);
143
144 deltaY = m_relativePointers[0].y;
145 m_relativePointers[0].y = 0;
146 }
147
148 return deltaY;
149 }
150
151 bool CLibretroDeviceInput::AbsolutePointerState(unsigned int pointerIndex, float& x, float& y) const
152 {
153 bool bSuccess = false;
154
155 if (pointerIndex < m_absolutePointers.size() && m_absolutePointers[pointerIndex].pressed)
156 {
157 x = m_absolutePointers[pointerIndex].x;
158 y = m_absolutePointers[pointerIndex].y;
159 bSuccess = true;
160 }
161
162 return bSuccess;
163 }
164
165 bool CLibretroDeviceInput::InputEvent(const game_input_event& event)
166 {
167 const std::string strControllerId = event.controller_id ? event.controller_id : "";
168 const std::string strFeatureName = event.feature_name ? event.feature_name : "";
169
170 int index = CButtonMapper::Get().GetLibretroIndex(strControllerId, strFeatureName);
171 if (index >= 0)
172 {
173 switch (event.type)
174 {
175 case GAME_INPUT_EVENT_DIGITAL_BUTTON:
176 {
177 if (index < (int)m_buttons.size())
178 m_buttons[index] = event.digital_button;
179
180 if (index < static_cast<int>(m_analogButtons.size()))
181 m_analogButtons[index].magnitude = event.digital_button.pressed ? 1.0f : 0.0f;
182
183 break;
184 }
185
186 case GAME_INPUT_EVENT_ANALOG_BUTTON:
187 {
188 if (index < static_cast<int>(m_buttons.size()))
189 m_buttons[index].pressed = (event.analog_button.magnitude >= ANALOG_DIGITAL_THRESHHOLD);
190
191 if (index < static_cast<int>(m_analogButtons.size()))
192 m_analogButtons[index].magnitude = event.analog_button.magnitude;
193
194 break;
195 }
196
197 case GAME_INPUT_EVENT_AXIS:
198 {
199 const int axisId = CButtonMapper::Get().GetAxisID(strControllerId, strFeatureName);
200 if (axisId >= 0)
201 {
202 const libretro_device_t deviceType = CButtonMapper::Get().GetLibretroDevice(strControllerId, strFeatureName);
203 switch (deviceType)
204 {
205 case RETRO_DEVICE_ANALOG:
206 {
207 if (index < static_cast<int>(m_analogSticks.size()))
208 {
209 auto& analogStick = m_analogSticks[index];
210 switch (axisId)
211 {
212 case RETRO_DEVICE_ID_ANALOG_X:
213 analogStick.x = event.axis.position;
214 break;
215 case RETRO_DEVICE_ID_ANALOG_Y:
216 analogStick.y = event.axis.position;
217 break;
218 default:
219 break;
220 }
221 }
222 break;
223 }
224 case RETRO_DEVICE_POINTER:
225 {
226 if (index < static_cast<int>(m_absolutePointers.size()))
227 {
228 auto& absPointer = m_absolutePointers[index];
229 switch (axisId)
230 {
231 case RETRO_DEVICE_ID_POINTER_X:
232 absPointer.x = event.axis.position;
233 break;
234 case RETRO_DEVICE_ID_POINTER_Y:
235 absPointer.y = event.axis.position;
236 break;
237 default:
238 break;
239 }
240 }
241 break;
242 }
243 default:
244 break;
245 }
246 }
247
248 break;
249 }
250
251 case GAME_INPUT_EVENT_ANALOG_STICK:
252 if (index < (int)m_analogSticks.size())
253 m_analogSticks[index] = event.analog_stick;
254 break;
255
256 case GAME_INPUT_EVENT_ACCELEROMETER:
257 if (index < (int)m_accelerometers.size())
258 m_accelerometers[index] = event.accelerometer;
259 break;
260
261 case GAME_INPUT_EVENT_KEY:
262 {
263 // Send keypress to libertro
264 SendKeyEvent(strControllerId, strFeatureName, index, event.key);
265
266 // Save keypress for polling
267 if (static_cast<size_t>(index) < m_buttons.size())
268 m_buttons[index] = event.digital_button;
269
270 break;
271 }
272
273 case GAME_INPUT_EVENT_RELATIVE_POINTER:
274 if (index < (int)m_relativePointers.size())
275 {
276 std::unique_lock<std::mutex> lock(m_relativePtrMutex);
277
278 m_relativePointers[index].x += event.rel_pointer.x;
279 m_relativePointers[index].y += event.rel_pointer.y;
280 }
281 break;
282
283 case GAME_INPUT_EVENT_ABSOLUTE_POINTER:
284 if (index < (int)m_absolutePointers.size())
285 m_absolutePointers[index] = event.abs_pointer;
286 break;
287
288 default:
289 break;
290 }
291
292 return true;
293 }
294
295 return false;
296 }
297
298 void CLibretroDeviceInput::SendKeyEvent(const std::string &controllerId,
299 const std::string &feature,
300 unsigned int keyIndex,
301 const game_key_event &keyEvent)
302 {
303 // Report key to client
304 CClientBridge* clientBridge = CLibretroEnvironment::Get().GetClientBridge();
305 if (clientBridge)
306 {
307 const bool down = keyEvent.pressed;
308 const retro_key keycode = static_cast<retro_key>(keyIndex);
309 const uint32_t character = keyEvent.unicode;
310 const retro_mod key_modifiers = LibretroTranslator::GetKeyModifiers(keyEvent.modifiers);
311 std::string retroKey = LibretroTranslator::GetFeatureName(RETRO_DEVICE_KEYBOARD, 0, keycode);
312
313 dsyslog("Controller \"%s\" key \"%s\" (%s) modifier 0x%08x: %s",
314 controllerId.c_str(),
315 feature.c_str(),
316 retroKey.c_str(),
317 keyEvent.modifiers,
318 down ? "down" : "up");
319
320 clientBridge->KeyboardEvent(down, keycode, character, key_modifiers);
321 }
322 }