1 /*
2 Simple DirectMedia Layer
3 Copyright (C) 1997-2016 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
SDL_XINPUT_HapticInit(void)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
SDL_XINPUT_MaybeAddDevice(const DWORD dwUserid)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
SDL_XINPUT_MaybeRemoveDevice(const DWORD dwUserid)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
SDL_RunXInputHaptic(void * arg)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
SDL_XINPUT_HapticOpenFromUserIndex(SDL_Haptic * haptic,const Uint8 userid)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
SDL_XINPUT_HapticOpen(SDL_Haptic * haptic,SDL_hapticlist_item * item)222 SDL_XINPUT_HapticOpen(SDL_Haptic * haptic, SDL_hapticlist_item *item)
223 {
224 return SDL_XINPUT_HapticOpenFromUserIndex(haptic, item->userid);
225 }
226
227 int
SDL_XINPUT_JoystickSameHaptic(SDL_Haptic * haptic,SDL_Joystick * joystick)228 SDL_XINPUT_JoystickSameHaptic(SDL_Haptic * haptic, SDL_Joystick * joystick)
229 {
230 return (haptic->hwdata->userid == joystick->hwdata->userid);
231 }
232
233 int
SDL_XINPUT_HapticOpenFromJoystick(SDL_Haptic * haptic,SDL_Joystick * joystick)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
SDL_XINPUT_HapticClose(SDL_Haptic * haptic)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
SDL_XINPUT_HapticQuit(void)261 SDL_XINPUT_HapticQuit(void)
262 {
263 if (loaded_xinput) {
264 WIN_UnloadXInputDLL();
265 loaded_xinput = SDL_FALSE;
266 }
267 }
268
269 int
SDL_XINPUT_HapticNewEffect(SDL_Haptic * haptic,struct haptic_effect * effect,SDL_HapticEffect * base)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
SDL_XINPUT_HapticUpdateEffect(SDL_Haptic * haptic,struct haptic_effect * effect,SDL_HapticEffect * data)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
SDL_XINPUT_HapticRunEffect(SDL_Haptic * haptic,struct haptic_effect * effect,Uint32 iterations)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
SDL_XINPUT_HapticStopEffect(SDL_Haptic * haptic,struct haptic_effect * effect)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
SDL_XINPUT_HapticDestroyEffect(SDL_Haptic * haptic,struct haptic_effect * effect)322 SDL_XINPUT_HapticDestroyEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
323 {
324 SDL_XINPUT_HapticStopEffect(haptic, effect);
325 }
326
327 int
SDL_XINPUT_HapticGetEffectStatus(SDL_Haptic * haptic,struct haptic_effect * effect)328 SDL_XINPUT_HapticGetEffectStatus(SDL_Haptic * haptic, struct haptic_effect *effect)
329 {
330 return SDL_Unsupported();
331 }
332
333 int
SDL_XINPUT_HapticSetGain(SDL_Haptic * haptic,int gain)334 SDL_XINPUT_HapticSetGain(SDL_Haptic * haptic, int gain)
335 {
336 return SDL_Unsupported();
337 }
338
339 int
SDL_XINPUT_HapticSetAutocenter(SDL_Haptic * haptic,int autocenter)340 SDL_XINPUT_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter)
341 {
342 return SDL_Unsupported();
343 }
344
345 int
SDL_XINPUT_HapticPause(SDL_Haptic * haptic)346 SDL_XINPUT_HapticPause(SDL_Haptic * haptic)
347 {
348 return SDL_Unsupported();
349 }
350
351 int
SDL_XINPUT_HapticUnpause(SDL_Haptic * haptic)352 SDL_XINPUT_HapticUnpause(SDL_Haptic * haptic)
353 {
354 return SDL_Unsupported();
355 }
356
357 int
SDL_XINPUT_HapticStopAll(SDL_Haptic * haptic)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
SDL_XINPUT_HapticInit(void)374 SDL_XINPUT_HapticInit(void)
375 {
376 return 0;
377 }
378
379 int
SDL_XINPUT_MaybeAddDevice(const DWORD dwUserid)380 SDL_XINPUT_MaybeAddDevice(const DWORD dwUserid)
381 {
382 return SDL_Unsupported();
383 }
384
385 int
SDL_XINPUT_MaybeRemoveDevice(const DWORD dwUserid)386 SDL_XINPUT_MaybeRemoveDevice(const DWORD dwUserid)
387 {
388 return SDL_Unsupported();
389 }
390
391 int
SDL_XINPUT_HapticOpen(SDL_Haptic * haptic,SDL_hapticlist_item * item)392 SDL_XINPUT_HapticOpen(SDL_Haptic * haptic, SDL_hapticlist_item *item)
393 {
394 return SDL_Unsupported();
395 }
396
397 int
SDL_XINPUT_JoystickSameHaptic(SDL_Haptic * haptic,SDL_Joystick * joystick)398 SDL_XINPUT_JoystickSameHaptic(SDL_Haptic * haptic, SDL_Joystick * joystick)
399 {
400 return SDL_Unsupported();
401 }
402
403 int
SDL_XINPUT_HapticOpenFromJoystick(SDL_Haptic * haptic,SDL_Joystick * joystick)404 SDL_XINPUT_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick)
405 {
406 return SDL_Unsupported();
407 }
408
409 void
SDL_XINPUT_HapticClose(SDL_Haptic * haptic)410 SDL_XINPUT_HapticClose(SDL_Haptic * haptic)
411 {
412 }
413
414 void
SDL_XINPUT_HapticQuit(void)415 SDL_XINPUT_HapticQuit(void)
416 {
417 }
418
419 int
SDL_XINPUT_HapticNewEffect(SDL_Haptic * haptic,struct haptic_effect * effect,SDL_HapticEffect * base)420 SDL_XINPUT_HapticNewEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * base)
421 {
422 return SDL_Unsupported();
423 }
424
425 int
SDL_XINPUT_HapticUpdateEffect(SDL_Haptic * haptic,struct haptic_effect * effect,SDL_HapticEffect * data)426 SDL_XINPUT_HapticUpdateEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * data)
427 {
428 return SDL_Unsupported();
429 }
430
431 int
SDL_XINPUT_HapticRunEffect(SDL_Haptic * haptic,struct haptic_effect * effect,Uint32 iterations)432 SDL_XINPUT_HapticRunEffect(SDL_Haptic * haptic, struct haptic_effect *effect, Uint32 iterations)
433 {
434 return SDL_Unsupported();
435 }
436
437 int
SDL_XINPUT_HapticStopEffect(SDL_Haptic * haptic,struct haptic_effect * effect)438 SDL_XINPUT_HapticStopEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
439 {
440 return SDL_Unsupported();
441 }
442
443 void
SDL_XINPUT_HapticDestroyEffect(SDL_Haptic * haptic,struct haptic_effect * effect)444 SDL_XINPUT_HapticDestroyEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
445 {
446 }
447
448 int
SDL_XINPUT_HapticGetEffectStatus(SDL_Haptic * haptic,struct haptic_effect * effect)449 SDL_XINPUT_HapticGetEffectStatus(SDL_Haptic * haptic, struct haptic_effect *effect)
450 {
451 return SDL_Unsupported();
452 }
453
454 int
SDL_XINPUT_HapticSetGain(SDL_Haptic * haptic,int gain)455 SDL_XINPUT_HapticSetGain(SDL_Haptic * haptic, int gain)
456 {
457 return SDL_Unsupported();
458 }
459
460 int
SDL_XINPUT_HapticSetAutocenter(SDL_Haptic * haptic,int autocenter)461 SDL_XINPUT_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter)
462 {
463 return SDL_Unsupported();
464 }
465
466 int
SDL_XINPUT_HapticPause(SDL_Haptic * haptic)467 SDL_XINPUT_HapticPause(SDL_Haptic * haptic)
468 {
469 return SDL_Unsupported();
470 }
471
472 int
SDL_XINPUT_HapticUnpause(SDL_Haptic * haptic)473 SDL_XINPUT_HapticUnpause(SDL_Haptic * haptic)
474 {
475 return SDL_Unsupported();
476 }
477
478 int
SDL_XINPUT_HapticStopAll(SDL_Haptic * haptic)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: */
487