/
SDL_windowsjoystick.c
594 lines (490 loc) · 17.1 KB
1
2
/*
Simple DirectMedia Layer
3
Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
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
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"
#if SDL_JOYSTICK_DINPUT || SDL_JOYSTICK_XINPUT
/* DirectInput joystick driver; written by Glenn Maynard, based on Andrei de
* A. Formiga's WINMM driver.
*
* Hats and sliders are completely untested; the app I'm writing this for mostly
* doesn't use them and I don't own any joysticks with them.
*
* We don't bother to use event notification here. It doesn't seem to work
* with polled devices, and it's fine to call IDirectInputDevice8_GetDeviceData and
* let it return 0 events. */
#include "SDL_error.h"
#include "SDL_assert.h"
#include "SDL_events.h"
#include "SDL_timer.h"
#include "SDL_mutex.h"
#include "SDL_joystick.h"
#include "../SDL_sysjoystick.h"
42
#include "../../thread/SDL_systhread.h"
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
#include "../../core/windows/SDL_windows.h"
#if !defined(__WINRT__)
#include <dbt.h>
#endif
#define INITGUID /* Only set here, if set twice will cause mingw32 to break. */
#include "SDL_windowsjoystick_c.h"
#include "SDL_dinputjoystick_c.h"
#include "SDL_xinputjoystick_c.h"
#include "../../haptic/windows/SDL_dinputhaptic_c.h" /* For haptic hot plugging */
#include "../../haptic/windows/SDL_xinputhaptic_c.h" /* For haptic hot plugging */
#ifndef DEVICE_NOTIFY_WINDOW_HANDLE
#define DEVICE_NOTIFY_WINDOW_HANDLE 0x00000000
#endif
/* local variables */
static SDL_bool s_bDeviceAdded = SDL_FALSE;
static SDL_bool s_bDeviceRemoved = SDL_FALSE;
static SDL_cond *s_condJoystickThread = NULL;
static SDL_mutex *s_mutexJoyStickEnum = NULL;
static SDL_Thread *s_threadJoystick = NULL;
static SDL_bool s_bJoystickThreadQuit = SDL_FALSE;
JoyStick_DeviceData *SYS_Joystick; /* array to hold joystick ID values */
static SDL_bool s_bWindowsDeviceChanged = SDL_FALSE;
#ifdef __WINRT__
typedef struct
{
int unused;
} SDL_DeviceNotificationData;
static void
SDL_CleanupDeviceNotification(SDL_DeviceNotificationData *data)
{
}
static int
SDL_CreateDeviceNotification(SDL_DeviceNotificationData *data)
{
return 0;
}
91
92
static SDL_bool
SDL_WaitForDeviceNotification(SDL_DeviceNotificationData *data, SDL_mutex *mutex)
93
{
94
return SDL_FALSE;
95
96
97
98
99
100
101
102
103
104
105
106
}
#else /* !__WINRT__ */
typedef struct
{
HRESULT coinitialized;
WNDCLASSEX wincl;
HWND messageWindow;
HDEVNOTIFY hNotify;
} SDL_DeviceNotificationData;
107
108
#define IDT_SDL_DEVICE_CHANGE_TIMER_1 1200
#define IDT_SDL_DEVICE_CHANGE_TIMER_2 1201
109
110
111
112
113
114
115
116
117
118
119
/* windowproc for our joystick detect thread message only window, to detect any USB device addition/removal */
static LRESULT CALLBACK
SDL_PrivateJoystickDetectProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message) {
case WM_DEVICECHANGE:
switch (wParam) {
case DBT_DEVICEARRIVAL:
case DBT_DEVICEREMOVECOMPLETE:
if (((DEV_BROADCAST_HDR*)lParam)->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE) {
120
121
122
/* notify 300ms and 2 seconds later to ensure all APIs have updated status */
SetTimer(hwnd, IDT_SDL_DEVICE_CHANGE_TIMER_1, 300, NULL);
SetTimer(hwnd, IDT_SDL_DEVICE_CHANGE_TIMER_2, 2000, NULL);
123
124
125
126
}
break;
}
return 0;
127
128
129
130
case WM_TIMER:
KillTimer(hwnd, wParam);
s_bWindowsDeviceChanged = SDL_TRUE;
return 0;
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
}
return DefWindowProc (hwnd, message, wParam, lParam);
}
static void
SDL_CleanupDeviceNotification(SDL_DeviceNotificationData *data)
{
if (data->hNotify)
UnregisterDeviceNotification(data->hNotify);
if (data->messageWindow)
DestroyWindow(data->messageWindow);
UnregisterClass(data->wincl.lpszClassName, data->wincl.hInstance);
if (data->coinitialized == S_OK) {
WIN_CoUninitialize();
}
}
static int
SDL_CreateDeviceNotification(SDL_DeviceNotificationData *data)
{
DEV_BROADCAST_DEVICEINTERFACE dbh;
GUID GUID_DEVINTERFACE_HID = { 0x4D1E55B2L, 0xF16F, 0x11CF, { 0x88, 0xCB, 0x00, 0x11, 0x11, 0x00, 0x00, 0x30 } };
SDL_zerop(data);
data->coinitialized = WIN_CoInitialize();
data->wincl.hInstance = GetModuleHandle(NULL);
data->wincl.lpszClassName = L"Message";
data->wincl.lpfnWndProc = SDL_PrivateJoystickDetectProc; /* This function is called by windows */
data->wincl.cbSize = sizeof (WNDCLASSEX);
if (!RegisterClassEx(&data->wincl)) {
WIN_SetError("Failed to create register class for joystick autodetect");
SDL_CleanupDeviceNotification(data);
return -1;
}
data->messageWindow = (HWND)CreateWindowEx(0, L"Message", NULL, 0, 0, 0, 0, 0, HWND_MESSAGE, NULL, NULL, NULL);
if (!data->messageWindow) {
WIN_SetError("Failed to create message window for joystick autodetect");
SDL_CleanupDeviceNotification(data);
return -1;
}
SDL_zero(dbh);
dbh.dbcc_size = sizeof(dbh);
dbh.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
dbh.dbcc_classguid = GUID_DEVINTERFACE_HID;
data->hNotify = RegisterDeviceNotification(data->messageWindow, &dbh, DEVICE_NOTIFY_WINDOW_HANDLE);
if (!data->hNotify) {
WIN_SetError("Failed to create notify device for joystick autodetect");
SDL_CleanupDeviceNotification(data);
return -1;
}
return 0;
}
194
195
static SDL_bool
SDL_WaitForDeviceNotification(SDL_DeviceNotificationData *data, SDL_mutex *mutex)
196
197
{
MSG msg;
198
int lastret = 1;
199
200
if (!data->messageWindow) {
201
return SDL_FALSE; /* device notifications require a window */
202
203
}
204
205
206
207
SDL_UnlockMutex(mutex);
while (lastret > 0 && s_bWindowsDeviceChanged == SDL_FALSE) {
lastret = GetMessage(&msg, NULL, 0, 0); /* WM_QUIT causes return value of 0 */
if (lastret > 0) {
208
209
210
211
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
212
213
SDL_LockMutex(mutex);
return (lastret != -1) ? SDL_TRUE : SDL_FALSE;
214
215
216
217
218
219
220
221
222
223
224
225
}
#endif /* __WINRT__ */
/* Function/thread to scan the system for joysticks. */
static int
SDL_JoystickThread(void *_data)
{
SDL_DeviceNotificationData notification_data;
#if SDL_JOYSTICK_XINPUT
SDL_bool bOpenedXInputDevices[XUSER_MAX_COUNT];
226
SDL_zeroa(bOpenedXInputDevices);
227
228
229
230
231
232
233
234
235
236
#endif
if (SDL_CreateDeviceNotification(¬ification_data) < 0) {
return -1;
}
SDL_LockMutex(s_mutexJoyStickEnum);
while (s_bJoystickThreadQuit == SDL_FALSE) {
SDL_bool bXInputChanged = SDL_FALSE;
237
if (SDL_WaitForDeviceNotification(¬ification_data, s_mutexJoyStickEnum) == SDL_FALSE) {
238
#if SDL_JOYSTICK_XINPUT
239
240
241
242
243
244
245
246
247
248
249
250
251
/* WM_DEVICECHANGE not working, poll for new XINPUT controllers */
SDL_CondWaitTimeout(s_condJoystickThread, s_mutexJoyStickEnum, 1000);
if (SDL_XINPUT_Enabled() && XINPUTGETCAPABILITIES) {
/* scan for any change in XInput devices */
Uint8 userId;
for (userId = 0; userId < XUSER_MAX_COUNT; userId++) {
XINPUT_CAPABILITIES capabilities;
const DWORD result = XINPUTGETCAPABILITIES(userId, XINPUT_FLAG_GAMEPAD, &capabilities);
const SDL_bool available = (result == ERROR_SUCCESS);
if (bOpenedXInputDevices[userId] != available) {
bXInputChanged = SDL_TRUE;
bOpenedXInputDevices[userId] = available;
}
252
253
}
}
254
255
256
#else
/* WM_DEVICECHANGE not working, no XINPUT, no point in keeping thread alive */
break;
257
#endif /* SDL_JOYSTICK_XINPUT */
258
}
259
260
261
262
263
264
265
266
267
268
269
270
271
272
if (s_bWindowsDeviceChanged || bXInputChanged) {
s_bDeviceRemoved = SDL_TRUE;
s_bDeviceAdded = SDL_TRUE;
s_bWindowsDeviceChanged = SDL_FALSE;
}
}
SDL_UnlockMutex(s_mutexJoyStickEnum);
SDL_CleanupDeviceNotification(¬ification_data);
return 1;
}
273
void WINDOWS_AddJoystickDevice(JoyStick_DeviceData *device)
274
275
{
device->send_add_event = SDL_TRUE;
276
device->nInstanceID = SDL_GetNextJoystickInstanceID();
277
278
279
280
281
282
device->pNext = SYS_Joystick;
SYS_Joystick = device;
s_bDeviceAdded = SDL_TRUE;
}
283
284
285
static void WINDOWS_JoystickDetect(void);
static void WINDOWS_JoystickQuit(void);
286
287
288
289
/* Function to scan the system for joysticks.
* Joystick 0 should be the system default joystick.
* It should return 0, or -1 on an unrecoverable fatal error.
*/
290
291
static int
WINDOWS_JoystickInit(void)
292
293
{
if (SDL_DINPUT_JoystickInit() < 0) {
294
WINDOWS_JoystickQuit();
295
296
297
298
return -1;
}
if (SDL_XINPUT_JoystickInit() < 0) {
299
WINDOWS_JoystickQuit();
300
301
302
303
304
305
306
return -1;
}
s_mutexJoyStickEnum = SDL_CreateMutex();
s_condJoystickThread = SDL_CreateCond();
s_bDeviceAdded = SDL_TRUE; /* force a scan of the system for joysticks this first time */
307
WINDOWS_JoystickDetect();
308
309
310
if (!s_threadJoystick) {
/* spin up the thread to detect hotplug of devices */
311
312
s_bJoystickThreadQuit = SDL_FALSE;
s_threadJoystick = SDL_CreateThreadInternal(SDL_JoystickThread, "SDL_joystick", 64 * 1024, NULL);
313
}
314
return 0;
315
316
317
}
/* return the number of joysticks that are connected right now */
318
319
static int
WINDOWS_JoystickGetCount(void)
320
321
322
323
324
325
326
327
328
329
330
331
{
int nJoysticks = 0;
JoyStick_DeviceData *device = SYS_Joystick;
while (device) {
nJoysticks++;
device = device->pNext;
}
return nJoysticks;
}
/* detect any new joysticks being inserted into the system */
332
333
static void
WINDOWS_JoystickDetect(void)
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
{
JoyStick_DeviceData *pCurList = NULL;
/* only enum the devices if the joystick thread told us something changed */
if (!s_bDeviceAdded && !s_bDeviceRemoved) {
return; /* thread hasn't signaled, nothing to do right now. */
}
SDL_LockMutex(s_mutexJoyStickEnum);
s_bDeviceAdded = SDL_FALSE;
s_bDeviceRemoved = SDL_FALSE;
pCurList = SYS_Joystick;
SYS_Joystick = NULL;
/* Look for DirectInput joysticks, wheels, head trackers, gamepads, etc.. */
SDL_DINPUT_JoystickDetect(&pCurList);
/* Look for XInput devices. Do this last, so they're first in the final list. */
SDL_XINPUT_JoystickDetect(&pCurList);
SDL_UnlockMutex(s_mutexJoyStickEnum);
while (pCurList) {
JoyStick_DeviceData *pListNext = NULL;
if (pCurList->bXInputDevice) {
362
#if SDL_HAPTIC_XINPUT
363
SDL_XINPUT_MaybeRemoveDevice(pCurList->XInputUserId);
364
#endif
365
} else {
366
#if SDL_HAPTIC_DINPUT
367
SDL_DINPUT_MaybeRemoveDevice(&pCurList->dxdevice);
368
#endif
369
370
}
371
SDL_PrivateJoystickRemoved(pCurList->nInstanceID);
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
pListNext = pCurList->pNext;
SDL_free(pCurList->joystickname);
SDL_free(pCurList);
pCurList = pListNext;
}
if (s_bDeviceAdded) {
JoyStick_DeviceData *pNewJoystick;
int device_index = 0;
s_bDeviceAdded = SDL_FALSE;
pNewJoystick = SYS_Joystick;
while (pNewJoystick) {
if (pNewJoystick->send_add_event) {
if (pNewJoystick->bXInputDevice) {
387
#if SDL_HAPTIC_XINPUT
388
SDL_XINPUT_MaybeAddDevice(pNewJoystick->XInputUserId);
389
#endif
390
} else {
391
#if SDL_HAPTIC_DINPUT
392
SDL_DINPUT_MaybeAddDevice(&pNewJoystick->dxdevice);
393
#endif
394
395
}
396
SDL_PrivateJoystickAdded(pNewJoystick->nInstanceID);
397
398
399
400
401
402
403
404
405
406
pNewJoystick->send_add_event = SDL_FALSE;
}
device_index++;
pNewJoystick = pNewJoystick->pNext;
}
}
}
/* Function to get the device-dependent name of a joystick */
407
408
static const char *
WINDOWS_JoystickGetDeviceName(int device_index)
409
410
{
JoyStick_DeviceData *device = SYS_Joystick;
411
int index;
412
413
for (index = device_index; index > 0; index--)
414
415
416
417
418
device = device->pNext;
return device->joystickname;
}
419
420
421
422
423
424
425
426
427
428
429
430
static int
WINDOWS_JoystickGetDevicePlayerIndex(int device_index)
{
JoyStick_DeviceData *device = SYS_Joystick;
int index;
for (index = device_index; index > 0; index--)
device = device->pNext;
return device->bXInputDevice ? (int)device->XInputUserId : -1;
}
431
432
433
434
435
static void
WINDOWS_JoystickSetDevicePlayerIndex(int device_index, int player_index)
{
}
436
437
438
439
440
441
442
443
444
445
446
447
448
/* return the stable device guid for this device index */
static SDL_JoystickGUID
WINDOWS_JoystickGetDeviceGUID(int device_index)
{
JoyStick_DeviceData *device = SYS_Joystick;
int index;
for (index = device_index; index > 0; index--)
device = device->pNext;
return device->guid;
}
449
/* Function to perform the mapping between current device instance and this joysticks instance id */
450
451
static SDL_JoystickID
WINDOWS_JoystickGetDeviceInstanceID(int device_index)
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
{
JoyStick_DeviceData *device = SYS_Joystick;
int index;
for (index = device_index; index > 0; index--)
device = device->pNext;
return device->nInstanceID;
}
/* Function to open a joystick for use.
The joystick to open is specified by the device index.
This should fill the nbuttons and naxes fields of the joystick structure.
It returns 0, or -1 if there is an error.
*/
467
468
static int
WINDOWS_JoystickOpen(SDL_Joystick * joystick, int device_index)
469
{
470
471
JoyStick_DeviceData *device = SYS_Joystick;
int index;
472
473
474
for (index = device_index; index > 0; index--)
device = device->pNext;
475
476
/* allocate memory for system specific hardware data */
477
joystick->instance_id = device->nInstanceID;
478
479
480
481
482
483
joystick->hwdata =
(struct joystick_hwdata *) SDL_malloc(sizeof(struct joystick_hwdata));
if (joystick->hwdata == NULL) {
return SDL_OutOfMemory();
}
SDL_zerop(joystick->hwdata);
484
joystick->hwdata->guid = device->guid;
485
486
487
if (device->bXInputDevice) {
return SDL_XINPUT_JoystickOpen(joystick, device);
488
} else {
489
return SDL_DINPUT_JoystickOpen(joystick, device);
490
491
492
}
}
493
static int
494
WINDOWS_JoystickRumble(SDL_Joystick * joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
495
496
{
if (joystick->hwdata->bXInputDevice) {
497
return SDL_XINPUT_JoystickRumble(joystick, low_frequency_rumble, high_frequency_rumble);
498
} else {
499
return SDL_DINPUT_JoystickRumble(joystick, low_frequency_rumble, high_frequency_rumble);
500
501
502
503
504
}
}
static void
WINDOWS_JoystickUpdate(SDL_Joystick * joystick)
505
{
506
if (!joystick->hwdata) {
507
508
509
510
511
512
513
514
515
516
517
return;
}
if (joystick->hwdata->bXInputDevice) {
SDL_XINPUT_JoystickUpdate(joystick);
} else {
SDL_DINPUT_JoystickUpdate(joystick);
}
}
/* Function to close a joystick after use */
518
519
static void
WINDOWS_JoystickClose(SDL_Joystick * joystick)
520
521
522
523
524
525
526
527
528
529
530
{
if (joystick->hwdata->bXInputDevice) {
SDL_XINPUT_JoystickClose(joystick);
} else {
SDL_DINPUT_JoystickClose(joystick);
}
SDL_free(joystick->hwdata);
}
/* Function to perform any system-specific joystick related cleanup */
531
532
static void
WINDOWS_JoystickQuit(void)
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
{
JoyStick_DeviceData *device = SYS_Joystick;
while (device) {
JoyStick_DeviceData *device_next = device->pNext;
SDL_free(device->joystickname);
SDL_free(device);
device = device_next;
}
SYS_Joystick = NULL;
if (s_threadJoystick) {
SDL_LockMutex(s_mutexJoyStickEnum);
s_bJoystickThreadQuit = SDL_TRUE;
SDL_CondBroadcast(s_condJoystickThread); /* signal the joystick thread to quit */
SDL_UnlockMutex(s_mutexJoyStickEnum);
549
550
551
#ifndef __WINRT__
PostThreadMessage(SDL_GetThreadID(s_threadJoystick), WM_QUIT, 0, 0);
#endif
552
553
554
555
556
557
558
559
560
561
562
SDL_WaitThread(s_threadJoystick, NULL); /* wait for it to bugger off */
SDL_DestroyMutex(s_mutexJoyStickEnum);
SDL_DestroyCond(s_condJoystickThread);
s_condJoystickThread= NULL;
s_mutexJoyStickEnum = NULL;
s_threadJoystick = NULL;
}
SDL_DINPUT_JoystickQuit();
SDL_XINPUT_JoystickQuit();
563
564
565
s_bDeviceAdded = SDL_FALSE;
s_bDeviceRemoved = SDL_FALSE;
566
567
}
568
569
570
571
572
573
static SDL_bool
WINDOWS_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out)
{
return SDL_FALSE;
}
574
SDL_JoystickDriver SDL_WINDOWS_JoystickDriver =
575
{
576
577
578
579
WINDOWS_JoystickInit,
WINDOWS_JoystickGetCount,
WINDOWS_JoystickDetect,
WINDOWS_JoystickGetDeviceName,
580
WINDOWS_JoystickGetDevicePlayerIndex,
581
WINDOWS_JoystickSetDevicePlayerIndex,
582
583
584
585
586
587
588
WINDOWS_JoystickGetDeviceGUID,
WINDOWS_JoystickGetDeviceInstanceID,
WINDOWS_JoystickOpen,
WINDOWS_JoystickRumble,
WINDOWS_JoystickUpdate,
WINDOWS_JoystickClose,
WINDOWS_JoystickQuit,
589
WINDOWS_JoystickGetGamepadMapping
590
};
591
592
593
594
#endif /* SDL_JOYSTICK_DINPUT || SDL_JOYSTICK_XINPUT */
/* vi: set ts=4 sw=4 expandtab: */