src/haptic/windows/SDL_xinputhaptic.c
author Sam Lantinga
Fri, 27 Jan 2017 06:05:50 -0800
changeset 10856 486aa38c6a88
parent 10737 3406a0f8b041
child 11110 db5c09aa4fd4
permissions -rw-r--r--
Added Thrustmaster Wheel FFB entry to the list of wheels
     1 /*
     2   Simple DirectMedia Layer
     3   Copyright (C) 1997-2017 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 #include "SDL_error.h"
    24 #include "SDL_haptic.h"
    25 #include "../SDL_syshaptic.h"
    26 
    27 #if SDL_HAPTIC_XINPUT
    28 
    29 #include "SDL_assert.h"
    30 #include "SDL_hints.h"
    31 #include "SDL_timer.h"
    32 #include "SDL_windowshaptic_c.h"
    33 #include "SDL_xinputhaptic_c.h"
    34 #include "../../core/windows/SDL_xinput.h"
    35 #include "../../joystick/windows/SDL_windowsjoystick_c.h"
    36 #include "../../thread/SDL_systhread.h"
    37 
    38 /*
    39  * Internal stuff.
    40  */
    41 static SDL_bool loaded_xinput = SDL_FALSE;
    42 
    43 
    44 int
    45 SDL_XINPUT_HapticInit(void)
    46 {
    47     if (SDL_GetHintBoolean(SDL_HINT_XINPUT_ENABLED, SDL_TRUE)) {
    48         loaded_xinput = (WIN_LoadXInputDLL() == 0);
    49     }
    50 
    51     if (loaded_xinput) {
    52         DWORD i;
    53         for (i = 0; i < XUSER_MAX_COUNT; i++) {
    54             SDL_XINPUT_MaybeAddDevice(i);
    55         }
    56     }
    57     return 0;
    58 }
    59 
    60 int
    61 SDL_XINPUT_MaybeAddDevice(const DWORD dwUserid)
    62 {
    63     const Uint8 userid = (Uint8)dwUserid;
    64     SDL_hapticlist_item *item;
    65     XINPUT_VIBRATION state;
    66 
    67     if ((!loaded_xinput) || (dwUserid >= XUSER_MAX_COUNT)) {
    68         return -1;
    69     }
    70 
    71     /* Make sure we don't already have it */
    72     for (item = SDL_hapticlist; item; item = item->next) {
    73         if (item->bXInputHaptic && item->userid == userid) {
    74             return -1;  /* Already added */
    75         }
    76     }
    77 
    78     SDL_zero(state);
    79     if (XINPUTSETSTATE(dwUserid, &state) != ERROR_SUCCESS) {
    80         return -1;  /* no force feedback on this device. */
    81     }
    82 
    83     item = (SDL_hapticlist_item *)SDL_malloc(sizeof(SDL_hapticlist_item));
    84     if (item == NULL) {
    85         return SDL_OutOfMemory();
    86     }
    87 
    88     SDL_zerop(item);
    89 
    90     /* !!! FIXME: I'm not bothering to query for a real name right now (can we even?) */
    91     {
    92         char buf[64];
    93         SDL_snprintf(buf, sizeof(buf), "XInput Controller #%u", (unsigned int)(userid + 1));
    94         item->name = SDL_strdup(buf);
    95     }
    96 
    97     if (!item->name) {
    98         SDL_free(item);
    99         return -1;
   100     }
   101 
   102     /* Copy the instance over, useful for creating devices. */
   103     item->bXInputHaptic = SDL_TRUE;
   104     item->userid = userid;
   105 
   106     return SDL_SYS_AddHapticDevice(item);
   107 }
   108 
   109 int
   110 SDL_XINPUT_MaybeRemoveDevice(const DWORD dwUserid)
   111 {
   112     const Uint8 userid = (Uint8)dwUserid;
   113     SDL_hapticlist_item *item;
   114     SDL_hapticlist_item *prev = NULL;
   115 
   116     if ((!loaded_xinput) || (dwUserid >= XUSER_MAX_COUNT)) {
   117         return -1;
   118     }
   119 
   120     for (item = SDL_hapticlist; item != NULL; item = item->next) {
   121         if (item->bXInputHaptic && item->userid == userid) {
   122             /* found it, remove it. */
   123             return SDL_SYS_RemoveHapticDevice(prev, item);
   124         }
   125         prev = item;
   126     }
   127     return -1;
   128 }
   129 
   130 /* !!! FIXME: this is a hack, remove this later. */
   131 /* Since XInput doesn't offer a way to vibrate for X time, we hook into
   132  *  SDL_PumpEvents() to check if it's time to stop vibrating with some
   133  *  frequency.
   134  * In practice, this works for 99% of use cases. But in an ideal world,
   135  *  we do this in a separate thread so that:
   136  *    - we aren't bound to when the app chooses to pump the event queue.
   137  *    - we aren't adding more polling to the event queue
   138  *    - we can emulate all the haptic effects correctly (start on a delay,
   139  *      mix multiple effects, etc).
   140  *
   141  * Mostly, this is here to get rumbling to work, and all the other features
   142  *  are absent in the XInput path for now.  :(
   143  */
   144 static int SDLCALL
   145 SDL_RunXInputHaptic(void *arg)
   146 {
   147     struct haptic_hwdata *hwdata = (struct haptic_hwdata *) arg;
   148 
   149     while (!SDL_AtomicGet(&hwdata->stopThread)) {
   150         SDL_Delay(50);
   151         SDL_LockMutex(hwdata->mutex);
   152         /* If we're currently running and need to stop... */
   153         if (hwdata->stopTicks) {
   154             if ((hwdata->stopTicks != SDL_HAPTIC_INFINITY) && SDL_TICKS_PASSED(SDL_GetTicks(), hwdata->stopTicks)) {
   155                 XINPUT_VIBRATION vibration = { 0, 0 };
   156                 hwdata->stopTicks = 0;
   157                 XINPUTSETSTATE(hwdata->userid, &vibration);
   158             }
   159         }
   160         SDL_UnlockMutex(hwdata->mutex);
   161     }
   162 
   163     return 0;
   164 }
   165 
   166 static int
   167 SDL_XINPUT_HapticOpenFromUserIndex(SDL_Haptic *haptic, const Uint8 userid)
   168 {
   169     char threadName[32];
   170     XINPUT_VIBRATION vibration = { 0, 0 };  /* stop any current vibration */
   171     XINPUTSETSTATE(userid, &vibration);
   172 
   173     haptic->supported = SDL_HAPTIC_LEFTRIGHT;
   174 
   175     haptic->neffects = 1;
   176     haptic->nplaying = 1;
   177 
   178     /* Prepare effects memory. */
   179     haptic->effects = (struct haptic_effect *)
   180         SDL_malloc(sizeof(struct haptic_effect) * haptic->neffects);
   181     if (haptic->effects == NULL) {
   182         return SDL_OutOfMemory();
   183     }
   184     /* Clear the memory */
   185     SDL_memset(haptic->effects, 0,
   186         sizeof(struct haptic_effect) * haptic->neffects);
   187 
   188     haptic->hwdata = (struct haptic_hwdata *) SDL_malloc(sizeof(*haptic->hwdata));
   189     if (haptic->hwdata == NULL) {
   190         SDL_free(haptic->effects);
   191         haptic->effects = NULL;
   192         return SDL_OutOfMemory();
   193     }
   194     SDL_memset(haptic->hwdata, 0, sizeof(*haptic->hwdata));
   195 
   196     haptic->hwdata->bXInputHaptic = 1;
   197     haptic->hwdata->userid = userid;
   198 
   199     haptic->hwdata->mutex = SDL_CreateMutex();
   200     if (haptic->hwdata->mutex == NULL) {
   201         SDL_free(haptic->effects);
   202         SDL_free(haptic->hwdata);
   203         haptic->effects = NULL;
   204         return SDL_SetError("Couldn't create XInput haptic mutex");
   205     }
   206 
   207     SDL_snprintf(threadName, sizeof(threadName), "SDLXInputDev%d", (int)userid);
   208     haptic->hwdata->thread = SDL_CreateThreadInternal(SDL_RunXInputHaptic, threadName, 64 * 1024, haptic->hwdata);
   209 
   210     if (haptic->hwdata->thread == NULL) {
   211         SDL_DestroyMutex(haptic->hwdata->mutex);
   212         SDL_free(haptic->effects);
   213         SDL_free(haptic->hwdata);
   214         haptic->effects = NULL;
   215         return SDL_SetError("Couldn't create XInput haptic thread");
   216     }
   217 
   218     return 0;
   219 }
   220 
   221 int
   222 SDL_XINPUT_HapticOpen(SDL_Haptic * haptic, SDL_hapticlist_item *item)
   223 {
   224     return SDL_XINPUT_HapticOpenFromUserIndex(haptic, item->userid);
   225 }
   226 
   227 int
   228 SDL_XINPUT_JoystickSameHaptic(SDL_Haptic * haptic, SDL_Joystick * joystick)
   229 {
   230     return (haptic->hwdata->userid == joystick->hwdata->userid);
   231 }
   232 
   233 int
   234 SDL_XINPUT_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick)
   235 {
   236     SDL_hapticlist_item *item;
   237     int index = 0;
   238 
   239     /* Since it comes from a joystick we have to try to match it with a haptic device on our haptic list. */
   240     for (item = SDL_hapticlist; item != NULL; item = item->next) {
   241         if (item->bXInputHaptic && item->userid == joystick->hwdata->userid) {
   242             haptic->index = index;
   243             return SDL_XINPUT_HapticOpenFromUserIndex(haptic, joystick->hwdata->userid);
   244         }
   245         ++index;
   246     }
   247 
   248     SDL_SetError("Couldn't find joystick in haptic device list");
   249     return -1;
   250 }
   251 
   252 void
   253 SDL_XINPUT_HapticClose(SDL_Haptic * haptic)
   254 {
   255     SDL_AtomicSet(&haptic->hwdata->stopThread, 1);
   256     SDL_WaitThread(haptic->hwdata->thread, NULL);
   257     SDL_DestroyMutex(haptic->hwdata->mutex);
   258 }
   259 
   260 void
   261 SDL_XINPUT_HapticQuit(void)
   262 {
   263     if (loaded_xinput) {
   264         WIN_UnloadXInputDLL();
   265         loaded_xinput = SDL_FALSE;
   266     }
   267 }
   268 
   269 int
   270 SDL_XINPUT_HapticNewEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * base)
   271 {
   272     SDL_assert(base->type == SDL_HAPTIC_LEFTRIGHT);  /* should catch this at higher level */
   273     return SDL_XINPUT_HapticUpdateEffect(haptic, effect, base);
   274 }
   275 
   276 int
   277 SDL_XINPUT_HapticUpdateEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * data)
   278 {
   279     XINPUT_VIBRATION *vib = &effect->hweffect->vibration;
   280     SDL_assert(data->type == SDL_HAPTIC_LEFTRIGHT);
   281     vib->wLeftMotorSpeed = data->leftright.large_magnitude;
   282     vib->wRightMotorSpeed = data->leftright.small_magnitude;
   283     SDL_LockMutex(haptic->hwdata->mutex);
   284     if (haptic->hwdata->stopTicks) {  /* running right now? Update it. */
   285         XINPUTSETSTATE(haptic->hwdata->userid, vib);
   286     }
   287     SDL_UnlockMutex(haptic->hwdata->mutex);
   288     return 0;
   289 }
   290 
   291 int
   292 SDL_XINPUT_HapticRunEffect(SDL_Haptic * haptic, struct haptic_effect *effect, Uint32 iterations)
   293 {
   294     XINPUT_VIBRATION *vib = &effect->hweffect->vibration;
   295     SDL_assert(effect->effect.type == SDL_HAPTIC_LEFTRIGHT);  /* should catch this at higher level */
   296     SDL_LockMutex(haptic->hwdata->mutex);
   297     if (effect->effect.leftright.length == SDL_HAPTIC_INFINITY || iterations == SDL_HAPTIC_INFINITY) {
   298         haptic->hwdata->stopTicks = SDL_HAPTIC_INFINITY;
   299     } else if ((!effect->effect.leftright.length) || (!iterations)) {
   300         /* do nothing. Effect runs for zero milliseconds. */
   301     } else {
   302         haptic->hwdata->stopTicks = SDL_GetTicks() + (effect->effect.leftright.length * iterations);
   303         if ((haptic->hwdata->stopTicks == SDL_HAPTIC_INFINITY) || (haptic->hwdata->stopTicks == 0)) {
   304             haptic->hwdata->stopTicks = 1;  /* fix edge cases. */
   305         }
   306     }
   307     SDL_UnlockMutex(haptic->hwdata->mutex);
   308     return (XINPUTSETSTATE(haptic->hwdata->userid, vib) == ERROR_SUCCESS) ? 0 : -1;
   309 }
   310 
   311 int
   312 SDL_XINPUT_HapticStopEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
   313 {
   314     XINPUT_VIBRATION vibration = { 0, 0 };
   315     SDL_LockMutex(haptic->hwdata->mutex);
   316     haptic->hwdata->stopTicks = 0;
   317     SDL_UnlockMutex(haptic->hwdata->mutex);
   318     return (XINPUTSETSTATE(haptic->hwdata->userid, &vibration) == ERROR_SUCCESS) ? 0 : -1;
   319 }
   320 
   321 void
   322 SDL_XINPUT_HapticDestroyEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
   323 {
   324     SDL_XINPUT_HapticStopEffect(haptic, effect);
   325 }
   326 
   327 int
   328 SDL_XINPUT_HapticGetEffectStatus(SDL_Haptic * haptic, struct haptic_effect *effect)
   329 {
   330     return SDL_Unsupported();
   331 }
   332 
   333 int
   334 SDL_XINPUT_HapticSetGain(SDL_Haptic * haptic, int gain)
   335 {
   336     return SDL_Unsupported();
   337 }
   338 
   339 int
   340 SDL_XINPUT_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter)
   341 {
   342     return SDL_Unsupported();
   343 }
   344 
   345 int
   346 SDL_XINPUT_HapticPause(SDL_Haptic * haptic)
   347 {
   348     return SDL_Unsupported();
   349 }
   350 
   351 int
   352 SDL_XINPUT_HapticUnpause(SDL_Haptic * haptic)
   353 {
   354     return SDL_Unsupported();
   355 }
   356 
   357 int
   358 SDL_XINPUT_HapticStopAll(SDL_Haptic * haptic)
   359 {
   360     XINPUT_VIBRATION vibration = { 0, 0 };
   361     SDL_LockMutex(haptic->hwdata->mutex);
   362     haptic->hwdata->stopTicks = 0;
   363     SDL_UnlockMutex(haptic->hwdata->mutex);
   364     return (XINPUTSETSTATE(haptic->hwdata->userid, &vibration) == ERROR_SUCCESS) ? 0 : -1;
   365 }
   366 
   367 #else /* !SDL_HAPTIC_XINPUT */
   368 
   369 #include "../../core/windows/SDL_windows.h"
   370 
   371 typedef struct SDL_hapticlist_item SDL_hapticlist_item;
   372 
   373 int
   374 SDL_XINPUT_HapticInit(void)
   375 {
   376     return 0;
   377 }
   378 
   379 int
   380 SDL_XINPUT_MaybeAddDevice(const DWORD dwUserid)
   381 {
   382     return SDL_Unsupported();
   383 }
   384 
   385 int
   386 SDL_XINPUT_MaybeRemoveDevice(const DWORD dwUserid)
   387 {
   388     return SDL_Unsupported();
   389 }
   390 
   391 int
   392 SDL_XINPUT_HapticOpen(SDL_Haptic * haptic, SDL_hapticlist_item *item)
   393 {
   394     return SDL_Unsupported();
   395 }
   396 
   397 int
   398 SDL_XINPUT_JoystickSameHaptic(SDL_Haptic * haptic, SDL_Joystick * joystick)
   399 {
   400     return SDL_Unsupported();
   401 }
   402 
   403 int
   404 SDL_XINPUT_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick)
   405 {
   406     return SDL_Unsupported();
   407 }
   408 
   409 void
   410 SDL_XINPUT_HapticClose(SDL_Haptic * haptic)
   411 {
   412 }
   413 
   414 void
   415 SDL_XINPUT_HapticQuit(void)
   416 {
   417 }
   418 
   419 int
   420 SDL_XINPUT_HapticNewEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * base)
   421 {
   422     return SDL_Unsupported();
   423 }
   424 
   425 int
   426 SDL_XINPUT_HapticUpdateEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * data)
   427 {
   428     return SDL_Unsupported();
   429 }
   430 
   431 int
   432 SDL_XINPUT_HapticRunEffect(SDL_Haptic * haptic, struct haptic_effect *effect, Uint32 iterations)
   433 {
   434     return SDL_Unsupported();
   435 }
   436 
   437 int
   438 SDL_XINPUT_HapticStopEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
   439 {
   440     return SDL_Unsupported();
   441 }
   442 
   443 void
   444 SDL_XINPUT_HapticDestroyEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
   445 {
   446 }
   447 
   448 int
   449 SDL_XINPUT_HapticGetEffectStatus(SDL_Haptic * haptic, struct haptic_effect *effect)
   450 {
   451     return SDL_Unsupported();
   452 }
   453 
   454 int
   455 SDL_XINPUT_HapticSetGain(SDL_Haptic * haptic, int gain)
   456 {
   457     return SDL_Unsupported();
   458 }
   459 
   460 int
   461 SDL_XINPUT_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter)
   462 {
   463     return SDL_Unsupported();
   464 }
   465 
   466 int
   467 SDL_XINPUT_HapticPause(SDL_Haptic * haptic)
   468 {
   469     return SDL_Unsupported();
   470 }
   471 
   472 int
   473 SDL_XINPUT_HapticUnpause(SDL_Haptic * haptic)
   474 {
   475     return SDL_Unsupported();
   476 }
   477 
   478 int
   479 SDL_XINPUT_HapticStopAll(SDL_Haptic * haptic)
   480 {
   481     return SDL_Unsupported();
   482 }
   483 
   484 #endif /* SDL_HAPTIC_XINPUT */
   485 
   486 /* vi: set ts=4 sw=4 expandtab: */