src/joystick/windows/SDL_windowsjoystick.c
author Sam Lantinga
Thu, 09 Aug 2018 16:00:17 -0700
changeset 12088 399cc39583cc
parent 11811 5d94cb6b24d3
child 12090 c3209fca27b2
permissions -rw-r--r--
Added HIDAPI joystick drivers for more consistent support for Xbox, PS4 and Nintendo Switch Pro controller support across platforms.
Added SDL_GameControllerRumble() and SDL_JoystickRumble() for simple force feedback outside of the SDL haptics API
     1 /*
     2   Simple DirectMedia Layer
     3   Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
     4 
     5   This software is provided 'as-is', without any express or implied
     6   warranty.  In no event will the authors be held liable for any damages
     7   arising from the use of this software.
     8 
     9   Permission is granted to anyone to use this software for any purpose,
    10   including commercial applications, and to alter it and redistribute it
    11   freely, subject to the following restrictions:
    12 
    13   1. The origin of this software must not be misrepresented; you must not
    14      claim that you wrote the original software. If you use this software
    15      in a product, an acknowledgment in the product documentation would be
    16      appreciated but is not required.
    17   2. Altered source versions must be plainly marked as such, and must not be
    18      misrepresented as being the original software.
    19   3. This notice may not be removed or altered from any source distribution.
    20 */
    21 #include "../../SDL_internal.h"
    22 
    23 #if SDL_JOYSTICK_DINPUT || SDL_JOYSTICK_XINPUT
    24 
    25 /* DirectInput joystick driver; written by Glenn Maynard, based on Andrei de
    26  * A. Formiga's WINMM driver.
    27  *
    28  * Hats and sliders are completely untested; the app I'm writing this for mostly
    29  * doesn't use them and I don't own any joysticks with them.
    30  *
    31  * We don't bother to use event notification here.  It doesn't seem to work
    32  * with polled devices, and it's fine to call IDirectInputDevice8_GetDeviceData and
    33  * let it return 0 events. */
    34 
    35 #include "SDL_error.h"
    36 #include "SDL_assert.h"
    37 #include "SDL_events.h"
    38 #include "SDL_timer.h"
    39 #include "SDL_mutex.h"
    40 #include "SDL_joystick.h"
    41 #include "../SDL_sysjoystick.h"
    42 #include "../../thread/SDL_systhread.h"
    43 #include "../../core/windows/SDL_windows.h"
    44 #if !defined(__WINRT__)
    45 #include <dbt.h>
    46 #endif
    47 
    48 #define INITGUID /* Only set here, if set twice will cause mingw32 to break. */
    49 #include "SDL_windowsjoystick_c.h"
    50 #include "SDL_dinputjoystick_c.h"
    51 #include "SDL_xinputjoystick_c.h"
    52 
    53 #include "../../haptic/windows/SDL_dinputhaptic_c.h"    /* For haptic hot plugging */
    54 #include "../../haptic/windows/SDL_xinputhaptic_c.h"    /* For haptic hot plugging */
    55 
    56 
    57 #ifndef DEVICE_NOTIFY_WINDOW_HANDLE
    58 #define DEVICE_NOTIFY_WINDOW_HANDLE 0x00000000
    59 #endif
    60 
    61 /* local variables */
    62 static SDL_bool s_bDeviceAdded = SDL_FALSE;
    63 static SDL_bool s_bDeviceRemoved = SDL_FALSE;
    64 static SDL_cond *s_condJoystickThread = NULL;
    65 static SDL_mutex *s_mutexJoyStickEnum = NULL;
    66 static SDL_Thread *s_threadJoystick = NULL;
    67 static SDL_bool s_bJoystickThreadQuit = SDL_FALSE;
    68 
    69 JoyStick_DeviceData *SYS_Joystick;    /* array to hold joystick ID values */
    70 
    71 static SDL_bool s_bWindowsDeviceChanged = SDL_FALSE;
    72 
    73 #ifdef __WINRT__
    74 
    75 typedef struct
    76 {
    77     int unused;
    78 } SDL_DeviceNotificationData;
    79 
    80 static void
    81 SDL_CleanupDeviceNotification(SDL_DeviceNotificationData *data)
    82 {
    83 }
    84 
    85 static int
    86 SDL_CreateDeviceNotification(SDL_DeviceNotificationData *data)
    87 {
    88     return 0;
    89 }
    90 
    91 static SDL_bool
    92 SDL_WaitForDeviceNotification(SDL_DeviceNotificationData *data, SDL_mutex *mutex)
    93 {
    94     return SDL_FALSE;
    95 }
    96 
    97 #else /* !__WINRT__ */
    98 
    99 typedef struct
   100 {
   101     HRESULT coinitialized;
   102     WNDCLASSEX wincl;
   103     HWND messageWindow;
   104     HDEVNOTIFY hNotify;
   105 } SDL_DeviceNotificationData;
   106 
   107 #define IDT_SDL_DEVICE_CHANGE_TIMER_1 1200
   108 #define IDT_SDL_DEVICE_CHANGE_TIMER_2 1201
   109 
   110 /* windowproc for our joystick detect thread message only window, to detect any USB device addition/removal */
   111 static LRESULT CALLBACK
   112 SDL_PrivateJoystickDetectProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
   113 {
   114     switch (message) {
   115     case WM_DEVICECHANGE:
   116         switch (wParam) {
   117         case DBT_DEVICEARRIVAL:
   118         case DBT_DEVICEREMOVECOMPLETE:
   119             if (((DEV_BROADCAST_HDR*)lParam)->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE) {
   120                 /* notify 300ms and 2 seconds later to ensure all APIs have updated status */
   121                 SetTimer(hwnd, IDT_SDL_DEVICE_CHANGE_TIMER_1, 300, NULL);
   122                 SetTimer(hwnd, IDT_SDL_DEVICE_CHANGE_TIMER_2, 2000, NULL);
   123             }
   124             break;
   125         }
   126         return 0;
   127     case WM_TIMER:
   128         KillTimer(hwnd, wParam);
   129         s_bWindowsDeviceChanged = SDL_TRUE;
   130         return 0;
   131     }
   132 
   133     return DefWindowProc (hwnd, message, wParam, lParam);
   134 }
   135 
   136 static void
   137 SDL_CleanupDeviceNotification(SDL_DeviceNotificationData *data)
   138 {
   139     if (data->hNotify)
   140         UnregisterDeviceNotification(data->hNotify);
   141 
   142     if (data->messageWindow)
   143         DestroyWindow(data->messageWindow);
   144 
   145     UnregisterClass(data->wincl.lpszClassName, data->wincl.hInstance);
   146 
   147     if (data->coinitialized == S_OK) {
   148         WIN_CoUninitialize();
   149     }
   150 }
   151 
   152 static int
   153 SDL_CreateDeviceNotification(SDL_DeviceNotificationData *data)
   154 {
   155     DEV_BROADCAST_DEVICEINTERFACE dbh;
   156     GUID GUID_DEVINTERFACE_HID = { 0x4D1E55B2L, 0xF16F, 0x11CF, { 0x88, 0xCB, 0x00, 0x11, 0x11, 0x00, 0x00, 0x30 } };
   157 
   158     SDL_zerop(data);
   159 
   160     data->coinitialized = WIN_CoInitialize();
   161 
   162     data->wincl.hInstance = GetModuleHandle(NULL);
   163     data->wincl.lpszClassName = L"Message";
   164     data->wincl.lpfnWndProc = SDL_PrivateJoystickDetectProc;      /* This function is called by windows */
   165     data->wincl.cbSize = sizeof (WNDCLASSEX);
   166 
   167     if (!RegisterClassEx(&data->wincl)) {
   168         WIN_SetError("Failed to create register class for joystick autodetect");
   169         SDL_CleanupDeviceNotification(data);
   170         return -1;
   171     }
   172 
   173     data->messageWindow = (HWND)CreateWindowEx(0,  L"Message", NULL, 0, 0, 0, 0, 0, HWND_MESSAGE, NULL, NULL, NULL);
   174     if (!data->messageWindow) {
   175         WIN_SetError("Failed to create message window for joystick autodetect");
   176         SDL_CleanupDeviceNotification(data);
   177         return -1;
   178     }
   179 
   180     SDL_zero(dbh);
   181     dbh.dbcc_size = sizeof(dbh);
   182     dbh.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
   183     dbh.dbcc_classguid = GUID_DEVINTERFACE_HID;
   184 
   185     data->hNotify = RegisterDeviceNotification(data->messageWindow, &dbh, DEVICE_NOTIFY_WINDOW_HANDLE);
   186     if (!data->hNotify) {
   187         WIN_SetError("Failed to create notify device for joystick autodetect");
   188         SDL_CleanupDeviceNotification(data);
   189         return -1;
   190     }
   191     return 0;
   192 }
   193 
   194 static SDL_bool
   195 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     SDL_UnlockMutex(mutex);
   205     while (lastret > 0 && s_bWindowsDeviceChanged == SDL_FALSE) {
   206         lastret = GetMessage(&msg, NULL, 0, 0); /* WM_QUIT causes return value of 0 */
   207         if (lastret > 0) {
   208             TranslateMessage(&msg);
   209             DispatchMessage(&msg);
   210         }
   211     }
   212     SDL_LockMutex(mutex);
   213     return (lastret != -1) ? SDL_TRUE : SDL_FALSE;
   214 }
   215 
   216 #endif /* __WINRT__ */
   217 
   218 /* Function/thread to scan the system for joysticks. */
   219 static int
   220 SDL_JoystickThread(void *_data)
   221 {
   222     SDL_DeviceNotificationData notification_data;
   223 
   224 #if SDL_JOYSTICK_XINPUT
   225     SDL_bool bOpenedXInputDevices[XUSER_MAX_COUNT];
   226     SDL_zero(bOpenedXInputDevices);
   227 #endif
   228 
   229     if (SDL_CreateDeviceNotification(&notification_data) < 0) {
   230         return -1;
   231     }
   232 
   233     SDL_LockMutex(s_mutexJoyStickEnum);
   234     while (s_bJoystickThreadQuit == SDL_FALSE) {
   235         SDL_bool bXInputChanged = SDL_FALSE;
   236 
   237         if (SDL_WaitForDeviceNotification(&notification_data, s_mutexJoyStickEnum) == SDL_FALSE) {
   238 #if SDL_JOYSTICK_XINPUT
   239             /* WM_DEVICECHANGE not working, poll for new XINPUT controllers */
   240             SDL_CondWaitTimeout(s_condJoystickThread, s_mutexJoyStickEnum, 1000);
   241             if (SDL_XINPUT_Enabled() && XINPUTGETCAPABILITIES) {
   242                 /* scan for any change in XInput devices */
   243                 Uint8 userId;
   244                 for (userId = 0; userId < XUSER_MAX_COUNT; userId++) {
   245                     XINPUT_CAPABILITIES capabilities;
   246                     const DWORD result = XINPUTGETCAPABILITIES(userId, XINPUT_FLAG_GAMEPAD, &capabilities);
   247                     const SDL_bool available = (result == ERROR_SUCCESS);
   248                     if (bOpenedXInputDevices[userId] != available) {
   249                         bXInputChanged = SDL_TRUE;
   250                         bOpenedXInputDevices[userId] = available;
   251                     }
   252                 }
   253             }
   254 #else
   255             /* WM_DEVICECHANGE not working, no XINPUT, no point in keeping thread alive */
   256             break;
   257 #endif /* SDL_JOYSTICK_XINPUT */
   258 		}
   259 
   260         if (s_bWindowsDeviceChanged || bXInputChanged) {
   261             s_bDeviceRemoved = SDL_TRUE;
   262             s_bDeviceAdded = SDL_TRUE;
   263             s_bWindowsDeviceChanged = SDL_FALSE;
   264         }
   265     }
   266     SDL_UnlockMutex(s_mutexJoyStickEnum);
   267 
   268     SDL_CleanupDeviceNotification(&notification_data);
   269 
   270     return 1;
   271 }
   272 
   273 void WINDOWS_AddJoystickDevice(JoyStick_DeviceData *device)
   274 {
   275     device->send_add_event = SDL_TRUE;
   276     device->nInstanceID = SDL_GetNextJoystickInstanceID();
   277     device->pNext = SYS_Joystick;
   278     SYS_Joystick = device;
   279 
   280     s_bDeviceAdded = SDL_TRUE;
   281 }
   282 
   283 static void WINDOWS_JoystickDetect(void);
   284 static void WINDOWS_JoystickQuit(void);
   285 
   286 /* Function to scan the system for joysticks.
   287  * Joystick 0 should be the system default joystick.
   288  * It should return 0, or -1 on an unrecoverable fatal error.
   289  */
   290 static int
   291 WINDOWS_JoystickInit(void)
   292 {
   293     if (SDL_DINPUT_JoystickInit() < 0) {
   294         WINDOWS_JoystickQuit();
   295         return -1;
   296     }
   297 
   298     if (SDL_XINPUT_JoystickInit() < 0) {
   299         WINDOWS_JoystickQuit();
   300         return -1;
   301     }
   302 
   303     s_mutexJoyStickEnum = SDL_CreateMutex();
   304     s_condJoystickThread = SDL_CreateCond();
   305     s_bDeviceAdded = SDL_TRUE; /* force a scan of the system for joysticks this first time */
   306 
   307     WINDOWS_JoystickDetect();
   308 
   309     if (!s_threadJoystick) {
   310         /* spin up the thread to detect hotplug of devices */
   311         s_bJoystickThreadQuit = SDL_FALSE;
   312         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 static int
   319 WINDOWS_JoystickGetCount(void)
   320 {
   321     int nJoysticks = 0;
   322     JoyStick_DeviceData *device = SYS_Joystick;
   323     while (device) {
   324         nJoysticks++;
   325         device = device->pNext;
   326     }
   327 
   328     return nJoysticks;
   329 }
   330 
   331 /* detect any new joysticks being inserted into the system */
   332 static void
   333 WINDOWS_JoystickDetect(void)
   334 {
   335     JoyStick_DeviceData *pCurList = NULL;
   336 
   337     /* only enum the devices if the joystick thread told us something changed */
   338     if (!s_bDeviceAdded && !s_bDeviceRemoved) {
   339         return;  /* thread hasn't signaled, nothing to do right now. */
   340     }
   341 
   342     SDL_LockMutex(s_mutexJoyStickEnum);
   343 
   344     s_bDeviceAdded = SDL_FALSE;
   345     s_bDeviceRemoved = SDL_FALSE;
   346 
   347     pCurList = SYS_Joystick;
   348     SYS_Joystick = NULL;
   349 
   350     /* Look for DirectInput joysticks, wheels, head trackers, gamepads, etc.. */
   351     SDL_DINPUT_JoystickDetect(&pCurList);
   352 
   353     /* Look for XInput devices. Do this last, so they're first in the final list. */
   354     SDL_XINPUT_JoystickDetect(&pCurList);
   355 
   356     SDL_UnlockMutex(s_mutexJoyStickEnum);
   357 
   358     while (pCurList) {
   359         JoyStick_DeviceData *pListNext = NULL;
   360 
   361         if (pCurList->bXInputDevice) {
   362             SDL_XINPUT_MaybeRemoveDevice(pCurList->XInputUserId);
   363         } else {
   364             SDL_DINPUT_MaybeRemoveDevice(&pCurList->dxdevice);
   365         }
   366 
   367         SDL_PrivateJoystickRemoved(pCurList->nInstanceID);
   368 
   369         pListNext = pCurList->pNext;
   370         SDL_free(pCurList->joystickname);
   371         SDL_free(pCurList);
   372         pCurList = pListNext;
   373     }
   374 
   375     if (s_bDeviceAdded) {
   376         JoyStick_DeviceData *pNewJoystick;
   377         int device_index = 0;
   378         s_bDeviceAdded = SDL_FALSE;
   379         pNewJoystick = SYS_Joystick;
   380         while (pNewJoystick) {
   381             if (pNewJoystick->send_add_event) {
   382                 if (pNewJoystick->bXInputDevice) {
   383                     SDL_XINPUT_MaybeAddDevice(pNewJoystick->XInputUserId);
   384                 } else {
   385                     SDL_DINPUT_MaybeAddDevice(&pNewJoystick->dxdevice);
   386                 }
   387 
   388                 SDL_PrivateJoystickAdded(pNewJoystick->nInstanceID);
   389 
   390                 pNewJoystick->send_add_event = SDL_FALSE;
   391             }
   392             device_index++;
   393             pNewJoystick = pNewJoystick->pNext;
   394         }
   395     }
   396 }
   397 
   398 /* Function to get the device-dependent name of a joystick */
   399 static const char *
   400 WINDOWS_JoystickGetDeviceName(int device_index)
   401 {
   402     JoyStick_DeviceData *device = SYS_Joystick;
   403 
   404     for (; device_index > 0; device_index--)
   405         device = device->pNext;
   406 
   407     return device->joystickname;
   408 }
   409 
   410 /* return the stable device guid for this device index */
   411 static SDL_JoystickGUID
   412 WINDOWS_JoystickGetDeviceGUID(int device_index)
   413 {
   414     JoyStick_DeviceData *device = SYS_Joystick;
   415     int index;
   416 
   417     for (index = device_index; index > 0; index--)
   418         device = device->pNext;
   419 
   420     return device->guid;
   421 }
   422 
   423 /* Function to perform the mapping between current device instance and this joysticks instance id */
   424 static SDL_JoystickID
   425 WINDOWS_JoystickGetDeviceInstanceID(int device_index)
   426 {
   427     JoyStick_DeviceData *device = SYS_Joystick;
   428     int index;
   429 
   430     for (index = device_index; index > 0; index--)
   431         device = device->pNext;
   432 
   433     return device->nInstanceID;
   434 }
   435 
   436 /* Function to open a joystick for use.
   437    The joystick to open is specified by the device index.
   438    This should fill the nbuttons and naxes fields of the joystick structure.
   439    It returns 0, or -1 if there is an error.
   440  */
   441 static int
   442 WINDOWS_JoystickOpen(SDL_Joystick * joystick, int device_index)
   443 {
   444     JoyStick_DeviceData *joystickdevice = SYS_Joystick;
   445 
   446     for (; device_index > 0; device_index--)
   447         joystickdevice = joystickdevice->pNext;
   448 
   449     /* allocate memory for system specific hardware data */
   450     joystick->instance_id = joystickdevice->nInstanceID;
   451     joystick->hwdata =
   452         (struct joystick_hwdata *) SDL_malloc(sizeof(struct joystick_hwdata));
   453     if (joystick->hwdata == NULL) {
   454         return SDL_OutOfMemory();
   455     }
   456     SDL_zerop(joystick->hwdata);
   457     joystick->hwdata->guid = joystickdevice->guid;
   458 
   459     if (joystickdevice->bXInputDevice) {
   460         return SDL_XINPUT_JoystickOpen(joystick, joystickdevice);
   461     } else {
   462         return SDL_DINPUT_JoystickOpen(joystick, joystickdevice);
   463     }
   464 }
   465 
   466 /* return true if this joystick is plugged in right now */
   467 static SDL_bool 
   468 WINDOWS_JoystickIsAttached(SDL_Joystick * joystick)
   469 {
   470     return joystick->hwdata && !joystick->hwdata->removed;
   471 }
   472 
   473 static int
   474 WINDOWS_JoystickRumble(SDL_Joystick * joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble, Uint32 duration_ms)
   475 {
   476     if (joystick->hwdata->bXInputDevice) {
   477         return SDL_XINPUT_JoystickRumble(joystick, low_frequency_rumble, high_frequency_rumble, duration_ms);
   478     } else {
   479         return SDL_DINPUT_JoystickRumble(joystick, low_frequency_rumble, high_frequency_rumble, duration_ms);
   480     }
   481 }
   482 
   483 static void
   484 WINDOWS_JoystickUpdate(SDL_Joystick * joystick)
   485 {
   486     if (!joystick->hwdata || joystick->hwdata->removed) {
   487         return;
   488     }
   489 
   490     if (joystick->hwdata->bXInputDevice) {
   491         SDL_XINPUT_JoystickUpdate(joystick);
   492     } else {
   493         SDL_DINPUT_JoystickUpdate(joystick);
   494     }
   495 
   496     if (joystick->hwdata->removed) {
   497         joystick->force_recentering = SDL_TRUE;
   498     }
   499 }
   500 
   501 /* Function to close a joystick after use */
   502 static void
   503 WINDOWS_JoystickClose(SDL_Joystick * joystick)
   504 {
   505     if (joystick->hwdata->bXInputDevice) {
   506         SDL_XINPUT_JoystickClose(joystick);
   507     } else {
   508         SDL_DINPUT_JoystickClose(joystick);
   509     }
   510 
   511     SDL_free(joystick->hwdata);
   512 }
   513 
   514 /* Function to perform any system-specific joystick related cleanup */
   515 static void
   516 WINDOWS_JoystickQuit(void)
   517 {
   518     JoyStick_DeviceData *device = SYS_Joystick;
   519 
   520     while (device) {
   521         JoyStick_DeviceData *device_next = device->pNext;
   522         SDL_free(device->joystickname);
   523         SDL_free(device);
   524         device = device_next;
   525     }
   526     SYS_Joystick = NULL;
   527 
   528     if (s_threadJoystick) {
   529         SDL_LockMutex(s_mutexJoyStickEnum);
   530         s_bJoystickThreadQuit = SDL_TRUE;
   531         SDL_CondBroadcast(s_condJoystickThread); /* signal the joystick thread to quit */
   532         SDL_UnlockMutex(s_mutexJoyStickEnum);
   533 #ifndef __WINRT__
   534         PostThreadMessage(SDL_GetThreadID(s_threadJoystick), WM_QUIT, 0, 0);
   535 #endif
   536         SDL_WaitThread(s_threadJoystick, NULL); /* wait for it to bugger off */
   537 
   538         SDL_DestroyMutex(s_mutexJoyStickEnum);
   539         SDL_DestroyCond(s_condJoystickThread);
   540         s_condJoystickThread= NULL;
   541         s_mutexJoyStickEnum = NULL;
   542         s_threadJoystick = NULL;
   543     }
   544 
   545     SDL_DINPUT_JoystickQuit();
   546     SDL_XINPUT_JoystickQuit();
   547 
   548     s_bDeviceAdded = SDL_FALSE;
   549     s_bDeviceRemoved = SDL_FALSE;
   550 }
   551 
   552 SDL_JoystickDriver SDL_WINDOWS_JoystickDriver =
   553 {
   554     WINDOWS_JoystickInit,
   555     WINDOWS_JoystickGetCount,
   556     WINDOWS_JoystickDetect,
   557     WINDOWS_JoystickGetDeviceName,
   558     WINDOWS_JoystickGetDeviceGUID,
   559     WINDOWS_JoystickGetDeviceInstanceID,
   560     WINDOWS_JoystickOpen,
   561     WINDOWS_JoystickIsAttached,
   562     WINDOWS_JoystickRumble,
   563     WINDOWS_JoystickUpdate,
   564     WINDOWS_JoystickClose,
   565     WINDOWS_JoystickQuit,
   566 };
   567 
   568 #endif /* SDL_JOYSTICK_DINPUT || SDL_JOYSTICK_XINPUT */
   569 
   570 /* vi: set ts=4 sw=4 expandtab: */