Debian Codegraph @

src/sdl/sdl_joystick.c

raw
1 /* ______ ___ ___
2 * /\ _ \ /\_ \ /\_ \
3 * \ \ \L\ \\//\ \ \//\ \ __ __ _ __ ___
4 * \ \ __ \ \ \ \ \ \ \ /'__`\ /'_ `\/\`'__\/ __`\
5 * \ \ \/\ \ \_\ \_ \_\ \_/\ __//\ \L\ \ \ \//\ \L\ \
6 * \ \_\ \_\/\____\/\____\ \____\ \____ \ \_\\ \____/
7 * \/_/\/_/\/____/\/____/\/____/\/___L\ \/_/ \/___/
8 * /\____/
9 * \_/__/
10 *
11 * SDL joystick driver.
12 *
13 * See LICENSE.txt for copyright information.
14 */
15 #include "allegro5/allegro.h"
16 #include "allegro5/internal/aintern.h"
17 #include "allegro5/internal/aintern_system.h"
18 #include "allegro5/platform/allegro_internal_sdl.h"
19
20 ALLEGRO_DEBUG_CHANNEL("SDL")
21
22 typedef struct ALLEGRO_JOYSTICK_SDL
23 {
24 SDL_JoystickID id;
25 ALLEGRO_JOYSTICK allegro;
26 SDL_Joystick *sdl;
27 SDL_GameController *sdl_gc;
28 bool dpad_state[4];
29 } ALLEGRO_JOYSTICK_SDL;
30
31 static ALLEGRO_JOYSTICK_DRIVER *vt;
32 static int num_joysticks; /* number of joysticks known to the user */
33 static _AL_VECTOR joysticks = _AL_VECTOR_INITIALIZER(ALLEGRO_JOYSTICK_SDL *); /* of ALLEGRO_JOYSTICK_SDL pointers */
34
35 static bool compat_5_2_10(void) {
36 /* Mappings. */
37 return _al_get_joystick_compat_version() < AL_ID(5, 2, 11, 0);
38 }
39
40 static ALLEGRO_JOYSTICK_SDL *get_joystick_from_allegro(ALLEGRO_JOYSTICK *allegro)
41 {
42 for (int i = 0; i < (int)_al_vector_size(&joysticks); i++) {
43 ALLEGRO_JOYSTICK_SDL *joy = *(ALLEGRO_JOYSTICK_SDL **)_al_vector_ref(&joysticks, i);
44 if (&joy->allegro == allegro)
45 return joy;
46 }
47 ASSERT(false);
48 return NULL;
49 }
50
51 static ALLEGRO_JOYSTICK_SDL *get_joystick(SDL_JoystickID id)
52 {
53 for (int i = 0; i < (int)_al_vector_size(&joysticks); i++) {
54 ALLEGRO_JOYSTICK_SDL *joy = *(ALLEGRO_JOYSTICK_SDL **)_al_vector_ref(&joysticks, i);
55 if (joy->id == id)
56 return joy;
57 }
58 ASSERT(false);
59 return NULL;
60 }
61
62 static ALLEGRO_JOYSTICK_SDL *get_or_insert_joystick(SDL_JoystickID id)
63 {
64 ALLEGRO_JOYSTICK_SDL **slot;
65 ALLEGRO_JOYSTICK_SDL *joy;
66
67 for (int i = 0; i < (int)_al_vector_size(&joysticks); i++) {
68 slot = _al_vector_ref(&joysticks, i);
69 joy = *slot;
70 if (joy->id == id)
71 return joy;
72 }
73
74 for (int i = 0; i < (int)_al_vector_size(&joysticks); i++) {
75 slot = _al_vector_ref(&joysticks, i);
76 joy = *slot;
77 if (!SDL_JoystickFromInstanceID(joy->id)) {
78 joy->id = id;
79 return joy;
80 }
81 }
82
83 joy = al_calloc(1, sizeof *joy);
84 joy->id = id;
85 slot = _al_vector_alloc_back(&joysticks);
86 *slot = joy;
87 return joy;
88 }
89
90 void _al_sdl_joystick_event(SDL_Event *e)
91 {
92 bool emit = false;
93 ALLEGRO_EVENT event;
94 memset(&event, 0, sizeof event);
95
96 event.joystick.timestamp = al_get_time();
97
98 if (e->type == SDL_CONTROLLERAXISMOTION) {
99 ALLEGRO_JOYSTICK_SDL *joy = get_joystick(e->caxis.which);
100 if (joy->allegro.info.type != ALLEGRO_JOYSTICK_TYPE_GAMEPAD)
101 return;
102 int stick = -1;
103 int axis = -1;
104 switch (e->caxis.axis) {
105 case SDL_CONTROLLER_AXIS_LEFTX:
106 stick = ALLEGRO_GAMEPAD_STICK_LEFT_THUMB;
107 axis = 0;
108 break;
109 case SDL_CONTROLLER_AXIS_LEFTY:
110 stick = ALLEGRO_GAMEPAD_STICK_LEFT_THUMB;
111 axis = 1;
112 break;
113 case SDL_CONTROLLER_AXIS_RIGHTX:
114 stick = ALLEGRO_GAMEPAD_STICK_RIGHT_THUMB;
115 axis = 0;
116 break;
117 case SDL_CONTROLLER_AXIS_RIGHTY:
118 stick = ALLEGRO_GAMEPAD_STICK_RIGHT_THUMB;
119 axis = 1;
120 break;
121 case SDL_CONTROLLER_AXIS_TRIGGERLEFT:
122 stick = ALLEGRO_GAMEPAD_STICK_LEFT_TRIGGER;
123 axis = 0;
124 break;
125 case SDL_CONTROLLER_AXIS_TRIGGERRIGHT:
126 stick = ALLEGRO_GAMEPAD_STICK_RIGHT_TRIGGER;
127 axis = 0;
128 break;
129 }
130 if (stick >= 0 && axis >= 0) {
131 event.joystick.type = ALLEGRO_EVENT_JOYSTICK_AXIS;
132 event.joystick.id = &joy->allegro;
133 event.joystick.stick = stick;
134 event.joystick.axis = axis;
135 event.joystick.pos = e->caxis.value / 32768.0;
136 event.joystick.button = 0;
137 emit = true;
138 }
139 }
140 else if (e->type == SDL_CONTROLLERBUTTONDOWN || e->type == SDL_CONTROLLERBUTTONUP) {
141 int stick = 0;
142 int axis = 0;
143 int button = 0;
144 float pos = 0.;
145 bool down = e->type == SDL_CONTROLLERBUTTONDOWN;
146 int type = down ? ALLEGRO_EVENT_JOYSTICK_BUTTON_DOWN : ALLEGRO_EVENT_JOYSTICK_BUTTON_UP;
147 ALLEGRO_JOYSTICK_SDL *joy = get_joystick(e->cbutton.which);
148 if (joy->allegro.info.type != ALLEGRO_JOYSTICK_TYPE_GAMEPAD)
149 return;
150
151 switch (e->cbutton.button) {
152 case SDL_CONTROLLER_BUTTON_A:
153 button = ALLEGRO_GAMEPAD_BUTTON_A;
154 break;
155 case SDL_CONTROLLER_BUTTON_B:
156 button = ALLEGRO_GAMEPAD_BUTTON_B;
157 break;
158 case SDL_CONTROLLER_BUTTON_X:
159 button = ALLEGRO_GAMEPAD_BUTTON_X;
160 break;
161 case SDL_CONTROLLER_BUTTON_Y:
162 button = ALLEGRO_GAMEPAD_BUTTON_Y;
163 break;
164 case SDL_CONTROLLER_BUTTON_BACK:
165 button = ALLEGRO_GAMEPAD_BUTTON_BACK;
166 break;
167 case SDL_CONTROLLER_BUTTON_GUIDE:
168 button = ALLEGRO_GAMEPAD_BUTTON_GUIDE;
169 break;
170 case SDL_CONTROLLER_BUTTON_START:
171 button = ALLEGRO_GAMEPAD_BUTTON_START;
172 break;
173 case SDL_CONTROLLER_BUTTON_LEFTSHOULDER:
174 button = ALLEGRO_GAMEPAD_BUTTON_LEFT_SHOULDER;
175 break;
176 case SDL_CONTROLLER_BUTTON_RIGHTSHOULDER:
177 button = ALLEGRO_GAMEPAD_BUTTON_RIGHT_SHOULDER;
178 break;
179 case SDL_CONTROLLER_BUTTON_LEFTSTICK:
180 button = ALLEGRO_GAMEPAD_BUTTON_LEFT_THUMB;
181 break;
182 case SDL_CONTROLLER_BUTTON_RIGHTSTICK:
183 button = ALLEGRO_GAMEPAD_BUTTON_RIGHT_THUMB;
184 break;
185 case SDL_CONTROLLER_BUTTON_DPAD_LEFT:
186 type = ALLEGRO_EVENT_JOYSTICK_AXIS;
187 axis = 0;
188 joy->dpad_state[2] = down;
189 break;
190 case SDL_CONTROLLER_BUTTON_DPAD_RIGHT:
191 type = ALLEGRO_EVENT_JOYSTICK_AXIS;
192 axis = 0;
193 joy->dpad_state[0] = down;
194 break;
195 case SDL_CONTROLLER_BUTTON_DPAD_UP:
196 type = ALLEGRO_EVENT_JOYSTICK_AXIS;
197 axis = 1;
198 joy->dpad_state[3] = down;
199 break;
200 case SDL_CONTROLLER_BUTTON_DPAD_DOWN:
201 type = ALLEGRO_EVENT_JOYSTICK_AXIS;
202 axis = 1;
203 joy->dpad_state[1] = down;
204 break;
205 default:
206 type = 0;
207 }
208 if (type == ALLEGRO_EVENT_JOYSTICK_AXIS) {
209 stick = ALLEGRO_GAMEPAD_STICK_DPAD;
210 if (axis == 0)
211 pos = (int)joy->dpad_state[0] - (int)joy->dpad_state[2];
212 else
213 pos = (int)joy->dpad_state[1] - (int)joy->dpad_state[3];
214 }
215 if (type != 0) {
216 event.joystick.type = type;
217 event.joystick.id = &joy->allegro;
218 event.joystick.stick = stick;
219 event.joystick.axis = axis;
220 event.joystick.pos = pos;
221 event.joystick.button = button;
222 emit = true;
223 }
224 }
225 else if (e->type == SDL_CONTROLLERDEVICEADDED || e->type == SDL_CONTROLLERDEVICEREMOVED
226 || e->type == SDL_JOYDEVICEADDED || e->type == SDL_JOYDEVICEREMOVED) {
227 event.joystick.type = ALLEGRO_EVENT_JOYSTICK_CONFIGURATION;
228 emit = true;
229 }
230 else if (e->type == SDL_JOYAXISMOTION) {
231 ALLEGRO_JOYSTICK_SDL *joy = get_joystick(e->jaxis.which);
232 if (joy->allegro.info.type != ALLEGRO_JOYSTICK_TYPE_UNKNOWN)
233 return;
234 event.joystick.type = ALLEGRO_EVENT_JOYSTICK_AXIS;
235 event.joystick.id = &joy->allegro;
236 event.joystick.stick = e->jaxis.axis / 2;
237 event.joystick.axis = e->jaxis.axis % 2;
238 event.joystick.pos = e->jaxis.value / 32768.0;
239 event.joystick.button = 0;
240 emit = true;
241 }
242 else if (e->type == SDL_JOYBUTTONDOWN) {
243 ALLEGRO_JOYSTICK_SDL *joy = get_joystick(e->jbutton.which);
244 if (joy->allegro.info.type != ALLEGRO_JOYSTICK_TYPE_UNKNOWN)
245 return;
246 event.joystick.type = ALLEGRO_EVENT_JOYSTICK_BUTTON_DOWN;
247 event.joystick.id = &joy->allegro;
248 event.joystick.stick = 0;
249 event.joystick.axis = 0;
250 event.joystick.pos = 0;
251 event.joystick.button = e->jbutton.button;
252 emit = true;
253 }
254 else if (e->type == SDL_JOYBUTTONUP) {
255 ALLEGRO_JOYSTICK_SDL *joy = get_joystick(e->jbutton.which);
256 if (joy->allegro.info.type != ALLEGRO_JOYSTICK_TYPE_UNKNOWN)
257 return;
258 event.joystick.type = ALLEGRO_EVENT_JOYSTICK_BUTTON_UP;
259 event.joystick.id = &joy->allegro;
260 event.joystick.stick = 0;
261 event.joystick.axis = 0;
262 event.joystick.pos = 0;
263 event.joystick.button = e->jbutton.button;
264 emit = true;
265 }
266 else {
267 return;
268 }
269
270 if (emit) {
271 ALLEGRO_EVENT_SOURCE *es = al_get_joystick_event_source();
272 _al_event_source_lock(es);
273 _al_event_source_emit_event(es, &event);
274 _al_event_source_unlock(es);
275 }
276 }
277
278 static void clear_joysticks(void)
279 {
280 for (int i = 0; i < (int)_al_vector_size(&joysticks); i++) {
281 ALLEGRO_JOYSTICK_SDL *joy = *(ALLEGRO_JOYSTICK_SDL **)_al_vector_ref(&joysticks, i);
282 if (joy->sdl) {
283 SDL_JoystickClose(joy->sdl);
284 joy->sdl = NULL;
285 }
286 if (joy->sdl_gc) {
287 SDL_GameControllerClose(joy->sdl_gc);
288 joy->sdl_gc = NULL;
289 }
290 _al_destroy_joystick_info(&joy->allegro.info);
291 /* Note that we deliberately keep the joystick id as is, so we can reuse it. */
292 }
293 }
294
295 static bool sdl_init_joystick(void)
296 {
297 num_joysticks = SDL_NumJoysticks();
298 for (int i = 0; i < num_joysticks; i++) {
299 ALLEGRO_JOYSTICK_SDL *joy = get_or_insert_joystick(SDL_JoystickGetDeviceInstanceID(i));
300 SDL_JoystickGUID sdl_guid = SDL_JoystickGetDeviceGUID(i);
301 memcpy(&joy->allegro.info.guid, &sdl_guid, sizeof(ALLEGRO_JOYSTICK_GUID));
302
303 if (SDL_IsGameController(i) && !compat_5_2_10()) {
304 joy->sdl_gc = SDL_GameControllerOpen(i);
305 _al_fill_gamepad_info(&joy->allegro.info);
306 SDL_GameControllerEventState(SDL_ENABLE);
307 continue;
308 }
309
310 joy->sdl = SDL_JoystickOpen(i);
311 _AL_JOYSTICK_INFO *info = &joy->allegro.info;
312 int an = SDL_JoystickNumAxes(joy->sdl);
313 int a;
314 info->num_sticks = an / 2;
315 for (a = 0; a < an; a++) {
316 info->stick[a / 2].num_axes = 2;
317 info->stick[a / 2].name = _al_strdup("stick");
318 info->stick[a / 2].axis[0].name = _al_strdup("X");
319 info->stick[a / 2].axis[1].name = _al_strdup("Y");
320 }
321
322 int bn = SDL_JoystickNumButtons(joy->sdl);
323 info->num_buttons = bn;
324 int b;
325 for (b = 0; b < bn; b++) {
326 info->button[b].name = _al_strdup(SDL_IsGameController(i) ?
327 SDL_GameControllerGetStringForButton(b) : "button");
328 }
329 SDL_JoystickEventState(SDL_ENABLE);
330 }
331 return true;
332 }
333
334 static void sdl_exit_joystick(void)
335 {
336 clear_joysticks();
337 num_joysticks = 0;
338 _al_vector_free(&joysticks);
339 }
340
341 static bool sdl_reconfigure_joysticks(void)
342 {
343 clear_joysticks();
344 return sdl_init_joystick();
345 }
346
347 static int sdl_num_joysticks(void)
348 {
349 return num_joysticks;
350 }
351
352 static ALLEGRO_JOYSTICK *sdl_get_joystick(int joyn)
353 {
354 for (int i = 0; i < (int)_al_vector_size(&joysticks); i++) {
355 ALLEGRO_JOYSTICK_SDL *joy = *(ALLEGRO_JOYSTICK_SDL **)_al_vector_ref(&joysticks, i);
356 if (SDL_JoystickFromInstanceID(joy->id)) {
357 if (joyn == 0)
358 return &joy->allegro;
359 joyn--;
360 }
361 }
362 return NULL;
363 }
364
365 static void sdl_release_joystick(ALLEGRO_JOYSTICK *joy)
366 {
367 ASSERT(joy);
368 }
369
370 static void sdl_get_joystick_state(ALLEGRO_JOYSTICK *joy,
371 ALLEGRO_JOYSTICK_STATE *ret_state)
372 {
373 ALLEGRO_SYSTEM_INTERFACE *s = _al_sdl_system_driver();
374 s->heartbeat();
375
376 #define BUTTON(x) ((x) * 32767)
377 #define AXIS(x) ((x) / 32768.0)
378
379 ALLEGRO_JOYSTICK_SDL *joy_sdl = get_joystick_from_allegro(joy);
380 if (joy->info.type == ALLEGRO_JOYSTICK_TYPE_GAMEPAD) {
381 SDL_GameController *sdl_gc = joy_sdl->sdl_gc;
382 ret_state->stick[ALLEGRO_GAMEPAD_STICK_DPAD].axis[0] = SDL_GameControllerGetButton(sdl_gc, SDL_CONTROLLER_BUTTON_DPAD_RIGHT)
383 - SDL_GameControllerGetButton(sdl_gc, SDL_CONTROLLER_BUTTON_DPAD_LEFT);
384 ret_state->stick[ALLEGRO_GAMEPAD_STICK_DPAD].axis[1] = SDL_GameControllerGetButton(sdl_gc, SDL_CONTROLLER_BUTTON_DPAD_DOWN)
385 - SDL_GameControllerGetButton(sdl_gc, SDL_CONTROLLER_BUTTON_DPAD_UP);
386 ret_state->stick[ALLEGRO_GAMEPAD_STICK_LEFT_THUMB].axis[0] = AXIS(SDL_GameControllerGetAxis(sdl_gc, SDL_CONTROLLER_AXIS_LEFTX));
387 ret_state->stick[ALLEGRO_GAMEPAD_STICK_LEFT_THUMB].axis[1] = AXIS(SDL_GameControllerGetAxis(sdl_gc, SDL_CONTROLLER_AXIS_LEFTY));
388 ret_state->stick[ALLEGRO_GAMEPAD_STICK_RIGHT_THUMB].axis[0] = AXIS(SDL_GameControllerGetAxis(sdl_gc, SDL_CONTROLLER_AXIS_RIGHTX));
389 ret_state->stick[ALLEGRO_GAMEPAD_STICK_RIGHT_THUMB].axis[1] = AXIS(SDL_GameControllerGetAxis(sdl_gc, SDL_CONTROLLER_AXIS_RIGHTY));
390 ret_state->stick[ALLEGRO_GAMEPAD_STICK_LEFT_TRIGGER].axis[0] = AXIS(SDL_GameControllerGetAxis(sdl_gc, SDL_CONTROLLER_AXIS_TRIGGERLEFT));
391 ret_state->stick[ALLEGRO_GAMEPAD_STICK_RIGHT_TRIGGER].axis[0] = AXIS(SDL_GameControllerGetAxis(sdl_gc, SDL_CONTROLLER_AXIS_TRIGGERRIGHT));
392
393 ret_state->button[ALLEGRO_GAMEPAD_BUTTON_A] = BUTTON(SDL_GameControllerGetButton(sdl_gc, SDL_CONTROLLER_BUTTON_A));
394 ret_state->button[ALLEGRO_GAMEPAD_BUTTON_B] = BUTTON(SDL_GameControllerGetButton(sdl_gc, SDL_CONTROLLER_BUTTON_B));
395 ret_state->button[ALLEGRO_GAMEPAD_BUTTON_X] = BUTTON(SDL_GameControllerGetButton(sdl_gc, SDL_CONTROLLER_BUTTON_X));
396 ret_state->button[ALLEGRO_GAMEPAD_BUTTON_Y] = BUTTON(SDL_GameControllerGetButton(sdl_gc, SDL_CONTROLLER_BUTTON_Y));
397 ret_state->button[ALLEGRO_GAMEPAD_BUTTON_BACK] = BUTTON(SDL_GameControllerGetButton(sdl_gc, SDL_CONTROLLER_BUTTON_BACK));
398 ret_state->button[ALLEGRO_GAMEPAD_BUTTON_GUIDE] = BUTTON(SDL_GameControllerGetButton(sdl_gc, SDL_CONTROLLER_BUTTON_GUIDE));
399 ret_state->button[ALLEGRO_GAMEPAD_BUTTON_START] = BUTTON(SDL_GameControllerGetButton(sdl_gc, SDL_CONTROLLER_BUTTON_START));
400 ret_state->button[ALLEGRO_GAMEPAD_BUTTON_LEFT_SHOULDER] = BUTTON(SDL_GameControllerGetButton(sdl_gc, SDL_CONTROLLER_BUTTON_LEFTSHOULDER));
401 ret_state->button[ALLEGRO_GAMEPAD_BUTTON_RIGHT_SHOULDER] = BUTTON(SDL_GameControllerGetButton(sdl_gc, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER));
402 ret_state->button[ALLEGRO_GAMEPAD_BUTTON_LEFT_THUMB] = BUTTON(SDL_GameControllerGetButton(sdl_gc, SDL_CONTROLLER_BUTTON_LEFTSTICK));
403 ret_state->button[ALLEGRO_GAMEPAD_BUTTON_RIGHT_THUMB] = BUTTON(SDL_GameControllerGetButton(sdl_gc, SDL_CONTROLLER_BUTTON_RIGHTSTICK));
404 }
405 else {
406 SDL_Joystick *sdl = joy_sdl->sdl;
407 int an = SDL_JoystickNumAxes(sdl);
408 int i;
409 for (i = 0; i < an; i++) {
410 ret_state->stick[i / 2].axis[i % 2] = AXIS(SDL_JoystickGetAxis(sdl, i));
411 }
412 int bn = SDL_JoystickNumButtons(sdl);
413 for (i = 0; i < bn; i++) {
414 ret_state->button[i] = BUTTON(SDL_JoystickGetButton(sdl, i));
415 }
416 }
417
418 #undef AXIS
419 #undef BUTTON
420
421 }
422
423 static const char *sdl_get_name(ALLEGRO_JOYSTICK *joy)
424 {
425 ALLEGRO_JOYSTICK_SDL *joy_sdl = get_joystick_from_allegro(joy);
426 if (joy_sdl->sdl)
427 return SDL_JoystickName(joy_sdl->sdl);
428 if (joy_sdl->sdl_gc)
429 return SDL_GameControllerName(joy_sdl->sdl_gc);
430 return NULL;
431 }
432
433 static bool sdl_get_active(ALLEGRO_JOYSTICK *joy)
434 {
435 ALLEGRO_JOYSTICK_SDL *joy_sdl = get_joystick_from_allegro(joy);
436 if (joy_sdl->sdl)
437 return SDL_JoystickGetAttached(joy_sdl->sdl);
438 if (joy_sdl->sdl_gc)
439 return SDL_GameControllerGetAttached(joy_sdl->sdl_gc);
440 return false;
441 }
442
443 ALLEGRO_JOYSTICK_DRIVER *_al_sdl_joystick_driver(void)
444 {
445 if (vt)
446 return vt;
447
448 vt = al_calloc(1, sizeof *vt);
449 vt->joydrv_id = AL_ID('S','D','L','2');
450 vt->joydrv_name = "SDL2 Joystick";
451 vt->joydrv_desc = "SDL2 Joystick";
452 vt->joydrv_ascii_name = "SDL2 Joystick";
453 vt->init_joystick = sdl_init_joystick;
454 vt->exit_joystick = sdl_exit_joystick;
455 vt->reconfigure_joysticks = sdl_reconfigure_joysticks;
456 vt->num_joysticks = sdl_num_joysticks;
457 vt->get_joystick = sdl_get_joystick;
458 vt->release_joystick = sdl_release_joystick;
459 vt->get_joystick_state = sdl_get_joystick_state;;
460 vt->get_name = sdl_get_name;
461 vt->get_active = sdl_get_active;
462
463 return vt;
464 }