/
SDL_gamecontroller.c
1228 lines (1057 loc) · 38.3 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
/*
Simple DirectMedia Layer
Copyright (C) 1997-2014 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "../SDL_internal.h"
/* This is the game controller API for Simple DirectMedia Layer */
#include "SDL_events.h"
#include "SDL_assert.h"
#include "SDL_sysjoystick.h"
#include "SDL_hints.h"
#include "SDL_gamecontrollerdb.h"
#if !SDL_EVENTS_DISABLED
#include "../events/SDL_events_c.h"
#endif
#define ABS(_x) ((_x) < 0 ? -(_x) : (_x))
#define SDL_CONTROLLER_PLATFORM_FIELD "platform:"
/* a list of currently opened game controllers */
static SDL_GameController *SDL_gamecontrollers = NULL;
/* keep track of the hat and mask value that transforms this hat movement into a button/axis press */
struct _SDL_HatMapping
{
int hat;
Uint8 mask;
};
#define k_nMaxReverseEntries 20
/**
* We are encoding the "HAT" as 0xhm. where h == hat ID and m == mask
* MAX 4 hats supported
*/
#define k_nMaxHatEntries 0x3f + 1
/* our in memory mapping db between joystick objects and controller mappings */
struct _SDL_ControllerMapping
{
SDL_JoystickGUID guid;
const char *name;
/* mapping of axis/button id to controller version */
int axes[SDL_CONTROLLER_AXIS_MAX];
int buttonasaxis[SDL_CONTROLLER_AXIS_MAX];
int buttons[SDL_CONTROLLER_BUTTON_MAX];
int axesasbutton[SDL_CONTROLLER_BUTTON_MAX];
struct _SDL_HatMapping hatasbutton[SDL_CONTROLLER_BUTTON_MAX];
/* reverse mapping, joystick indices to buttons */
SDL_GameControllerAxis raxes[k_nMaxReverseEntries];
SDL_GameControllerAxis rbuttonasaxis[k_nMaxReverseEntries];
SDL_GameControllerButton rbuttons[k_nMaxReverseEntries];
SDL_GameControllerButton raxesasbutton[k_nMaxReverseEntries];
SDL_GameControllerButton rhatasbutton[k_nMaxHatEntries];
};
/* our hard coded list of mapping support */
typedef struct _ControllerMapping_t
{
SDL_JoystickGUID guid;
char *name;
char *mapping;
struct _ControllerMapping_t *next;
} ControllerMapping_t;
static ControllerMapping_t *s_pSupportedControllers = NULL;
static ControllerMapping_t *s_pXInputMapping = NULL;
/* The SDL game controller structure */
struct _SDL_GameController
{
SDL_Joystick *joystick; /* underlying joystick device */
int ref_count;
Uint8 hatState[4]; /* the current hat state for this controller */
struct _SDL_ControllerMapping mapping; /* the mapping object for this controller */
struct _SDL_GameController *next; /* pointer to next game controller we have allocated */
};
int SDL_PrivateGameControllerAxis(SDL_GameController * gamecontroller, SDL_GameControllerAxis axis, Sint16 value);
int SDL_PrivateGameControllerButton(SDL_GameController * gamecontroller, SDL_GameControllerButton button, Uint8 state);
/*
* Event filter to fire controller events from joystick ones
*/
int SDL_GameControllerEventWatcher(void *userdata, SDL_Event * event)
{
112
switch(event->type) {
113
114
115
116
case SDL_JOYAXISMOTION:
{
SDL_GameController *controllerlist;
117
if (event->jaxis.axis >= k_nMaxReverseEntries) break;
118
119
controllerlist = SDL_gamecontrollers;
120
121
122
while (controllerlist) {
if (controllerlist->joystick->instance_id == event->jaxis.which) {
if (controllerlist->mapping.raxes[event->jaxis.axis] >= 0) /* simple axis to axis, send it through */ {
123
124
SDL_GameControllerAxis axis = controllerlist->mapping.raxes[event->jaxis.axis];
Sint16 value = event->jaxis.value;
125
switch (axis) {
126
127
128
129
130
131
132
case SDL_CONTROLLER_AXIS_TRIGGERLEFT:
case SDL_CONTROLLER_AXIS_TRIGGERRIGHT:
/* Shift it to be 0 - 32767. */
value = value / 2 + 16384;
default:
break;
}
133
134
135
SDL_PrivateGameControllerAxis(controllerlist, axis, value);
} else if (controllerlist->mapping.raxesasbutton[event->jaxis.axis] >= 0) { /* simulate an axis as a button */
SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.raxesasbutton[event->jaxis.axis], ABS(event->jaxis.value) > 32768/2 ? SDL_PRESSED : SDL_RELEASED);
136
137
138
139
140
141
142
143
144
145
146
147
}
break;
}
controllerlist = controllerlist->next;
}
}
break;
case SDL_JOYBUTTONDOWN:
case SDL_JOYBUTTONUP:
{
SDL_GameController *controllerlist;
148
if (event->jbutton.button >= k_nMaxReverseEntries) break;
149
150
controllerlist = SDL_gamecontrollers;
151
152
153
154
155
156
while (controllerlist) {
if (controllerlist->joystick->instance_id == event->jbutton.which) {
if (controllerlist->mapping.rbuttons[event->jbutton.button] >= 0) { /* simple button as button */
SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rbuttons[event->jbutton.button], event->jbutton.state);
} else if (controllerlist->mapping.rbuttonasaxis[event->jbutton.button] >= 0) { /* an button pretending to be an axis */
SDL_PrivateGameControllerAxis(controllerlist, controllerlist->mapping.rbuttonasaxis[event->jbutton.button], event->jbutton.state > 0 ? 32767 : 0);
157
158
159
160
161
162
163
164
165
166
167
}
break;
}
controllerlist = controllerlist->next;
}
}
break;
case SDL_JOYHATMOTION:
{
SDL_GameController *controllerlist;
168
if (event->jhat.hat >= 4) break;
169
170
controllerlist = SDL_gamecontrollers;
171
172
while (controllerlist) {
if (controllerlist->joystick->instance_id == event->jhat.which) {
173
174
175
176
177
178
Uint8 bSame = controllerlist->hatState[event->jhat.hat] & event->jhat.value;
/* Get list of removed bits (button release) */
Uint8 bChanged = controllerlist->hatState[event->jhat.hat] ^ bSame;
/* the hat idx in the high nibble */
int bHighHat = event->jhat.hat << 4;
179
180
181
182
183
184
185
186
if (bChanged & SDL_HAT_DOWN)
SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_DOWN], SDL_RELEASED);
if (bChanged & SDL_HAT_UP)
SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_UP], SDL_RELEASED);
if (bChanged & SDL_HAT_LEFT)
SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_LEFT], SDL_RELEASED);
if (bChanged & SDL_HAT_RIGHT)
SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_RIGHT], SDL_RELEASED);
187
188
189
190
/* Get list of added bits (button press) */
bChanged = event->jhat.value ^ bSame;
191
192
193
194
195
196
197
198
if (bChanged & SDL_HAT_DOWN)
SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_DOWN], SDL_PRESSED);
if (bChanged & SDL_HAT_UP)
SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_UP], SDL_PRESSED);
if (bChanged & SDL_HAT_LEFT)
SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_LEFT], SDL_PRESSED);
if (bChanged & SDL_HAT_RIGHT)
SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_RIGHT], SDL_PRESSED);
199
200
201
202
203
204
205
206
207
208
209
210
/* update our state cache */
controllerlist->hatState[event->jhat.hat] = event->jhat.value;
break;
}
controllerlist = controllerlist->next;
}
}
break;
case SDL_JOYDEVICEADDED:
{
211
if (SDL_IsGameController(event->jdevice.which)) {
212
213
214
215
216
217
218
219
220
221
SDL_Event deviceevent;
deviceevent.type = SDL_CONTROLLERDEVICEADDED;
deviceevent.cdevice.which = event->jdevice.which;
SDL_PushEvent(&deviceevent);
}
}
break;
case SDL_JOYDEVICEREMOVED:
{
SDL_GameController *controllerlist = SDL_gamecontrollers;
222
223
while (controllerlist) {
if (controllerlist->joystick->instance_id == event->jdevice.which) {
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
SDL_Event deviceevent;
deviceevent.type = SDL_CONTROLLERDEVICEREMOVED;
deviceevent.cdevice.which = event->jdevice.which;
SDL_PushEvent(&deviceevent);
break;
}
controllerlist = controllerlist->next;
}
}
break;
default:
break;
}
return 1;
}
/*
* Helper function to scan the mappings database for a controller with the specified GUID
*/
ControllerMapping_t *SDL_PrivateGetControllerMappingForGUID(SDL_JoystickGUID *guid)
{
ControllerMapping_t *pSupportedController = s_pSupportedControllers;
247
248
while (pSupportedController) {
if (SDL_memcmp(guid, &pSupportedController->guid, sizeof(*guid)) == 0) {
249
250
251
252
253
254
255
256
257
258
259
260
return pSupportedController;
}
pSupportedController = pSupportedController->next;
}
return NULL;
}
/*
* Helper function to determine pre-calculated offset to certain joystick mappings
*/
ControllerMapping_t *SDL_PrivateGetControllerMapping(int device_index)
{
261
if (SDL_SYS_IsXInputGamepad_DeviceIndex(device_index) && s_pXInputMapping) {
262
263
264
265
return s_pXInputMapping;
}
else
{
266
SDL_JoystickGUID jGUID = SDL_JoystickGetDeviceGUID(device_index);
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
return SDL_PrivateGetControllerMappingForGUID(&jGUID);
}
}
static const char* map_StringForControllerAxis[] = {
"leftx",
"lefty",
"rightx",
"righty",
"lefttrigger",
"righttrigger",
NULL
};
/*
* convert a string to its enum equivalent
*/
284
SDL_GameControllerAxis SDL_GameControllerGetAxisFromString(const char *pchString)
285
286
{
int entry;
287
if (!pchString || !pchString[0])
288
289
return SDL_CONTROLLER_AXIS_INVALID;
290
291
for (entry = 0; map_StringForControllerAxis[entry]; ++entry) {
if (!SDL_strcasecmp(pchString, map_StringForControllerAxis[entry]))
292
293
294
295
296
297
298
299
return entry;
}
return SDL_CONTROLLER_AXIS_INVALID;
}
/*
* convert an enum to its string equivalent
*/
300
const char* SDL_GameControllerGetStringForAxis(SDL_GameControllerAxis axis)
301
{
302
if (axis > SDL_CONTROLLER_AXIS_INVALID && axis < SDL_CONTROLLER_AXIS_MAX) {
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
return map_StringForControllerAxis[axis];
}
return NULL;
}
static const char* map_StringForControllerButton[] = {
"a",
"b",
"x",
"y",
"back",
"guide",
"start",
"leftstick",
"rightstick",
"leftshoulder",
"rightshoulder",
"dpup",
"dpdown",
"dpleft",
"dpright",
NULL
};
/*
* convert a string to its enum equivalent
*/
330
SDL_GameControllerButton SDL_GameControllerGetButtonFromString(const char *pchString)
331
332
{
int entry;
333
if (!pchString || !pchString[0])
334
335
return SDL_CONTROLLER_BUTTON_INVALID;
336
337
338
for (entry = 0; map_StringForControllerButton[entry]; ++entry) {
if (SDL_strcasecmp(pchString, map_StringForControllerButton[entry]) == 0)
return entry;
339
340
341
342
343
344
345
}
return SDL_CONTROLLER_BUTTON_INVALID;
}
/*
* convert an enum to its string equivalent
*/
346
const char* SDL_GameControllerGetStringForButton(SDL_GameControllerButton axis)
347
{
348
if (axis > SDL_CONTROLLER_BUTTON_INVALID && axis < SDL_CONTROLLER_BUTTON_MAX) {
349
350
351
352
353
354
355
356
return map_StringForControllerButton[axis];
}
return NULL;
}
/*
* given a controller button name and a joystick name update our mapping structure with it
*/
357
void SDL_PrivateGameControllerParseButton(const char *szGameButton, const char *szJoystickButton, struct _SDL_ControllerMapping *pMapping)
358
359
360
361
{
int iSDLButton = 0;
SDL_GameControllerButton button;
SDL_GameControllerAxis axis;
362
363
364
button = SDL_GameControllerGetButtonFromString(szGameButton);
axis = SDL_GameControllerGetAxisFromString(szGameButton);
iSDLButton = SDL_atoi(&szJoystickButton[1]);
365
366
367
368
if (szJoystickButton[0] == 'a') {
if (iSDLButton >= k_nMaxReverseEntries) {
SDL_SetError("Axis index too large: %d", iSDLButton);
369
370
return;
}
371
if (axis != SDL_CONTROLLER_AXIS_INVALID) {
372
373
pMapping->axes[ axis ] = iSDLButton;
pMapping->raxes[ iSDLButton ] = axis;
374
} else if (button != SDL_CONTROLLER_BUTTON_INVALID) {
375
376
pMapping->axesasbutton[ button ] = iSDLButton;
pMapping->raxesasbutton[ iSDLButton ] = button;
377
378
} else {
SDL_assert(!"How did we get here?");
379
380
}
381
382
383
} else if (szJoystickButton[0] == 'b') {
if (iSDLButton >= k_nMaxReverseEntries) {
SDL_SetError("Button index too large: %d", iSDLButton);
384
385
return;
}
386
if (button != SDL_CONTROLLER_BUTTON_INVALID) {
387
388
pMapping->buttons[ button ] = iSDLButton;
pMapping->rbuttons[ iSDLButton ] = button;
389
} else if (axis != SDL_CONTROLLER_AXIS_INVALID) {
390
391
pMapping->buttonasaxis[ axis ] = iSDLButton;
pMapping->rbuttonasaxis[ iSDLButton ] = axis;
392
393
} else {
SDL_assert(!"How did we get here?");
394
}
395
396
397
} else if (szJoystickButton[0] == 'h') {
int hat = SDL_atoi(&szJoystickButton[1]);
int mask = SDL_atoi(&szJoystickButton[3]);
398
if (hat >= 4) {
399
SDL_SetError("Hat index too large: %d", iSDLButton);
400
401
}
402
if (button != SDL_CONTROLLER_BUTTON_INVALID) {
403
404
405
406
407
int ridx;
pMapping->hatasbutton[ button ].hat = hat;
pMapping->hatasbutton[ button ].mask = mask;
ridx = (hat << 4) | mask;
pMapping->rhatasbutton[ ridx ] = button;
408
409
410
411
} else if (axis != SDL_CONTROLLER_AXIS_INVALID) {
SDL_assert(!"Support hat as axis");
} else {
SDL_assert(!"How did we get here?");
412
413
414
415
416
417
418
419
420
}
}
}
/*
* given a controller mapping string update our mapping object
*/
static void
421
SDL_PrivateGameControllerParseControllerConfigString(struct _SDL_ControllerMapping *pMapping, const char *pchString)
422
423
424
425
426
427
428
{
char szGameButton[20];
char szJoystickButton[20];
SDL_bool bGameButton = SDL_TRUE;
int i = 0;
const char *pchPos = pchString;
429
430
SDL_memset(szGameButton, 0x0, sizeof(szGameButton));
SDL_memset(szJoystickButton, 0x0, sizeof(szJoystickButton));
431
432
433
while (pchPos && *pchPos) {
if (*pchPos == ':') {
434
435
i = 0;
bGameButton = SDL_FALSE;
436
} else if (*pchPos == ' ') {
437
438
} else if (*pchPos == ',') {
439
440
i = 0;
bGameButton = SDL_TRUE;
441
442
443
SDL_PrivateGameControllerParseButton(szGameButton, szJoystickButton, pMapping);
SDL_memset(szGameButton, 0x0, sizeof(szGameButton));
SDL_memset(szJoystickButton, 0x0, sizeof(szJoystickButton));
444
445
446
447
} else if (bGameButton) {
if (i >= sizeof(szGameButton)) {
SDL_SetError("Button name too large: %s", szGameButton);
448
449
450
451
return;
}
szGameButton[i] = *pchPos;
i++;
452
453
454
} else {
if (i >= sizeof(szJoystickButton)) {
SDL_SetError("Joystick button name too large: %s", szJoystickButton);
455
456
457
458
459
460
461
462
return;
}
szJoystickButton[i] = *pchPos;
i++;
}
pchPos++;
}
463
SDL_PrivateGameControllerParseButton(szGameButton, szJoystickButton, pMapping);
464
465
466
467
468
469
}
/*
* Make a new button mapping struct
*/
470
void SDL_PrivateLoadButtonMapping(struct _SDL_ControllerMapping *pMapping, SDL_JoystickGUID guid, const char *pchName, const char *pchMapping)
471
472
473
474
475
476
477
{
int j;
pMapping->guid = guid;
pMapping->name = pchName;
/* set all the button mappings to non defaults */
478
for (j = 0; j < SDL_CONTROLLER_AXIS_MAX; j++) {
479
480
481
pMapping->axes[j] = -1;
pMapping->buttonasaxis[j] = -1;
}
482
for (j = 0; j < SDL_CONTROLLER_BUTTON_MAX; j++) {
483
484
485
486
487
pMapping->buttons[j] = -1;
pMapping->axesasbutton[j] = -1;
pMapping->hatasbutton[j].hat = -1;
}
488
for (j = 0; j < k_nMaxReverseEntries; j++) {
489
490
491
492
493
494
pMapping->raxes[j] = SDL_CONTROLLER_AXIS_INVALID;
pMapping->rbuttonasaxis[j] = SDL_CONTROLLER_AXIS_INVALID;
pMapping->rbuttons[j] = SDL_CONTROLLER_BUTTON_INVALID;
pMapping->raxesasbutton[j] = SDL_CONTROLLER_BUTTON_INVALID;
}
495
for (j = 0; j < k_nMaxHatEntries; j++) {
496
497
498
pMapping->rhatasbutton[j] = SDL_CONTROLLER_BUTTON_INVALID;
}
499
SDL_PrivateGameControllerParseControllerConfigString(pMapping, pchMapping);
500
501
502
503
504
505
}
/*
* grab the guid string from a mapping string
*/
506
char *SDL_PrivateGetControllerGUIDFromMappingString(const char *pMapping)
507
{
508
509
510
511
const char *pFirstComma = SDL_strchr(pMapping, ',');
if (pFirstComma) {
char *pchGUID = SDL_malloc(pFirstComma - pMapping + 1);
if (!pchGUID) {
512
513
514
SDL_OutOfMemory();
return NULL;
}
515
SDL_memcpy(pchGUID, pMapping, pFirstComma - pMapping);
516
517
518
519
520
521
522
523
524
525
pchGUID[ pFirstComma - pMapping ] = 0;
return pchGUID;
}
return NULL;
}
/*
* grab the name string from a mapping string
*/
526
char *SDL_PrivateGetControllerNameFromMappingString(const char *pMapping)
527
528
529
530
{
const char *pFirstComma, *pSecondComma;
char *pchName;
531
532
pFirstComma = SDL_strchr(pMapping, ',');
if (!pFirstComma)
533
534
return NULL;
535
536
pSecondComma = SDL_strchr(pFirstComma + 1, ',');
if (!pSecondComma)
537
538
return NULL;
539
540
pchName = SDL_malloc(pSecondComma - pFirstComma);
if (!pchName) {
541
542
543
SDL_OutOfMemory();
return NULL;
}
544
SDL_memcpy(pchName, pFirstComma + 1, pSecondComma - pFirstComma);
545
546
547
548
549
550
551
552
pchName[ pSecondComma - pFirstComma - 1 ] = 0;
return pchName;
}
/*
* grab the button mapping string from a mapping string
*/
553
char *SDL_PrivateGetControllerMappingFromMappingString(const char *pMapping)
554
555
556
{
const char *pFirstComma, *pSecondComma;
557
558
pFirstComma = SDL_strchr(pMapping, ',');
if (!pFirstComma)
559
560
return NULL;
561
562
pSecondComma = SDL_strchr(pFirstComma + 1, ',');
if (!pSecondComma)
563
564
565
566
567
return NULL;
return SDL_strdup(pSecondComma + 1); /* mapping is everything after the 3rd comma */
}
568
void SDL_PrivateGameControllerRefreshMapping(ControllerMapping_t *pControllerMapping)
569
570
{
SDL_GameController *gamecontrollerlist = SDL_gamecontrollers;
571
572
while (gamecontrollerlist) {
if (!SDL_memcmp(&gamecontrollerlist->mapping.guid, &pControllerMapping->guid, sizeof(pControllerMapping->guid))) {
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
SDL_Event event;
event.type = SDL_CONTROLLERDEVICEREMAPPED;
event.cdevice.which = gamecontrollerlist->joystick->instance_id;
SDL_PushEvent(&event);
/* Not really threadsafe. Should this lock access within SDL_GameControllerEventWatcher? */
SDL_PrivateLoadButtonMapping(&gamecontrollerlist->mapping, pControllerMapping->guid, pControllerMapping->name, pControllerMapping->mapping);
}
gamecontrollerlist = gamecontrollerlist->next;
}
}
/*
* Add or update an entry into the Mappings Database
*/
int
590
SDL_GameControllerAddMappingsFromRW(SDL_RWops * rw, int freerw)
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
{
const char *platform = SDL_GetPlatform();
int controllers = 0;
char *buf, *line, *line_end, *tmp, *comma, line_platform[64];
size_t db_size, platform_len;
if (rw == NULL) {
return SDL_SetError("Invalid RWops");
}
db_size = (size_t)SDL_RWsize(rw);
buf = (char *)SDL_malloc(db_size + 1);
if (buf == NULL) {
if (freerw) {
SDL_RWclose(rw);
}
return SDL_SetError("Could allocate space to not read DB into memory");
}
if (SDL_RWread(rw, buf, db_size, 1) != 1) {
if (freerw) {
SDL_RWclose(rw);
}
SDL_free(buf);
return SDL_SetError("Could not read DB");
}
if (freerw) {
SDL_RWclose(rw);
}
buf[db_size] = '\0';
line = buf;
while (line < buf + db_size) {
626
line_end = SDL_strchr(line, '\n');
627
628
if (line_end != NULL) {
*line_end = '\0';
629
} else {
630
631
632
633
634
line_end = buf + db_size;
}
/* Extract and verify the platform */
tmp = SDL_strstr(line, SDL_CONTROLLER_PLATFORM_FIELD);
635
if (tmp != NULL) {
636
637
638
639
640
641
tmp += SDL_strlen(SDL_CONTROLLER_PLATFORM_FIELD);
comma = SDL_strchr(tmp, ',');
if (comma != NULL) {
platform_len = comma - tmp + 1;
if (platform_len + 1 < SDL_arraysize(line_platform)) {
SDL_strlcpy(line_platform, tmp, platform_len);
642
643
if (SDL_strncasecmp(line_platform, platform, platform_len) == 0 &&
SDL_GameControllerAddMapping(line) > 0) {
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
controllers++;
}
}
}
}
line = line_end + 1;
}
SDL_free(buf);
return controllers;
}
/*
* Add or update an entry into the Mappings Database
*/
int
661
SDL_GameControllerAddMapping(const char *mappingString)
662
663
664
665
666
667
668
669
{
char *pchGUID;
char *pchName;
char *pchMapping;
SDL_JoystickGUID jGUID;
ControllerMapping_t *pControllerMapping;
SDL_bool is_xinput_mapping = SDL_FALSE;
670
pchGUID = SDL_PrivateGetControllerGUIDFromMappingString(mappingString);
671
672
673
if (!pchGUID) {
return SDL_SetError("Couldn't parse GUID from %s", mappingString);
}
674
if (!SDL_strcasecmp(pchGUID, "xinput")) {
675
676
677
678
679
is_xinput_mapping = SDL_TRUE;
}
jGUID = SDL_JoystickGetGUIDFromString(pchGUID);
SDL_free(pchGUID);
680
pchName = SDL_PrivateGetControllerNameFromMappingString(mappingString);
681
682
683
684
if (!pchName) {
return SDL_SetError("Couldn't parse name from %s", mappingString);
}
685
pchMapping = SDL_PrivateGetControllerMappingFromMappingString(mappingString);
686
if (!pchMapping) {
687
SDL_free(pchName);
688
689
690
691
692
693
694
return SDL_SetError("Couldn't parse %s", mappingString);
}
pControllerMapping = SDL_PrivateGetControllerMappingForGUID(&jGUID);
if (pControllerMapping) {
/* Update existing mapping */
695
SDL_free(pControllerMapping->name);
696
pControllerMapping->name = pchName;
697
SDL_free(pControllerMapping->mapping);
698
699
pControllerMapping->mapping = pchMapping;
/* refresh open controllers */
700
SDL_PrivateGameControllerRefreshMapping(pControllerMapping);
701
702
return 0;
} else {
703
pControllerMapping = SDL_malloc(sizeof(*pControllerMapping));
704
if (!pControllerMapping) {
705
706
SDL_free(pchName);
SDL_free(pchMapping);
707
708
return SDL_OutOfMemory();
}
709
if (is_xinput_mapping) {
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
s_pXInputMapping = pControllerMapping;
}
pControllerMapping->guid = jGUID;
pControllerMapping->name = pchName;
pControllerMapping->mapping = pchMapping;
pControllerMapping->next = s_pSupportedControllers;
s_pSupportedControllers = pControllerMapping;
return 1;
}
}
/*
* Get the mapping string for this GUID
*/
char *
725
SDL_GameControllerMappingForGUID(SDL_JoystickGUID guid)
726
727
728
729
730
731
732
733
734
{
char *pMappingString = NULL;
ControllerMapping_t *mapping = SDL_PrivateGetControllerMappingForGUID(&guid);
if (mapping) {
char pchGUID[33];
size_t needed;
SDL_JoystickGetGUIDString(guid, pchGUID, sizeof(pchGUID));
/* allocate enough memory for GUID + ',' + name + ',' + mapping + \0 */
needed = SDL_strlen(pchGUID) + 1 + SDL_strlen(mapping->name) + 1 + SDL_strlen(mapping->mapping) + 1;
735
736
pMappingString = SDL_malloc(needed);
SDL_snprintf(pMappingString, needed, "%s,%s,%s", pchGUID, mapping->name, mapping->mapping);
737
738
739
740
741
742
743
744
}
return pMappingString;
}
/*
* Get the mapping string for this device
*/
char *
745
SDL_GameControllerMapping(SDL_GameController * gamecontroller)
746
{
747
return SDL_GameControllerMappingForGUID(gamecontroller->mapping.guid);
748
749
750
751
752
753
}
static void
SDL_GameControllerLoadHints()
{
const char *hint = SDL_GetHint(SDL_HINT_GAMECONTROLLERCONFIG);
754
755
756
if (hint && hint[0]) {
size_t nchHints = SDL_strlen(hint);
char *pUserMappings = SDL_malloc(nchHints + 1);
757
char *pTempMappings = pUserMappings;
758
SDL_memcpy(pUserMappings, hint, nchHints);
759
pUserMappings[nchHints] = '\0';
760
while (pUserMappings) {
761
762
char *pchNewLine = NULL;
763
764
pchNewLine = SDL_strchr(pUserMappings, '\n');
if (pchNewLine)
765
766
*pchNewLine = '\0';
767
SDL_GameControllerAddMapping(pUserMappings);
768
769
if (pchNewLine) {
770
pUserMappings = pchNewLine + 1;
771
} else {
772
pUserMappings = NULL;
773
}
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
}
SDL_free(pTempMappings);
}
}
/*
* Initialize the game controller system, mostly load our DB of controller config mappings
*/
int
SDL_GameControllerInit(void)
{
int i = 0;
const char *pMappingString = NULL;
s_pSupportedControllers = NULL;
pMappingString = s_ControllerMappings[i];
789
790
while (pMappingString) {
SDL_GameControllerAddMapping(pMappingString);
791
792
793
794
795
796
797
798
799
i++;
pMappingString = s_ControllerMappings[i];
}
/* load in any user supplied config */
SDL_GameControllerLoadHints();
/* watch for joy events and fire controller ones if needed */
800
SDL_AddEventWatch(SDL_GameControllerEventWatcher, NULL);
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
/* Send added events for controllers currently attached */
for (i = 0; i < SDL_NumJoysticks(); ++i) {
if (SDL_IsGameController(i)) {
SDL_Event deviceevent;
deviceevent.type = SDL_CONTROLLERDEVICEADDED;
deviceevent.cdevice.which = i;
SDL_PushEvent(&deviceevent);
}
}
return (0);
}
/*
* Get the implementation dependent name of a controller
*/
const char *
SDL_GameControllerNameForIndex(int device_index)
{
ControllerMapping_t *pSupportedController = SDL_PrivateGetControllerMapping(device_index);
823
if (pSupportedController) {
824
825
826
827
828
829
830
831
832
833
834
835
836
return pSupportedController->name;
}
return NULL;
}
/*
* Return 1 if the joystick at this device index is a supported controller
*/
SDL_bool
SDL_IsGameController(int device_index)
{
ControllerMapping_t *pSupportedController = SDL_PrivateGetControllerMapping(device_index);
837
if (pSupportedController) {
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
return SDL_TRUE;
}
return SDL_FALSE;
}
/*
* Open a controller for use - the index passed as an argument refers to
* the N'th controller on the system. This index is the value which will
* identify this controller in future controller events.
*
* This function returns a controller identifier, or NULL if an error occurred.
*/
SDL_GameController *
SDL_GameControllerOpen(int device_index)
{
SDL_GameController *gamecontroller;
SDL_GameController *gamecontrollerlist;
ControllerMapping_t *pSupportedController = NULL;
if ((device_index < 0) || (device_index >= SDL_NumJoysticks())) {
SDL_SetError("There are %d joysticks available", SDL_NumJoysticks());
return (NULL);
}
gamecontrollerlist = SDL_gamecontrollers;
/* If the controller is already open, return it */
865
866
while (gamecontrollerlist) {
if (SDL_SYS_GetInstanceIdOfDeviceIndex(device_index) == gamecontrollerlist->joystick->instance_id) {
867
868
869
870
871
872
873
874
875
gamecontroller = gamecontrollerlist;
++gamecontroller->ref_count;
return (gamecontroller);
}
gamecontrollerlist = gamecontrollerlist->next;
}
/* Find a controller mapping */
pSupportedController = SDL_PrivateGetControllerMapping(device_index);
876
877
if (!pSupportedController) {
SDL_SetError("Couldn't find mapping for device (%d)", device_index);
878
879
880
881
882
883
884
885
886
887
888
889
return (NULL);
}
/* Create and initialize the joystick */
gamecontroller = (SDL_GameController *) SDL_malloc((sizeof *gamecontroller));
if (gamecontroller == NULL) {
SDL_OutOfMemory();
return NULL;
}
SDL_memset(gamecontroller, 0, (sizeof *gamecontroller));
gamecontroller->joystick = SDL_JoystickOpen(device_index);
890
if (!gamecontroller->joystick) {
891
892
893
894
SDL_free(gamecontroller);
return NULL;
}
895
SDL_PrivateLoadButtonMapping(&gamecontroller->mapping, pSupportedController->guid, pSupportedController->name, pSupportedController->mapping);
896
897
898
899
900
901
902
/* Add joystick to list */
++gamecontroller->ref_count;
/* Link the joystick in the list */
gamecontroller->next = SDL_gamecontrollers;
SDL_gamecontrollers = gamecontroller;
903
SDL_SYS_JoystickUpdate(gamecontroller->joystick);
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
return (gamecontroller);
}
/*
* Manually pump for controller updates.
*/
void
SDL_GameControllerUpdate(void)
{
/* Just for API completeness; the joystick API does all the work. */
SDL_JoystickUpdate();
}
/*
* Get the current state of an axis control on a controller
*/
Sint16
SDL_GameControllerGetAxis(SDL_GameController * gamecontroller, SDL_GameControllerAxis axis)
{
925
if (!gamecontroller)
926
927
return 0;
928
929
930
if (gamecontroller->mapping.axes[axis] >= 0) {
Sint16 value = (SDL_JoystickGetAxis(gamecontroller->joystick, gamecontroller->mapping.axes[axis]));
switch (axis) {
931
932
933
934
935
936
937
938
case SDL_CONTROLLER_AXIS_TRIGGERLEFT:
case SDL_CONTROLLER_AXIS_TRIGGERRIGHT:
/* Shift it to be 0 - 32767. */
value = value / 2 + 16384;
default:
break;
}
return value;
939
} else if (gamecontroller->mapping.buttonasaxis[axis] >= 0) {
940
Uint8 value;
941
942
value = SDL_JoystickGetButton(gamecontroller->joystick, gamecontroller->mapping.buttonasaxis[axis]);
if (value > 0)
943
944
945
946
947
948
949
950
951
952
953
954
955
return 32767;
return 0;
}
return 0;
}
/*
* Get the current state of a button on a controller
*/
Uint8
SDL_GameControllerGetButton(SDL_GameController * gamecontroller, SDL_GameControllerButton button)
{
956
if (!gamecontroller)
957
958
return 0;
959
960
961
if (gamecontroller->mapping.buttons[button] >= 0) {
return (SDL_JoystickGetButton(gamecontroller->joystick, gamecontroller->mapping.buttons[button]));
} else if (gamecontroller->mapping.axesasbutton[button] >= 0) {
962
Sint16 value;
963
964
value = SDL_JoystickGetAxis(gamecontroller->joystick, gamecontroller->mapping.axesasbutton[button]);
if (ABS(value) > 32768/2)
965
966
return 1;
return 0;
967
} else if (gamecontroller->mapping.hatasbutton[button].hat >= 0) {
968
Uint8 value;
969
value = SDL_JoystickGetHat(gamecontroller->joystick, gamecontroller->mapping.hatasbutton[button].hat);
970
971
if (value & gamecontroller->mapping.hatasbutton[button].mask)
972
973
974
975
976
977
978
979
980
981
982
983
return 1;
return 0;
}
return 0;
}
/*
* Return if the joystick in question is currently attached to the system,
* \return 0 if not plugged in, 1 if still present.
*/
SDL_bool
984
SDL_GameControllerGetAttached(SDL_GameController * gamecontroller)
985
{
986
if (!gamecontroller)
987
988
989
990
991
992
993
994
995
996
997
998
return SDL_FALSE;
return SDL_JoystickGetAttached(gamecontroller->joystick);
}
/*
* Get the number of multi-dimensional axis controls on a joystick
*/
const char *
SDL_GameControllerName(SDL_GameController * gamecontroller)
{
999
if (!gamecontroller)
1000
return NULL;