SDL_joystick.c (76295B)
1 /* 2 Simple DirectMedia Layer 3 Copyright (C) 1997-2020 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 /* This is the joystick API for Simple DirectMedia Layer */ 24 25 #include "SDL.h" 26 #include "SDL_atomic.h" 27 #include "SDL_events.h" 28 #include "SDL_sysjoystick.h" 29 #include "SDL_hints.h" 30 31 #if !SDL_EVENTS_DISABLED 32 #include "../events/SDL_events_c.h" 33 #endif 34 #include "../video/SDL_sysvideo.h" 35 #include "hidapi/SDL_hidapijoystick_c.h" 36 37 /* This is included in only one place because it has a large static list of controllers */ 38 #include "controller_type.h" 39 40 #ifdef __WIN32__ 41 /* Needed for checking for input remapping programs */ 42 #include "../core/windows/SDL_windows.h" 43 44 #undef UNICODE /* We want ASCII functions */ 45 #include <tlhelp32.h> 46 #endif 47 48 #if SDL_JOYSTICK_VIRTUAL 49 #include "./virtual/SDL_virtualjoystick_c.h" 50 #endif 51 52 static SDL_JoystickDriver *SDL_joystick_drivers[] = { 53 #ifdef SDL_JOYSTICK_HIDAPI /* Before WINDOWS_ driver, as WINDOWS wants to check if this driver is handling things */ 54 &SDL_HIDAPI_JoystickDriver, 55 #endif 56 #ifdef SDL_JOYSTICK_RAWINPUT /* Before WINDOWS_ driver, as WINDOWS wants to check if this driver is handling things */ 57 &SDL_RAWINPUT_JoystickDriver, 58 #endif 59 #if defined(SDL_JOYSTICK_WGI) 60 &SDL_WGI_JoystickDriver, 61 #endif 62 #if defined(SDL_JOYSTICK_DINPUT) || defined(SDL_JOYSTICK_XINPUT) 63 &SDL_WINDOWS_JoystickDriver, 64 #endif 65 #ifdef SDL_JOYSTICK_LINUX 66 &SDL_LINUX_JoystickDriver, 67 #endif 68 #ifdef SDL_JOYSTICK_IOKIT 69 &SDL_DARWIN_JoystickDriver, 70 #endif 71 #if (defined(__MACOSX__) || defined(__IPHONEOS__) || defined(__TVOS__)) && !defined(SDL_JOYSTICK_DISABLED) 72 &SDL_IOS_JoystickDriver, 73 #endif 74 #ifdef SDL_JOYSTICK_ANDROID 75 &SDL_ANDROID_JoystickDriver, 76 #endif 77 #ifdef SDL_JOYSTICK_EMSCRIPTEN 78 &SDL_EMSCRIPTEN_JoystickDriver, 79 #endif 80 #ifdef SDL_JOYSTICK_HAIKU 81 &SDL_HAIKU_JoystickDriver, 82 #endif 83 #ifdef SDL_JOYSTICK_USBHID /* !!! FIXME: "USBHID" is a generic name, and doubly-confusing with HIDAPI next to it. This is the *BSD interface, rename this. */ 84 &SDL_BSD_JoystickDriver, 85 #endif 86 #ifdef SDL_JOYSTICK_VIRTUAL 87 &SDL_VIRTUAL_JoystickDriver, 88 #endif 89 #if defined(SDL_JOYSTICK_DUMMY) || defined(SDL_JOYSTICK_DISABLED) 90 &SDL_DUMMY_JoystickDriver 91 #endif 92 }; 93 static SDL_bool SDL_joystick_allows_background_events = SDL_FALSE; 94 static SDL_Joystick *SDL_joysticks = NULL; 95 static SDL_bool SDL_updating_joystick = SDL_FALSE; 96 static SDL_mutex *SDL_joystick_lock = NULL; /* This needs to support recursive locks */ 97 static SDL_atomic_t SDL_next_joystick_instance_id; 98 static int SDL_joystick_player_count = 0; 99 static SDL_JoystickID *SDL_joystick_players = NULL; 100 101 void 102 SDL_LockJoysticks(void) 103 { 104 if (SDL_joystick_lock) { 105 SDL_LockMutex(SDL_joystick_lock); 106 } 107 } 108 109 void 110 SDL_UnlockJoysticks(void) 111 { 112 if (SDL_joystick_lock) { 113 SDL_UnlockMutex(SDL_joystick_lock); 114 } 115 } 116 117 static int 118 SDL_FindFreePlayerIndex() 119 { 120 int player_index; 121 122 for (player_index = 0; player_index < SDL_joystick_player_count; ++player_index) { 123 if (SDL_joystick_players[player_index] == -1) { 124 return player_index; 125 } 126 } 127 return player_index; 128 } 129 130 static int 131 SDL_GetPlayerIndexForJoystickID(SDL_JoystickID instance_id) 132 { 133 int player_index; 134 135 for (player_index = 0; player_index < SDL_joystick_player_count; ++player_index) { 136 if (instance_id == SDL_joystick_players[player_index]) { 137 break; 138 } 139 } 140 if (player_index == SDL_joystick_player_count) { 141 player_index = -1; 142 } 143 return player_index; 144 } 145 146 static SDL_JoystickID 147 SDL_GetJoystickIDForPlayerIndex(int player_index) 148 { 149 if (player_index < 0 || player_index >= SDL_joystick_player_count) { 150 return -1; 151 } 152 return SDL_joystick_players[player_index]; 153 } 154 155 static SDL_bool 156 SDL_SetJoystickIDForPlayerIndex(int player_index, SDL_JoystickID instance_id) 157 { 158 SDL_JoystickID existing_instance = SDL_GetJoystickIDForPlayerIndex(player_index); 159 SDL_JoystickDriver *driver; 160 int device_index; 161 int existing_player_index; 162 163 if (player_index < 0) { 164 return SDL_FALSE; 165 } 166 if (player_index >= SDL_joystick_player_count) { 167 SDL_JoystickID *new_players = (SDL_JoystickID *)SDL_realloc(SDL_joystick_players, (player_index + 1)*sizeof(*SDL_joystick_players)); 168 if (!new_players) { 169 SDL_OutOfMemory(); 170 return SDL_FALSE; 171 } 172 173 SDL_joystick_players = new_players; 174 SDL_memset(&SDL_joystick_players[SDL_joystick_player_count], 0xFF, (player_index - SDL_joystick_player_count + 1) * sizeof(SDL_joystick_players[0])); 175 SDL_joystick_player_count = player_index + 1; 176 } else if (SDL_joystick_players[player_index] == instance_id) { 177 /* Joystick is already assigned the requested player index */ 178 return SDL_TRUE; 179 } 180 181 /* Clear the old player index */ 182 existing_player_index = SDL_GetPlayerIndexForJoystickID(instance_id); 183 if (existing_player_index >= 0) { 184 SDL_joystick_players[existing_player_index] = -1; 185 } 186 187 SDL_joystick_players[player_index] = instance_id; 188 189 /* Update the driver with the new index */ 190 device_index = SDL_JoystickGetDeviceIndexFromInstanceID(instance_id); 191 if (SDL_GetDriverAndJoystickIndex(device_index, &driver, &device_index)) { 192 driver->SetDevicePlayerIndex(device_index, player_index); 193 } 194 195 /* Move any existing joystick to another slot */ 196 if (existing_instance >= 0) { 197 SDL_SetJoystickIDForPlayerIndex(SDL_FindFreePlayerIndex(), existing_instance); 198 } 199 return SDL_TRUE; 200 } 201 202 static void SDLCALL 203 SDL_JoystickAllowBackgroundEventsChanged(void *userdata, const char *name, const char *oldValue, const char *hint) 204 { 205 if (hint && *hint == '1') { 206 SDL_joystick_allows_background_events = SDL_TRUE; 207 } else { 208 SDL_joystick_allows_background_events = SDL_FALSE; 209 } 210 } 211 212 int 213 SDL_JoystickInit(void) 214 { 215 int i, status; 216 217 SDL_GameControllerInitMappings(); 218 219 /* Create the joystick list lock */ 220 if (!SDL_joystick_lock) { 221 SDL_joystick_lock = SDL_CreateMutex(); 222 } 223 224 /* See if we should allow joystick events while in the background */ 225 SDL_AddHintCallback(SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, 226 SDL_JoystickAllowBackgroundEventsChanged, NULL); 227 228 #if !SDL_EVENTS_DISABLED 229 if (SDL_InitSubSystem(SDL_INIT_EVENTS) < 0) { 230 return -1; 231 } 232 #endif /* !SDL_EVENTS_DISABLED */ 233 234 status = -1; 235 for (i = 0; i < SDL_arraysize(SDL_joystick_drivers); ++i) { 236 if (SDL_joystick_drivers[i]->Init() >= 0) { 237 status = 0; 238 } 239 } 240 return status; 241 } 242 243 /* 244 * Count the number of joysticks attached to the system 245 */ 246 int 247 SDL_NumJoysticks(void) 248 { 249 int i, total_joysticks = 0; 250 SDL_LockJoysticks(); 251 for (i = 0; i < SDL_arraysize(SDL_joystick_drivers); ++i) { 252 total_joysticks += SDL_joystick_drivers[i]->GetCount(); 253 } 254 SDL_UnlockJoysticks(); 255 return total_joysticks; 256 } 257 258 /* 259 * Return the next available joystick instance ID 260 * This may be called by drivers from multiple threads, unprotected by any locks 261 */ 262 SDL_JoystickID SDL_GetNextJoystickInstanceID() 263 { 264 return SDL_AtomicIncRef(&SDL_next_joystick_instance_id); 265 } 266 267 /* 268 * Get the driver and device index for an API device index 269 * This should be called while the joystick lock is held, to prevent another thread from updating the list 270 */ 271 SDL_bool 272 SDL_GetDriverAndJoystickIndex(int device_index, SDL_JoystickDriver **driver, int *driver_index) 273 { 274 int i, num_joysticks, total_joysticks = 0; 275 276 if (device_index >= 0) { 277 for (i = 0; i < SDL_arraysize(SDL_joystick_drivers); ++i) { 278 num_joysticks = SDL_joystick_drivers[i]->GetCount(); 279 if (device_index < num_joysticks) { 280 *driver = SDL_joystick_drivers[i]; 281 *driver_index = device_index; 282 return SDL_TRUE; 283 } 284 device_index -= num_joysticks; 285 total_joysticks += num_joysticks; 286 } 287 } 288 289 SDL_SetError("There are %d joysticks available", total_joysticks); 290 return SDL_FALSE; 291 } 292 293 /* 294 * Get the implementation dependent name of a joystick 295 */ 296 const char * 297 SDL_JoystickNameForIndex(int device_index) 298 { 299 SDL_JoystickDriver *driver; 300 const char *name = NULL; 301 302 SDL_LockJoysticks(); 303 if (SDL_GetDriverAndJoystickIndex(device_index, &driver, &device_index)) { 304 name = driver->GetDeviceName(device_index); 305 } 306 SDL_UnlockJoysticks(); 307 308 /* FIXME: Really we should reference count this name so it doesn't go away after unlock */ 309 return name; 310 } 311 312 /* 313 * Get the player index of a joystick, or -1 if it's not available 314 */ 315 int 316 SDL_JoystickGetDevicePlayerIndex(int device_index) 317 { 318 int player_index; 319 320 SDL_LockJoysticks(); 321 player_index = SDL_GetPlayerIndexForJoystickID(SDL_JoystickGetDeviceInstanceID(device_index)); 322 SDL_UnlockJoysticks(); 323 324 return player_index; 325 } 326 327 /* 328 * Return true if this joystick is known to have all axes centered at zero 329 * This isn't generally needed unless the joystick never generates an initial axis value near zero, 330 * e.g. it's emulating axes with digital buttons 331 */ 332 static SDL_bool 333 SDL_JoystickAxesCenteredAtZero(SDL_Joystick *joystick) 334 { 335 static Uint32 zero_centered_joysticks[] = { 336 MAKE_VIDPID(0x0e8f, 0x3013), /* HuiJia SNES USB adapter */ 337 MAKE_VIDPID(0x05a0, 0x3232), /* 8Bitdo Zero Gamepad */ 338 }; 339 340 int i; 341 Uint32 id = MAKE_VIDPID(SDL_JoystickGetVendor(joystick), 342 SDL_JoystickGetProduct(joystick)); 343 344 /*printf("JOYSTICK '%s' VID/PID 0x%.4x/0x%.4x AXES: %d\n", joystick->name, vendor, product, joystick->naxes);*/ 345 346 if (joystick->naxes == 2) { 347 /* Assume D-pad or thumbstick style axes are centered at 0 */ 348 return SDL_TRUE; 349 } 350 351 for (i = 0; i < SDL_arraysize(zero_centered_joysticks); ++i) { 352 if (id == zero_centered_joysticks[i]) { 353 return SDL_TRUE; 354 } 355 } 356 return SDL_FALSE; 357 } 358 359 /* 360 * Open a joystick for use - the index passed as an argument refers to 361 * the N'th joystick on the system. This index is the value which will 362 * identify this joystick in future joystick events. 363 * 364 * This function returns a joystick identifier, or NULL if an error occurred. 365 */ 366 SDL_Joystick * 367 SDL_JoystickOpen(int device_index) 368 { 369 SDL_JoystickDriver *driver; 370 SDL_JoystickID instance_id; 371 SDL_Joystick *joystick; 372 SDL_Joystick *joysticklist; 373 const char *joystickname = NULL; 374 375 SDL_LockJoysticks(); 376 377 if (!SDL_GetDriverAndJoystickIndex(device_index, &driver, &device_index)) { 378 SDL_UnlockJoysticks(); 379 return NULL; 380 } 381 382 joysticklist = SDL_joysticks; 383 /* If the joystick is already open, return it 384 * it is important that we have a single joystick * for each instance id 385 */ 386 instance_id = driver->GetDeviceInstanceID(device_index); 387 while (joysticklist) { 388 if (instance_id == joysticklist->instance_id) { 389 joystick = joysticklist; 390 ++joystick->ref_count; 391 SDL_UnlockJoysticks(); 392 return joystick; 393 } 394 joysticklist = joysticklist->next; 395 } 396 397 /* Create and initialize the joystick */ 398 joystick = (SDL_Joystick *) SDL_calloc(sizeof(*joystick), 1); 399 if (joystick == NULL) { 400 SDL_OutOfMemory(); 401 SDL_UnlockJoysticks(); 402 return NULL; 403 } 404 joystick->driver = driver; 405 joystick->instance_id = instance_id; 406 joystick->attached = SDL_TRUE; 407 joystick->epowerlevel = SDL_JOYSTICK_POWER_UNKNOWN; 408 409 if (driver->Open(joystick, device_index) < 0) { 410 SDL_free(joystick); 411 SDL_UnlockJoysticks(); 412 return NULL; 413 } 414 415 joystickname = driver->GetDeviceName(device_index); 416 if (joystickname) { 417 joystick->name = SDL_strdup(joystickname); 418 } else { 419 joystick->name = NULL; 420 } 421 422 joystick->guid = driver->GetDeviceGUID(device_index); 423 424 if (joystick->naxes > 0) { 425 joystick->axes = (SDL_JoystickAxisInfo *) SDL_calloc(joystick->naxes, sizeof(SDL_JoystickAxisInfo)); 426 } 427 if (joystick->nhats > 0) { 428 joystick->hats = (Uint8 *) SDL_calloc(joystick->nhats, sizeof(Uint8)); 429 } 430 if (joystick->nballs > 0) { 431 joystick->balls = (struct balldelta *) SDL_calloc(joystick->nballs, sizeof(*joystick->balls)); 432 } 433 if (joystick->nbuttons > 0) { 434 joystick->buttons = (Uint8 *) SDL_calloc(joystick->nbuttons, sizeof(Uint8)); 435 } 436 if (((joystick->naxes > 0) && !joystick->axes) 437 || ((joystick->nhats > 0) && !joystick->hats) 438 || ((joystick->nballs > 0) && !joystick->balls) 439 || ((joystick->nbuttons > 0) && !joystick->buttons)) { 440 SDL_OutOfMemory(); 441 SDL_JoystickClose(joystick); 442 SDL_UnlockJoysticks(); 443 return NULL; 444 } 445 446 /* If this joystick is known to have all zero centered axes, skip the auto-centering code */ 447 if (SDL_JoystickAxesCenteredAtZero(joystick)) { 448 int i; 449 450 for (i = 0; i < joystick->naxes; ++i) { 451 joystick->axes[i].has_initial_value = SDL_TRUE; 452 } 453 } 454 455 joystick->is_game_controller = SDL_IsGameController(device_index); 456 457 /* Add joystick to list */ 458 ++joystick->ref_count; 459 /* Link the joystick in the list */ 460 joystick->next = SDL_joysticks; 461 SDL_joysticks = joystick; 462 463 SDL_UnlockJoysticks(); 464 465 driver->Update(joystick); 466 467 return joystick; 468 } 469 470 int 471 SDL_JoystickAttachVirtual(SDL_JoystickType type, 472 int naxes, int nbuttons, int nhats) 473 { 474 #if SDL_JOYSTICK_VIRTUAL 475 return SDL_JoystickAttachVirtualInner(type, naxes, nbuttons, nhats); 476 #else 477 return SDL_SetError("SDL not built with virtual-joystick support"); 478 #endif 479 } 480 481 int 482 SDL_JoystickDetachVirtual(int device_index) 483 { 484 #if SDL_JOYSTICK_VIRTUAL 485 SDL_JoystickDriver *driver; 486 487 SDL_LockJoysticks(); 488 if (SDL_GetDriverAndJoystickIndex(device_index, &driver, &device_index)) { 489 if (driver == &SDL_VIRTUAL_JoystickDriver) { 490 const int result = SDL_JoystickDetachVirtualInner(device_index); 491 SDL_UnlockJoysticks(); 492 return result; 493 } 494 } 495 SDL_UnlockJoysticks(); 496 497 return SDL_SetError("Virtual joystick not found at provided index"); 498 #else 499 return SDL_SetError("SDL not built with virtual-joystick support"); 500 #endif 501 } 502 503 SDL_bool 504 SDL_JoystickIsVirtual(int device_index) 505 { 506 #if SDL_JOYSTICK_VIRTUAL 507 SDL_JoystickDriver *driver; 508 int driver_device_index; 509 SDL_bool is_virtual = SDL_FALSE; 510 511 SDL_LockJoysticks(); 512 if (SDL_GetDriverAndJoystickIndex(device_index, &driver, &driver_device_index)) { 513 if (driver == &SDL_VIRTUAL_JoystickDriver) { 514 is_virtual = SDL_TRUE; 515 } 516 } 517 SDL_UnlockJoysticks(); 518 519 return is_virtual; 520 #else 521 return SDL_FALSE; 522 #endif 523 } 524 525 int 526 SDL_JoystickSetVirtualAxis(SDL_Joystick *joystick, int axis, Sint16 value) 527 { 528 #if SDL_JOYSTICK_VIRTUAL 529 return SDL_JoystickSetVirtualAxisInner(joystick, axis, value); 530 #else 531 return SDL_SetError("SDL not built with virtual-joystick support"); 532 #endif 533 } 534 535 int 536 SDL_JoystickSetVirtualButton(SDL_Joystick *joystick, int button, Uint8 value) 537 { 538 #if SDL_JOYSTICK_VIRTUAL 539 return SDL_JoystickSetVirtualButtonInner(joystick, button, value); 540 #else 541 return SDL_SetError("SDL not built with virtual-joystick support"); 542 #endif 543 } 544 545 int 546 SDL_JoystickSetVirtualHat(SDL_Joystick *joystick, int hat, Uint8 value) 547 { 548 #if SDL_JOYSTICK_VIRTUAL 549 return SDL_JoystickSetVirtualHatInner(joystick, hat, value); 550 #else 551 return SDL_SetError("SDL not built with virtual-joystick support"); 552 #endif 553 } 554 555 /* 556 * Checks to make sure the joystick is valid. 557 */ 558 SDL_bool 559 SDL_PrivateJoystickValid(SDL_Joystick *joystick) 560 { 561 SDL_bool valid; 562 563 if (joystick == NULL) { 564 SDL_SetError("Joystick hasn't been opened yet"); 565 valid = SDL_FALSE; 566 } else { 567 valid = SDL_TRUE; 568 } 569 570 return valid; 571 } 572 573 SDL_bool 574 SDL_PrivateJoystickGetAutoGamepadMapping(int device_index, SDL_GamepadMapping * out) 575 { 576 SDL_JoystickDriver *driver; 577 SDL_bool is_ok = SDL_FALSE; 578 579 SDL_LockJoysticks(); 580 if (SDL_GetDriverAndJoystickIndex(device_index, &driver, &device_index)) { 581 is_ok = driver->GetGamepadMapping(device_index, out); 582 } 583 SDL_UnlockJoysticks(); 584 585 return is_ok; 586 } 587 588 /* 589 * Get the number of multi-dimensional axis controls on a joystick 590 */ 591 int 592 SDL_JoystickNumAxes(SDL_Joystick *joystick) 593 { 594 if (!SDL_PrivateJoystickValid(joystick)) { 595 return -1; 596 } 597 return joystick->naxes; 598 } 599 600 /* 601 * Get the number of hats on a joystick 602 */ 603 int 604 SDL_JoystickNumHats(SDL_Joystick *joystick) 605 { 606 if (!SDL_PrivateJoystickValid(joystick)) { 607 return -1; 608 } 609 return joystick->nhats; 610 } 611 612 /* 613 * Get the number of trackballs on a joystick 614 */ 615 int 616 SDL_JoystickNumBalls(SDL_Joystick *joystick) 617 { 618 if (!SDL_PrivateJoystickValid(joystick)) { 619 return -1; 620 } 621 return joystick->nballs; 622 } 623 624 /* 625 * Get the number of buttons on a joystick 626 */ 627 int 628 SDL_JoystickNumButtons(SDL_Joystick *joystick) 629 { 630 if (!SDL_PrivateJoystickValid(joystick)) { 631 return -1; 632 } 633 return joystick->nbuttons; 634 } 635 636 /* 637 * Get the current state of an axis control on a joystick 638 */ 639 Sint16 640 SDL_JoystickGetAxis(SDL_Joystick *joystick, int axis) 641 { 642 Sint16 state; 643 644 if (!SDL_PrivateJoystickValid(joystick)) { 645 return 0; 646 } 647 if (axis < joystick->naxes) { 648 state = joystick->axes[axis].value; 649 } else { 650 SDL_SetError("Joystick only has %d axes", joystick->naxes); 651 state = 0; 652 } 653 return state; 654 } 655 656 /* 657 * Get the initial state of an axis control on a joystick 658 */ 659 SDL_bool 660 SDL_JoystickGetAxisInitialState(SDL_Joystick *joystick, int axis, Sint16 *state) 661 { 662 if (!SDL_PrivateJoystickValid(joystick)) { 663 return SDL_FALSE; 664 } 665 if (axis >= joystick->naxes) { 666 SDL_SetError("Joystick only has %d axes", joystick->naxes); 667 return SDL_FALSE; 668 } 669 if (state) { 670 *state = joystick->axes[axis].initial_value; 671 } 672 return joystick->axes[axis].has_initial_value; 673 } 674 675 /* 676 * Get the current state of a hat on a joystick 677 */ 678 Uint8 679 SDL_JoystickGetHat(SDL_Joystick *joystick, int hat) 680 { 681 Uint8 state; 682 683 if (!SDL_PrivateJoystickValid(joystick)) { 684 return 0; 685 } 686 if (hat < joystick->nhats) { 687 state = joystick->hats[hat]; 688 } else { 689 SDL_SetError("Joystick only has %d hats", joystick->nhats); 690 state = 0; 691 } 692 return state; 693 } 694 695 /* 696 * Get the ball axis change since the last poll 697 */ 698 int 699 SDL_JoystickGetBall(SDL_Joystick *joystick, int ball, int *dx, int *dy) 700 { 701 int retval; 702 703 if (!SDL_PrivateJoystickValid(joystick)) { 704 return -1; 705 } 706 707 retval = 0; 708 if (ball < joystick->nballs) { 709 if (dx) { 710 *dx = joystick->balls[ball].dx; 711 } 712 if (dy) { 713 *dy = joystick->balls[ball].dy; 714 } 715 joystick->balls[ball].dx = 0; 716 joystick->balls[ball].dy = 0; 717 } else { 718 return SDL_SetError("Joystick only has %d balls", joystick->nballs); 719 } 720 return retval; 721 } 722 723 /* 724 * Get the current state of a button on a joystick 725 */ 726 Uint8 727 SDL_JoystickGetButton(SDL_Joystick *joystick, int button) 728 { 729 Uint8 state; 730 731 if (!SDL_PrivateJoystickValid(joystick)) { 732 return 0; 733 } 734 if (button < joystick->nbuttons) { 735 state = joystick->buttons[button]; 736 } else { 737 SDL_SetError("Joystick only has %d buttons", joystick->nbuttons); 738 state = 0; 739 } 740 return state; 741 } 742 743 /* 744 * Return if the joystick in question is currently attached to the system, 745 * \return SDL_FALSE if not plugged in, SDL_TRUE if still present. 746 */ 747 SDL_bool 748 SDL_JoystickGetAttached(SDL_Joystick *joystick) 749 { 750 if (!SDL_PrivateJoystickValid(joystick)) { 751 return SDL_FALSE; 752 } 753 754 return joystick->attached; 755 } 756 757 /* 758 * Get the instance id for this opened joystick 759 */ 760 SDL_JoystickID 761 SDL_JoystickInstanceID(SDL_Joystick *joystick) 762 { 763 if (!SDL_PrivateJoystickValid(joystick)) { 764 return -1; 765 } 766 767 return joystick->instance_id; 768 } 769 770 /* 771 * Return the SDL_Joystick associated with an instance id. 772 */ 773 SDL_Joystick * 774 SDL_JoystickFromInstanceID(SDL_JoystickID instance_id) 775 { 776 SDL_Joystick *joystick; 777 778 SDL_LockJoysticks(); 779 for (joystick = SDL_joysticks; joystick; joystick = joystick->next) { 780 if (joystick->instance_id == instance_id) { 781 break; 782 } 783 } 784 SDL_UnlockJoysticks(); 785 return joystick; 786 } 787 788 /** 789 * Return the SDL_Joystick associated with a player index. 790 */ 791 SDL_Joystick * 792 SDL_JoystickFromPlayerIndex(int player_index) 793 { 794 SDL_JoystickID instance_id; 795 SDL_Joystick *joystick; 796 797 SDL_LockJoysticks(); 798 instance_id = SDL_GetJoystickIDForPlayerIndex(player_index); 799 for (joystick = SDL_joysticks; joystick; joystick = joystick->next) { 800 if (joystick->instance_id == instance_id) { 801 break; 802 } 803 } 804 SDL_UnlockJoysticks(); 805 return joystick; 806 } 807 808 /* 809 * Get the friendly name of this joystick 810 */ 811 const char * 812 SDL_JoystickName(SDL_Joystick *joystick) 813 { 814 if (!SDL_PrivateJoystickValid(joystick)) { 815 return NULL; 816 } 817 818 return joystick->name; 819 } 820 821 /** 822 * Get the player index of an opened joystick, or -1 if it's not available 823 */ 824 int 825 SDL_JoystickGetPlayerIndex(SDL_Joystick *joystick) 826 { 827 int player_index; 828 829 if (!SDL_PrivateJoystickValid(joystick)) { 830 return -1; 831 } 832 833 SDL_LockJoysticks(); 834 player_index = SDL_GetPlayerIndexForJoystickID(joystick->instance_id); 835 SDL_UnlockJoysticks(); 836 837 return player_index; 838 } 839 840 /** 841 * Set the player index of an opened joystick 842 */ 843 void 844 SDL_JoystickSetPlayerIndex(SDL_Joystick *joystick, int player_index) 845 { 846 if (!SDL_PrivateJoystickValid(joystick)) { 847 return; 848 } 849 850 SDL_LockJoysticks(); 851 SDL_SetJoystickIDForPlayerIndex(player_index, joystick->instance_id); 852 SDL_UnlockJoysticks(); 853 } 854 855 int 856 SDL_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble, Uint32 duration_ms) 857 { 858 int result; 859 860 if (!SDL_PrivateJoystickValid(joystick)) { 861 return -1; 862 } 863 864 SDL_LockJoysticks(); 865 if (low_frequency_rumble == joystick->low_frequency_rumble && 866 high_frequency_rumble == joystick->high_frequency_rumble) { 867 /* Just update the expiration */ 868 result = 0; 869 } else { 870 result = joystick->driver->Rumble(joystick, low_frequency_rumble, high_frequency_rumble); 871 } 872 873 /* Save the rumble value regardless of success, so we don't spam the driver */ 874 joystick->low_frequency_rumble = low_frequency_rumble; 875 joystick->high_frequency_rumble = high_frequency_rumble; 876 877 if ((low_frequency_rumble || high_frequency_rumble) && duration_ms) { 878 joystick->rumble_expiration = SDL_GetTicks() + SDL_min(duration_ms, SDL_MAX_RUMBLE_DURATION_MS); 879 if (!joystick->rumble_expiration) { 880 joystick->rumble_expiration = 1; 881 } 882 } else { 883 joystick->rumble_expiration = 0; 884 } 885 SDL_UnlockJoysticks(); 886 887 return result; 888 } 889 890 int 891 SDL_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble, Uint32 duration_ms) 892 { 893 int result; 894 895 if (!SDL_PrivateJoystickValid(joystick)) { 896 return -1; 897 } 898 899 SDL_LockJoysticks(); 900 if (left_rumble == joystick->left_trigger_rumble && right_rumble == joystick->right_trigger_rumble) { 901 /* Just update the expiration */ 902 result = 0; 903 } else { 904 result = joystick->driver->RumbleTriggers(joystick, left_rumble, right_rumble); 905 } 906 907 /* Save the rumble value regardless of success, so we don't spam the driver */ 908 joystick->left_trigger_rumble = left_rumble; 909 joystick->right_trigger_rumble = right_rumble; 910 911 if ((left_rumble || right_rumble) && duration_ms) { 912 joystick->trigger_rumble_expiration = SDL_GetTicks() + SDL_min(duration_ms, SDL_MAX_RUMBLE_DURATION_MS); 913 if (!joystick->trigger_rumble_expiration) { 914 joystick->trigger_rumble_expiration = 1; 915 } 916 } else { 917 joystick->trigger_rumble_expiration = 0; 918 } 919 SDL_UnlockJoysticks(); 920 921 return result; 922 } 923 924 SDL_bool 925 SDL_JoystickHasLED(SDL_Joystick *joystick) 926 { 927 SDL_bool result; 928 929 if (!SDL_PrivateJoystickValid(joystick)) { 930 return SDL_FALSE; 931 } 932 933 SDL_LockJoysticks(); 934 935 result = joystick->driver->HasLED(joystick); 936 937 SDL_UnlockJoysticks(); 938 939 return result; 940 } 941 942 int 943 SDL_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue) 944 { 945 int result; 946 947 if (!SDL_PrivateJoystickValid(joystick)) { 948 return -1; 949 } 950 951 SDL_LockJoysticks(); 952 953 if (red == joystick->led_red && 954 green == joystick->led_green && 955 blue == joystick->led_blue) { 956 /* Avoid spamming the driver */ 957 result = 0; 958 } else { 959 result = joystick->driver->SetLED(joystick, red, green, blue); 960 } 961 962 /* Save the LED value regardless of success, so we don't spam the driver */ 963 joystick->led_red = red; 964 joystick->led_green = green; 965 joystick->led_blue = blue; 966 967 SDL_UnlockJoysticks(); 968 969 return result; 970 } 971 972 /* 973 * Close a joystick previously opened with SDL_JoystickOpen() 974 */ 975 void 976 SDL_JoystickClose(SDL_Joystick *joystick) 977 { 978 SDL_Joystick *joysticklist; 979 SDL_Joystick *joysticklistprev; 980 int i; 981 982 if (!SDL_PrivateJoystickValid(joystick)) { 983 return; 984 } 985 986 SDL_LockJoysticks(); 987 988 /* First decrement ref count */ 989 if (--joystick->ref_count > 0) { 990 SDL_UnlockJoysticks(); 991 return; 992 } 993 994 if (SDL_updating_joystick) { 995 SDL_UnlockJoysticks(); 996 return; 997 } 998 999 if (joystick->rumble_expiration) { 1000 SDL_JoystickRumble(joystick, 0, 0, 0); 1001 } 1002 if (joystick->trigger_rumble_expiration) { 1003 SDL_JoystickRumbleTriggers(joystick, 0, 0, 0); 1004 } 1005 1006 joystick->driver->Close(joystick); 1007 joystick->hwdata = NULL; 1008 1009 joysticklist = SDL_joysticks; 1010 joysticklistprev = NULL; 1011 while (joysticklist) { 1012 if (joystick == joysticklist) { 1013 if (joysticklistprev) { 1014 /* unlink this entry */ 1015 joysticklistprev->next = joysticklist->next; 1016 } else { 1017 SDL_joysticks = joystick->next; 1018 } 1019 break; 1020 } 1021 joysticklistprev = joysticklist; 1022 joysticklist = joysticklist->next; 1023 } 1024 1025 SDL_free(joystick->name); 1026 SDL_free(joystick->serial); 1027 1028 /* Free the data associated with this joystick */ 1029 SDL_free(joystick->axes); 1030 SDL_free(joystick->hats); 1031 SDL_free(joystick->balls); 1032 SDL_free(joystick->buttons); 1033 for (i = 0; i < joystick->ntouchpads; i++) { 1034 SDL_JoystickTouchpadInfo *touchpad = &joystick->touchpads[i]; 1035 SDL_free(touchpad->fingers); 1036 } 1037 SDL_free(joystick->touchpads); 1038 SDL_free(joystick->sensors); 1039 SDL_free(joystick); 1040 1041 SDL_UnlockJoysticks(); 1042 } 1043 1044 void 1045 SDL_JoystickQuit(void) 1046 { 1047 int i; 1048 1049 /* Make sure we're not getting called in the middle of updating joysticks */ 1050 SDL_LockJoysticks(); 1051 while (SDL_updating_joystick) { 1052 SDL_UnlockJoysticks(); 1053 SDL_Delay(1); 1054 SDL_LockJoysticks(); 1055 } 1056 1057 /* Stop the event polling */ 1058 while (SDL_joysticks) { 1059 SDL_joysticks->ref_count = 1; 1060 SDL_JoystickClose(SDL_joysticks); 1061 } 1062 1063 /* Quit the joystick setup */ 1064 for (i = 0; i < SDL_arraysize(SDL_joystick_drivers); ++i) { 1065 SDL_joystick_drivers[i]->Quit(); 1066 } 1067 1068 if (SDL_joystick_players) { 1069 SDL_free(SDL_joystick_players); 1070 SDL_joystick_players = NULL; 1071 SDL_joystick_player_count = 0; 1072 } 1073 SDL_UnlockJoysticks(); 1074 1075 #if !SDL_EVENTS_DISABLED 1076 SDL_QuitSubSystem(SDL_INIT_EVENTS); 1077 #endif 1078 1079 SDL_DelHintCallback(SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, 1080 SDL_JoystickAllowBackgroundEventsChanged, NULL); 1081 1082 if (SDL_joystick_lock) { 1083 SDL_mutex *mutex = SDL_joystick_lock; 1084 SDL_joystick_lock = NULL; 1085 SDL_DestroyMutex(mutex); 1086 } 1087 1088 SDL_GameControllerQuitMappings(); 1089 } 1090 1091 1092 static SDL_bool 1093 SDL_PrivateJoystickShouldIgnoreEvent() 1094 { 1095 if (SDL_joystick_allows_background_events) { 1096 return SDL_FALSE; 1097 } 1098 1099 if (SDL_HasWindows() && SDL_GetKeyboardFocus() == NULL) { 1100 /* We have windows but we don't have focus, ignore the event. */ 1101 return SDL_TRUE; 1102 } 1103 return SDL_FALSE; 1104 } 1105 1106 /* These are global for SDL_sysjoystick.c and SDL_events.c */ 1107 1108 void SDL_PrivateJoystickAddTouchpad(SDL_Joystick *joystick, int nfingers) 1109 { 1110 int ntouchpads = joystick->ntouchpads + 1; 1111 SDL_JoystickTouchpadInfo *touchpads = (SDL_JoystickTouchpadInfo *)SDL_realloc(joystick->touchpads, (ntouchpads * sizeof(SDL_JoystickTouchpadInfo))); 1112 if (touchpads) { 1113 SDL_JoystickTouchpadInfo *touchpad = &touchpads[ntouchpads - 1]; 1114 SDL_JoystickTouchpadFingerInfo *fingers = (SDL_JoystickTouchpadFingerInfo *)SDL_calloc(nfingers, sizeof(SDL_JoystickTouchpadFingerInfo)); 1115 1116 if (fingers) { 1117 touchpad->nfingers = nfingers; 1118 touchpad->fingers = fingers; 1119 } else { 1120 /* Out of memory, this touchpad won't be active */ 1121 touchpad->nfingers = 0; 1122 touchpad->fingers = NULL; 1123 } 1124 1125 joystick->ntouchpads = ntouchpads; 1126 joystick->touchpads = touchpads; 1127 } 1128 } 1129 1130 void SDL_PrivateJoystickAddSensor(SDL_Joystick *joystick, SDL_SensorType type) 1131 { 1132 int nsensors = joystick->nsensors + 1; 1133 SDL_JoystickSensorInfo *sensors = (SDL_JoystickSensorInfo *)SDL_realloc(joystick->sensors, (nsensors * sizeof(SDL_JoystickSensorInfo))); 1134 if (sensors) { 1135 SDL_JoystickSensorInfo *sensor = &sensors[nsensors - 1]; 1136 1137 SDL_zerop(sensor); 1138 sensor->type = type; 1139 1140 joystick->nsensors = nsensors; 1141 joystick->sensors = sensors; 1142 } 1143 } 1144 1145 void SDL_PrivateJoystickAdded(SDL_JoystickID device_instance) 1146 { 1147 SDL_JoystickDriver *driver; 1148 int driver_device_index; 1149 int player_index = -1; 1150 int device_index = SDL_JoystickGetDeviceIndexFromInstanceID(device_instance); 1151 if (device_index < 0) { 1152 return; 1153 } 1154 1155 SDL_LockJoysticks(); 1156 if (SDL_GetDriverAndJoystickIndex(device_index, &driver, &driver_device_index)) { 1157 player_index = driver->GetDevicePlayerIndex(driver_device_index); 1158 } 1159 if (player_index < 0 && SDL_IsGameController(device_index)) { 1160 player_index = SDL_FindFreePlayerIndex(); 1161 } 1162 if (player_index >= 0) { 1163 SDL_SetJoystickIDForPlayerIndex(player_index, device_instance); 1164 } 1165 SDL_UnlockJoysticks(); 1166 1167 #if !SDL_EVENTS_DISABLED 1168 { 1169 SDL_Event event; 1170 1171 event.type = SDL_JOYDEVICEADDED; 1172 1173 if (SDL_GetEventState(event.type) == SDL_ENABLE) { 1174 event.jdevice.which = device_index; 1175 SDL_PushEvent(&event); 1176 } 1177 } 1178 #endif /* !SDL_EVENTS_DISABLED */ 1179 } 1180 1181 /* 1182 * If there is an existing add event in the queue, it needs to be modified 1183 * to have the right value for which, because the number of controllers in 1184 * the system is now one less. 1185 */ 1186 static void UpdateEventsForDeviceRemoval(int device_index) 1187 { 1188 int i, num_events; 1189 SDL_Event *events; 1190 SDL_bool isstack; 1191 1192 num_events = SDL_PeepEvents(NULL, 0, SDL_PEEKEVENT, SDL_JOYDEVICEADDED, SDL_JOYDEVICEADDED); 1193 if (num_events <= 0) { 1194 return; 1195 } 1196 1197 events = SDL_small_alloc(SDL_Event, num_events, &isstack); 1198 if (!events) { 1199 return; 1200 } 1201 1202 num_events = SDL_PeepEvents(events, num_events, SDL_GETEVENT, SDL_JOYDEVICEADDED, SDL_JOYDEVICEADDED); 1203 for (i = 0; i < num_events; ++i) { 1204 if (events[i].cdevice.which < device_index) { 1205 /* No change for index values lower than the removed device */ 1206 } 1207 else if (events[i].cdevice.which == device_index) { 1208 /* Drop this event entirely */ 1209 SDL_memmove(&events[i], &events[i + 1], sizeof(*events) * (num_events - (i + 1))); 1210 --num_events; 1211 --i; 1212 } 1213 else { 1214 /* Fix up the device index if greater than the removed device */ 1215 --events[i].cdevice.which; 1216 } 1217 } 1218 SDL_PeepEvents(events, num_events, SDL_ADDEVENT, 0, 0); 1219 1220 SDL_small_free(events, isstack); 1221 } 1222 1223 static void 1224 SDL_PrivateJoystickForceRecentering(SDL_Joystick *joystick) 1225 { 1226 int i, j; 1227 1228 /* Tell the app that everything is centered/unpressed... */ 1229 for (i = 0; i < joystick->naxes; i++) { 1230 if (joystick->axes[i].has_initial_value) { 1231 SDL_PrivateJoystickAxis(joystick, i, joystick->axes[i].zero); 1232 } 1233 } 1234 1235 for (i = 0; i < joystick->nbuttons; i++) { 1236 SDL_PrivateJoystickButton(joystick, i, SDL_RELEASED); 1237 } 1238 1239 for (i = 0; i < joystick->nhats; i++) { 1240 SDL_PrivateJoystickHat(joystick, i, SDL_HAT_CENTERED); 1241 } 1242 1243 for (i = 0; i < joystick->ntouchpads; i++) { 1244 SDL_JoystickTouchpadInfo *touchpad = &joystick->touchpads[i]; 1245 1246 for (j = 0; j < touchpad->nfingers; ++j) { 1247 SDL_PrivateJoystickTouchpad(joystick, i, j, SDL_RELEASED, 0.0f, 0.0f, 0.0f); 1248 } 1249 } 1250 1251 } 1252 1253 void SDL_PrivateJoystickRemoved(SDL_JoystickID device_instance) 1254 { 1255 SDL_Joystick *joystick = NULL; 1256 int player_index; 1257 int device_index; 1258 #if !SDL_EVENTS_DISABLED 1259 SDL_Event event; 1260 #endif 1261 1262 /* Find this joystick... */ 1263 device_index = 0; 1264 for (joystick = SDL_joysticks; joystick; joystick = joystick->next) { 1265 if (joystick->instance_id == device_instance) { 1266 SDL_PrivateJoystickForceRecentering(joystick); 1267 joystick->attached = SDL_FALSE; 1268 break; 1269 } 1270 1271 ++device_index; 1272 } 1273 1274 #if !SDL_EVENTS_DISABLED 1275 SDL_zero(event); 1276 event.type = SDL_JOYDEVICEREMOVED; 1277 1278 if (SDL_GetEventState(event.type) == SDL_ENABLE) { 1279 event.jdevice.which = device_instance; 1280 SDL_PushEvent(&event); 1281 } 1282 1283 UpdateEventsForDeviceRemoval(device_index); 1284 #endif /* !SDL_EVENTS_DISABLED */ 1285 1286 SDL_LockJoysticks(); 1287 player_index = SDL_GetPlayerIndexForJoystickID(device_instance); 1288 if (player_index >= 0) { 1289 SDL_joystick_players[player_index] = -1; 1290 } 1291 SDL_UnlockJoysticks(); 1292 } 1293 1294 int 1295 SDL_PrivateJoystickAxis(SDL_Joystick *joystick, Uint8 axis, Sint16 value) 1296 { 1297 int posted; 1298 SDL_JoystickAxisInfo *info; 1299 1300 /* Make sure we're not getting garbage or duplicate events */ 1301 if (axis >= joystick->naxes) { 1302 return 0; 1303 } 1304 1305 info = &joystick->axes[axis]; 1306 if (!info->has_initial_value || 1307 (!info->has_second_value && (info->initial_value <= -32767 || info->initial_value == 32767) && SDL_abs(value) < (SDL_JOYSTICK_AXIS_MAX / 4))) { 1308 info->initial_value = value; 1309 info->value = value; 1310 info->zero = value; 1311 info->has_initial_value = SDL_TRUE; 1312 } else if (value == info->value) { 1313 return 0; 1314 } else { 1315 info->has_second_value = SDL_TRUE; 1316 } 1317 if (!info->sent_initial_value) { 1318 /* Make sure we don't send motion until there's real activity on this axis */ 1319 const int MAX_ALLOWED_JITTER = SDL_JOYSTICK_AXIS_MAX / 80; /* ShanWan PS3 controller needed 96 */ 1320 if (SDL_abs(value - info->value) <= MAX_ALLOWED_JITTER) { 1321 return 0; 1322 } 1323 info->sent_initial_value = SDL_TRUE; 1324 info->value = ~value; /* Just so we pass the check above */ 1325 SDL_PrivateJoystickAxis(joystick, axis, info->initial_value); 1326 } 1327 1328 /* We ignore events if we don't have keyboard focus, except for centering 1329 * events. 1330 */ 1331 if (SDL_PrivateJoystickShouldIgnoreEvent()) { 1332 if ((value > info->zero && value >= info->value) || 1333 (value < info->zero && value <= info->value)) { 1334 return 0; 1335 } 1336 } 1337 1338 /* Update internal joystick state */ 1339 info->value = value; 1340 1341 /* Post the event, if desired */ 1342 posted = 0; 1343 #if !SDL_EVENTS_DISABLED 1344 if (SDL_GetEventState(SDL_JOYAXISMOTION) == SDL_ENABLE) { 1345 SDL_Event event; 1346 event.type = SDL_JOYAXISMOTION; 1347 event.jaxis.which = joystick->instance_id; 1348 event.jaxis.axis = axis; 1349 event.jaxis.value = value; 1350 posted = SDL_PushEvent(&event) == 1; 1351 } 1352 #endif /* !SDL_EVENTS_DISABLED */ 1353 return posted; 1354 } 1355 1356 int 1357 SDL_PrivateJoystickHat(SDL_Joystick *joystick, Uint8 hat, Uint8 value) 1358 { 1359 int posted; 1360 1361 /* Make sure we're not getting garbage or duplicate events */ 1362 if (hat >= joystick->nhats) { 1363 return 0; 1364 } 1365 if (value == joystick->hats[hat]) { 1366 return 0; 1367 } 1368 1369 /* We ignore events if we don't have keyboard focus, except for centering 1370 * events. 1371 */ 1372 if (SDL_PrivateJoystickShouldIgnoreEvent()) { 1373 if (value != SDL_HAT_CENTERED) { 1374 return 0; 1375 } 1376 } 1377 1378 /* Update internal joystick state */ 1379 joystick->hats[hat] = value; 1380 1381 /* Post the event, if desired */ 1382 posted = 0; 1383 #if !SDL_EVENTS_DISABLED 1384 if (SDL_GetEventState(SDL_JOYHATMOTION) == SDL_ENABLE) { 1385 SDL_Event event; 1386 event.jhat.type = SDL_JOYHATMOTION; 1387 event.jhat.which = joystick->instance_id; 1388 event.jhat.hat = hat; 1389 event.jhat.value = value; 1390 posted = SDL_PushEvent(&event) == 1; 1391 } 1392 #endif /* !SDL_EVENTS_DISABLED */ 1393 return posted; 1394 } 1395 1396 int 1397 SDL_PrivateJoystickBall(SDL_Joystick *joystick, Uint8 ball, 1398 Sint16 xrel, Sint16 yrel) 1399 { 1400 int posted; 1401 1402 /* Make sure we're not getting garbage events */ 1403 if (ball >= joystick->nballs) { 1404 return 0; 1405 } 1406 1407 /* We ignore events if we don't have keyboard focus. */ 1408 if (SDL_PrivateJoystickShouldIgnoreEvent()) { 1409 return 0; 1410 } 1411 1412 /* Update internal mouse state */ 1413 joystick->balls[ball].dx += xrel; 1414 joystick->balls[ball].dy += yrel; 1415 1416 /* Post the event, if desired */ 1417 posted = 0; 1418 #if !SDL_EVENTS_DISABLED 1419 if (SDL_GetEventState(SDL_JOYBALLMOTION) == SDL_ENABLE) { 1420 SDL_Event event; 1421 event.jball.type = SDL_JOYBALLMOTION; 1422 event.jball.which = joystick->instance_id; 1423 event.jball.ball = ball; 1424 event.jball.xrel = xrel; 1425 event.jball.yrel = yrel; 1426 posted = SDL_PushEvent(&event) == 1; 1427 } 1428 #endif /* !SDL_EVENTS_DISABLED */ 1429 return posted; 1430 } 1431 1432 int 1433 SDL_PrivateJoystickButton(SDL_Joystick *joystick, Uint8 button, Uint8 state) 1434 { 1435 int posted; 1436 #if !SDL_EVENTS_DISABLED 1437 SDL_Event event; 1438 1439 switch (state) { 1440 case SDL_PRESSED: 1441 event.type = SDL_JOYBUTTONDOWN; 1442 break; 1443 case SDL_RELEASED: 1444 event.type = SDL_JOYBUTTONUP; 1445 break; 1446 default: 1447 /* Invalid state -- bail */ 1448 return 0; 1449 } 1450 #endif /* !SDL_EVENTS_DISABLED */ 1451 1452 /* Make sure we're not getting garbage or duplicate events */ 1453 if (button >= joystick->nbuttons) { 1454 return 0; 1455 } 1456 if (state == joystick->buttons[button]) { 1457 return 0; 1458 } 1459 1460 /* We ignore events if we don't have keyboard focus, except for button 1461 * release. */ 1462 if (SDL_PrivateJoystickShouldIgnoreEvent()) { 1463 if (state == SDL_PRESSED) { 1464 return 0; 1465 } 1466 } 1467 1468 /* Update internal joystick state */ 1469 joystick->buttons[button] = state; 1470 1471 /* Post the event, if desired */ 1472 posted = 0; 1473 #if !SDL_EVENTS_DISABLED 1474 if (SDL_GetEventState(event.type) == SDL_ENABLE) { 1475 event.jbutton.which = joystick->instance_id; 1476 event.jbutton.button = button; 1477 event.jbutton.state = state; 1478 posted = SDL_PushEvent(&event) == 1; 1479 } 1480 #endif /* !SDL_EVENTS_DISABLED */ 1481 return posted; 1482 } 1483 1484 void 1485 SDL_JoystickUpdate(void) 1486 { 1487 int i; 1488 SDL_Joystick *joystick, *next; 1489 1490 if (!SDL_WasInit(SDL_INIT_JOYSTICK)) { 1491 return; 1492 } 1493 1494 SDL_LockJoysticks(); 1495 1496 if (SDL_updating_joystick) { 1497 /* The joysticks are already being updated */ 1498 SDL_UnlockJoysticks(); 1499 return; 1500 } 1501 1502 SDL_updating_joystick = SDL_TRUE; 1503 1504 /* Make sure the list is unlocked while dispatching events to prevent application deadlocks */ 1505 SDL_UnlockJoysticks(); 1506 1507 #ifdef SDL_JOYSTICK_HIDAPI 1508 /* Special function for HIDAPI devices, as a single device can provide multiple SDL_Joysticks */ 1509 HIDAPI_UpdateDevices(); 1510 #endif /* SDL_JOYSTICK_HIDAPI */ 1511 1512 for (joystick = SDL_joysticks; joystick; joystick = joystick->next) { 1513 if (joystick->attached) { 1514 /* This should always be true, but seeing a crash in the wild...? */ 1515 if (joystick->driver) { 1516 joystick->driver->Update(joystick); 1517 } 1518 1519 if (joystick->delayed_guide_button) { 1520 SDL_GameControllerHandleDelayedGuideButton(joystick); 1521 } 1522 } 1523 1524 if (joystick->rumble_expiration) { 1525 SDL_LockJoysticks(); 1526 /* Double check now that the lock is held */ 1527 if (joystick->rumble_expiration && 1528 SDL_TICKS_PASSED(SDL_GetTicks(), joystick->rumble_expiration)) { 1529 SDL_JoystickRumble(joystick, 0, 0, 0); 1530 } 1531 SDL_UnlockJoysticks(); 1532 } 1533 1534 if (joystick->trigger_rumble_expiration) { 1535 SDL_LockJoysticks(); 1536 /* Double check now that the lock is held */ 1537 if (joystick->trigger_rumble_expiration && 1538 SDL_TICKS_PASSED(SDL_GetTicks(), joystick->trigger_rumble_expiration)) { 1539 SDL_JoystickRumbleTriggers(joystick, 0, 0, 0); 1540 } 1541 SDL_UnlockJoysticks(); 1542 } 1543 } 1544 1545 SDL_LockJoysticks(); 1546 1547 SDL_updating_joystick = SDL_FALSE; 1548 1549 /* If any joysticks were closed while updating, free them here */ 1550 for (joystick = SDL_joysticks; joystick; joystick = next) { 1551 next = joystick->next; 1552 if (joystick->ref_count <= 0) { 1553 SDL_JoystickClose(joystick); 1554 } 1555 } 1556 1557 /* this needs to happen AFTER walking the joystick list above, so that any 1558 dangling hardware data from removed devices can be free'd 1559 */ 1560 for (i = 0; i < SDL_arraysize(SDL_joystick_drivers); ++i) { 1561 SDL_joystick_drivers[i]->Detect(); 1562 } 1563 1564 SDL_UnlockJoysticks(); 1565 } 1566 1567 int 1568 SDL_JoystickEventState(int state) 1569 { 1570 #if SDL_EVENTS_DISABLED 1571 return SDL_DISABLE; 1572 #else 1573 const Uint32 event_list[] = { 1574 SDL_JOYAXISMOTION, SDL_JOYBALLMOTION, SDL_JOYHATMOTION, 1575 SDL_JOYBUTTONDOWN, SDL_JOYBUTTONUP, SDL_JOYDEVICEADDED, SDL_JOYDEVICEREMOVED 1576 }; 1577 unsigned int i; 1578 1579 switch (state) { 1580 case SDL_QUERY: 1581 state = SDL_DISABLE; 1582 for (i = 0; i < SDL_arraysize(event_list); ++i) { 1583 state = SDL_EventState(event_list[i], SDL_QUERY); 1584 if (state == SDL_ENABLE) { 1585 break; 1586 } 1587 } 1588 break; 1589 default: 1590 for (i = 0; i < SDL_arraysize(event_list); ++i) { 1591 SDL_EventState(event_list[i], state); 1592 } 1593 break; 1594 } 1595 return state; 1596 #endif /* SDL_EVENTS_DISABLED */ 1597 } 1598 1599 void SDL_GetJoystickGUIDInfo(SDL_JoystickGUID guid, Uint16 *vendor, Uint16 *product, Uint16 *version) 1600 { 1601 Uint16 *guid16 = (Uint16 *)guid.data; 1602 1603 /* If the GUID fits the form of BUS 0000 VENDOR 0000 PRODUCT 0000, return the data */ 1604 if (/* guid16[0] is device bus type */ 1605 guid16[1] == 0x0000 && 1606 /* guid16[2] is vendor ID */ 1607 guid16[3] == 0x0000 && 1608 /* guid16[4] is product ID */ 1609 guid16[5] == 0x0000 1610 /* guid16[6] is product version */ 1611 ) { 1612 if (vendor) { 1613 *vendor = guid16[2]; 1614 } 1615 if (product) { 1616 *product = guid16[4]; 1617 } 1618 if (version) { 1619 *version = guid16[6]; 1620 } 1621 } else { 1622 if (vendor) { 1623 *vendor = 0; 1624 } 1625 if (product) { 1626 *product = 0; 1627 } 1628 if (version) { 1629 *version = 0; 1630 } 1631 } 1632 } 1633 1634 static int 1635 PrefixMatch(const char *a, const char *b) 1636 { 1637 int matchlen = 0; 1638 while (*a && *b) { 1639 if (SDL_tolower(*a++) == SDL_tolower(*b++)) { 1640 ++matchlen; 1641 } else { 1642 break; 1643 } 1644 } 1645 return matchlen; 1646 } 1647 1648 char * 1649 SDL_CreateJoystickName(Uint16 vendor, Uint16 product, const char *vendor_name, const char *product_name) 1650 { 1651 static struct { 1652 const char *prefix; 1653 const char *replacement; 1654 } replacements[] = { 1655 { "NVIDIA Corporation ", "" }, 1656 { "Performance Designed Products", "PDP" }, 1657 { "HORI CO.,LTD.", "HORI" }, 1658 { "HORI CO.,LTD", "HORI" }, 1659 }; 1660 const char *custom_name; 1661 char *name; 1662 size_t i, len; 1663 1664 custom_name = GuessControllerName(vendor, product); 1665 if (custom_name) { 1666 return SDL_strdup(custom_name); 1667 } 1668 1669 if (!vendor_name) { 1670 vendor_name = ""; 1671 } 1672 if (!product_name) { 1673 product_name = ""; 1674 } 1675 1676 while (*vendor_name == ' ') { 1677 ++vendor_name; 1678 } 1679 while (*product_name == ' ') { 1680 ++product_name; 1681 } 1682 1683 if (*vendor_name && *product_name) { 1684 len = (SDL_strlen(vendor_name) + 1 + SDL_strlen(product_name) + 1); 1685 name = (char *)SDL_malloc(len); 1686 if (!name) { 1687 return NULL; 1688 } 1689 SDL_snprintf(name, len, "%s %s", vendor_name, product_name); 1690 } else if (*product_name) { 1691 name = SDL_strdup(product_name); 1692 } else if (vendor || product) { 1693 len = (6 + 1 + 6 + 1); 1694 name = (char *)SDL_malloc(len); 1695 if (!name) { 1696 return NULL; 1697 } 1698 SDL_snprintf(name, len, "0x%.4x/0x%.4x", vendor, product); 1699 } else { 1700 name = SDL_strdup("Controller"); 1701 } 1702 1703 /* Trim trailing whitespace */ 1704 for (len = SDL_strlen(name); (len > 0 && name[len - 1] == ' '); --len) { 1705 /* continue */ 1706 } 1707 name[len] = '\0'; 1708 1709 /* Compress duplicate spaces */ 1710 for (i = 0; i < (len - 1); ) { 1711 if (name[i] == ' ' && name[i+1] == ' ') { 1712 SDL_memmove(&name[i], &name[i+1], (len - i)); 1713 --len; 1714 } else { 1715 ++i; 1716 } 1717 } 1718 1719 /* Remove duplicate manufacturer or product in the name */ 1720 for (i = 1; i < (len - 1); ++i) { 1721 int matchlen = PrefixMatch(name, &name[i]); 1722 if (matchlen > 0 && name[matchlen-1] == ' ') { 1723 SDL_memmove(name, name+matchlen, len-matchlen+1); 1724 len -= matchlen; 1725 break; 1726 } else if (matchlen > 0 && name[matchlen] == ' ') { 1727 SDL_memmove(name, name+matchlen+1, len-matchlen); 1728 len -= (matchlen + 1); 1729 break; 1730 } 1731 } 1732 1733 /* Perform any manufacturer replacements */ 1734 for (i = 0; i < SDL_arraysize(replacements); ++i) { 1735 size_t prefixlen = SDL_strlen(replacements[i].prefix); 1736 if (SDL_strncasecmp(name, replacements[i].prefix, prefixlen) == 0) { 1737 size_t replacementlen = SDL_strlen(replacements[i].replacement); 1738 SDL_memcpy(name, replacements[i].replacement, replacementlen); 1739 SDL_memmove(name+replacementlen, name+prefixlen, (len-prefixlen+1)); 1740 break; 1741 } 1742 } 1743 1744 return name; 1745 } 1746 1747 SDL_GameControllerType 1748 SDL_GetJoystickGameControllerTypeFromVIDPID(Uint16 vendor, Uint16 product) 1749 { 1750 return SDL_GetJoystickGameControllerType(NULL, vendor, product, -1, 0, 0, 0); 1751 } 1752 1753 SDL_GameControllerType 1754 SDL_GetJoystickGameControllerTypeFromGUID(SDL_JoystickGUID guid, const char *name) 1755 { 1756 SDL_GameControllerType type; 1757 Uint16 vendor, product; 1758 1759 SDL_GetJoystickGUIDInfo(guid, &vendor, &product, NULL); 1760 type = SDL_GetJoystickGameControllerType(name, vendor, product, -1, 0, 0, 0); 1761 if (type == SDL_CONTROLLER_TYPE_UNKNOWN) { 1762 if (SDL_IsJoystickXInput(guid)) { 1763 /* This is probably an Xbox One controller */ 1764 return SDL_CONTROLLER_TYPE_XBOXONE; 1765 } 1766 } 1767 return type; 1768 } 1769 1770 SDL_GameControllerType 1771 SDL_GetJoystickGameControllerType(const char *name, Uint16 vendor, Uint16 product, int interface_number, int interface_class, int interface_subclass, int interface_protocol) 1772 { 1773 static const int LIBUSB_CLASS_VENDOR_SPEC = 0xFF; 1774 static const int XB360_IFACE_SUBCLASS = 93; 1775 static const int XB360_IFACE_PROTOCOL = 1; /* Wired */ 1776 static const int XB360W_IFACE_PROTOCOL = 129; /* Wireless */ 1777 static const int XBONE_IFACE_SUBCLASS = 71; 1778 static const int XBONE_IFACE_PROTOCOL = 208; 1779 1780 SDL_GameControllerType type = SDL_CONTROLLER_TYPE_UNKNOWN; 1781 1782 /* This code should match the checks in libusb/hid.c and HIDDeviceManager.java */ 1783 if (interface_class == LIBUSB_CLASS_VENDOR_SPEC && 1784 interface_subclass == XB360_IFACE_SUBCLASS && 1785 (interface_protocol == XB360_IFACE_PROTOCOL || 1786 interface_protocol == XB360W_IFACE_PROTOCOL)) { 1787 1788 static const int SUPPORTED_VENDORS[] = { 1789 0x0079, /* GPD Win 2 */ 1790 0x044f, /* Thrustmaster */ 1791 0x045e, /* Microsoft */ 1792 0x046d, /* Logitech */ 1793 0x056e, /* Elecom */ 1794 0x06a3, /* Saitek */ 1795 0x0738, /* Mad Catz */ 1796 0x07ff, /* Mad Catz */ 1797 0x0e6f, /* PDP */ 1798 0x0f0d, /* Hori */ 1799 0x1038, /* SteelSeries */ 1800 0x11c9, /* Nacon */ 1801 0x12ab, /* Unknown */ 1802 0x1430, /* RedOctane */ 1803 0x146b, /* BigBen */ 1804 0x1532, /* Razer Sabertooth */ 1805 0x15e4, /* Numark */ 1806 0x162e, /* Joytech */ 1807 0x1689, /* Razer Onza */ 1808 0x1bad, /* Harmonix */ 1809 0x24c6, /* PowerA */ 1810 }; 1811 1812 int i; 1813 for (i = 0; i < SDL_arraysize(SUPPORTED_VENDORS); ++i) { 1814 if (vendor == SUPPORTED_VENDORS[i]) { 1815 type = SDL_CONTROLLER_TYPE_XBOX360; 1816 break; 1817 } 1818 } 1819 } 1820 1821 if (interface_number == 0 && 1822 interface_class == LIBUSB_CLASS_VENDOR_SPEC && 1823 interface_subclass == XBONE_IFACE_SUBCLASS && 1824 interface_protocol == XBONE_IFACE_PROTOCOL) { 1825 1826 static const int SUPPORTED_VENDORS[] = { 1827 0x045e, /* Microsoft */ 1828 0x0738, /* Mad Catz */ 1829 0x0e6f, /* PDP */ 1830 0x0f0d, /* Hori */ 1831 0x1532, /* Razer Wildcat */ 1832 0x24c6, /* PowerA */ 1833 0x2e24, /* Hyperkin */ 1834 }; 1835 1836 int i; 1837 for (i = 0; i < SDL_arraysize(SUPPORTED_VENDORS); ++i) { 1838 if (vendor == SUPPORTED_VENDORS[i]) { 1839 type = SDL_CONTROLLER_TYPE_XBOXONE; 1840 break; 1841 } 1842 } 1843 } 1844 1845 if (type == SDL_CONTROLLER_TYPE_UNKNOWN) { 1846 if (vendor == 0x0000 && product == 0x0000) { 1847 /* Some devices are only identifiable by their name */ 1848 if (name && 1849 (SDL_strcmp(name, "Lic Pro Controller") == 0 || 1850 SDL_strcmp(name, "Nintendo Wireless Gamepad") == 0 || 1851 SDL_strcmp(name, "Wireless Gamepad") == 0)) { 1852 /* HORI or PowerA Switch Pro Controller clone */ 1853 type = SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO; 1854 } else if (name && SDL_strcmp(name, "Virtual Joystick") == 0) { 1855 type = SDL_CONTROLLER_TYPE_VIRTUAL; 1856 } else { 1857 type = SDL_CONTROLLER_TYPE_UNKNOWN; 1858 } 1859 1860 } else if (vendor == 0x0001 && product == 0x0001) { 1861 type = SDL_CONTROLLER_TYPE_UNKNOWN; 1862 1863 } else { 1864 switch (GuessControllerType(vendor, product)) { 1865 case k_eControllerType_XBox360Controller: 1866 type = SDL_CONTROLLER_TYPE_XBOX360; 1867 break; 1868 case k_eControllerType_XBoxOneController: 1869 type = SDL_CONTROLLER_TYPE_XBOXONE; 1870 break; 1871 case k_eControllerType_PS3Controller: 1872 type = SDL_CONTROLLER_TYPE_PS3; 1873 break; 1874 case k_eControllerType_PS4Controller: 1875 type = SDL_CONTROLLER_TYPE_PS4; 1876 break; 1877 case k_eControllerType_PS5Controller: 1878 type = SDL_CONTROLLER_TYPE_PS5; 1879 break; 1880 case k_eControllerType_SwitchProController: 1881 case k_eControllerType_SwitchInputOnlyController: 1882 type = SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO; 1883 break; 1884 default: 1885 type = SDL_CONTROLLER_TYPE_UNKNOWN; 1886 break; 1887 } 1888 } 1889 } 1890 return type; 1891 } 1892 1893 SDL_bool 1894 SDL_IsJoystickXboxOneElite(Uint16 vendor_id, Uint16 product_id) 1895 { 1896 if (vendor_id == USB_VENDOR_MICROSOFT) { 1897 if (product_id == USB_PRODUCT_XBOX_ONE_ELITE_SERIES_1 || 1898 product_id == USB_PRODUCT_XBOX_ONE_ELITE_SERIES_2 || 1899 product_id == USB_PRODUCT_XBOX_ONE_ELITE_SERIES_2_BLUETOOTH) { 1900 return SDL_TRUE; 1901 } 1902 } 1903 return SDL_FALSE; 1904 } 1905 1906 SDL_bool 1907 SDL_IsJoystickXboxOneSeriesX(Uint16 vendor_id, Uint16 product_id) 1908 { 1909 if (vendor_id == USB_VENDOR_MICROSOFT) { 1910 if (product_id == USB_PRODUCT_XBOX_ONE_SERIES_X || 1911 product_id == USB_PRODUCT_XBOX_ONE_SERIES_X_BLUETOOTH) { 1912 return SDL_TRUE; 1913 } 1914 } 1915 return SDL_FALSE; 1916 } 1917 1918 SDL_bool 1919 SDL_IsJoystickPS4(Uint16 vendor_id, Uint16 product_id) 1920 { 1921 EControllerType eType = GuessControllerType(vendor_id, product_id); 1922 return (eType == k_eControllerType_PS4Controller); 1923 } 1924 1925 SDL_bool 1926 SDL_IsJoystickPS5(Uint16 vendor_id, Uint16 product_id) 1927 { 1928 EControllerType eType = GuessControllerType(vendor_id, product_id); 1929 return (eType == k_eControllerType_PS5Controller); 1930 } 1931 1932 SDL_bool 1933 SDL_IsJoystickNintendoSwitchPro(Uint16 vendor_id, Uint16 product_id) 1934 { 1935 EControllerType eType = GuessControllerType(vendor_id, product_id); 1936 return (eType == k_eControllerType_SwitchProController || 1937 eType == k_eControllerType_SwitchInputOnlyController); 1938 } 1939 1940 SDL_bool 1941 SDL_IsJoystickNintendoSwitchProInputOnly(Uint16 vendor_id, Uint16 product_id) 1942 { 1943 EControllerType eType = GuessControllerType(vendor_id, product_id); 1944 return (eType == k_eControllerType_SwitchInputOnlyController); 1945 } 1946 1947 SDL_bool 1948 SDL_IsJoystickSteamController(Uint16 vendor_id, Uint16 product_id) 1949 { 1950 EControllerType eType = GuessControllerType(vendor_id, product_id); 1951 return (eType == k_eControllerType_SteamController || 1952 eType == k_eControllerType_SteamControllerV2); 1953 } 1954 1955 SDL_bool 1956 SDL_IsJoystickXInput(SDL_JoystickGUID guid) 1957 { 1958 return (guid.data[14] == 'x') ? SDL_TRUE : SDL_FALSE; 1959 } 1960 1961 SDL_bool 1962 SDL_IsJoystickWGI(SDL_JoystickGUID guid) 1963 { 1964 return (guid.data[14] == 'w') ? SDL_TRUE : SDL_FALSE; 1965 } 1966 1967 SDL_bool 1968 SDL_IsJoystickHIDAPI(SDL_JoystickGUID guid) 1969 { 1970 return (guid.data[14] == 'h') ? SDL_TRUE : SDL_FALSE; 1971 } 1972 1973 SDL_bool 1974 SDL_IsJoystickRAWINPUT(SDL_JoystickGUID guid) 1975 { 1976 return (guid.data[14] == 'r') ? SDL_TRUE : SDL_FALSE; 1977 } 1978 1979 SDL_bool 1980 SDL_IsJoystickVirtual(SDL_JoystickGUID guid) 1981 { 1982 return (guid.data[14] == 'v') ? SDL_TRUE : SDL_FALSE; 1983 } 1984 1985 static SDL_bool SDL_IsJoystickProductWheel(Uint32 vidpid) 1986 { 1987 static Uint32 wheel_joysticks[] = { 1988 MAKE_VIDPID(0x046d, 0xc294), /* Logitech generic wheel */ 1989 MAKE_VIDPID(0x046d, 0xc295), /* Logitech Momo Force */ 1990 MAKE_VIDPID(0x046d, 0xc298), /* Logitech Driving Force Pro */ 1991 MAKE_VIDPID(0x046d, 0xc299), /* Logitech G25 */ 1992 MAKE_VIDPID(0x046d, 0xc29a), /* Logitech Driving Force GT */ 1993 MAKE_VIDPID(0x046d, 0xc29b), /* Logitech G27 */ 1994 MAKE_VIDPID(0x046d, 0xc24f), /* Logitech G29 */ 1995 MAKE_VIDPID(0x046d, 0xc261), /* Logitech G920 (initial mode) */ 1996 MAKE_VIDPID(0x046d, 0xc262), /* Logitech G920 (active mode) */ 1997 MAKE_VIDPID(0x044f, 0xb65d), /* Thrustmaster Wheel FFB */ 1998 MAKE_VIDPID(0x044f, 0xb66d), /* Thrustmaster Wheel FFB */ 1999 MAKE_VIDPID(0x044f, 0xb677), /* Thrustmaster T150 */ 2000 MAKE_VIDPID(0x044f, 0xb664), /* Thrustmaster TX (initial mode) */ 2001 MAKE_VIDPID(0x044f, 0xb669), /* Thrustmaster TX (active mode) */ 2002 }; 2003 int i; 2004 2005 for (i = 0; i < SDL_arraysize(wheel_joysticks); ++i) { 2006 if (vidpid == wheel_joysticks[i]) { 2007 return SDL_TRUE; 2008 } 2009 } 2010 return SDL_FALSE; 2011 } 2012 2013 static SDL_bool SDL_IsJoystickProductFlightStick(Uint32 vidpid) 2014 { 2015 static Uint32 flightstick_joysticks[] = { 2016 MAKE_VIDPID(0x044f, 0x0402), /* HOTAS Warthog Joystick */ 2017 MAKE_VIDPID(0x0738, 0x2221), /* Saitek Pro Flight X-56 Rhino Stick */ 2018 }; 2019 int i; 2020 2021 for (i = 0; i < SDL_arraysize(flightstick_joysticks); ++i) { 2022 if (vidpid == flightstick_joysticks[i]) { 2023 return SDL_TRUE; 2024 } 2025 } 2026 return SDL_FALSE; 2027 } 2028 2029 static SDL_bool SDL_IsJoystickProductThrottle(Uint32 vidpid) 2030 { 2031 static Uint32 throttle_joysticks[] = { 2032 MAKE_VIDPID(0x044f, 0x0404), /* HOTAS Warthog Throttle */ 2033 MAKE_VIDPID(0x0738, 0xa221), /* Saitek Pro Flight X-56 Rhino Throttle */ 2034 }; 2035 int i; 2036 2037 for (i = 0; i < SDL_arraysize(throttle_joysticks); ++i) { 2038 if (vidpid == throttle_joysticks[i]) { 2039 return SDL_TRUE; 2040 } 2041 } 2042 return SDL_FALSE; 2043 } 2044 2045 static SDL_JoystickType SDL_GetJoystickGUIDType(SDL_JoystickGUID guid) 2046 { 2047 Uint16 vendor; 2048 Uint16 product; 2049 Uint32 vidpid; 2050 2051 if (SDL_IsJoystickXInput(guid)) { 2052 /* XInput GUID, get the type based on the XInput device subtype */ 2053 switch (guid.data[15]) { 2054 case 0x01: /* XINPUT_DEVSUBTYPE_GAMEPAD */ 2055 return SDL_JOYSTICK_TYPE_GAMECONTROLLER; 2056 case 0x02: /* XINPUT_DEVSUBTYPE_WHEEL */ 2057 return SDL_JOYSTICK_TYPE_WHEEL; 2058 case 0x03: /* XINPUT_DEVSUBTYPE_ARCADE_STICK */ 2059 return SDL_JOYSTICK_TYPE_ARCADE_STICK; 2060 case 0x04: /* XINPUT_DEVSUBTYPE_FLIGHT_STICK */ 2061 return SDL_JOYSTICK_TYPE_FLIGHT_STICK; 2062 case 0x05: /* XINPUT_DEVSUBTYPE_DANCE_PAD */ 2063 return SDL_JOYSTICK_TYPE_DANCE_PAD; 2064 case 0x06: /* XINPUT_DEVSUBTYPE_GUITAR */ 2065 case 0x07: /* XINPUT_DEVSUBTYPE_GUITAR_ALTERNATE */ 2066 case 0x0B: /* XINPUT_DEVSUBTYPE_GUITAR_BASS */ 2067 return SDL_JOYSTICK_TYPE_GUITAR; 2068 case 0x08: /* XINPUT_DEVSUBTYPE_DRUM_KIT */ 2069 return SDL_JOYSTICK_TYPE_DRUM_KIT; 2070 case 0x13: /* XINPUT_DEVSUBTYPE_ARCADE_PAD */ 2071 return SDL_JOYSTICK_TYPE_ARCADE_PAD; 2072 default: 2073 return SDL_JOYSTICK_TYPE_UNKNOWN; 2074 } 2075 } 2076 2077 if (SDL_IsJoystickWGI(guid)) { 2078 return (SDL_JoystickType)guid.data[15]; 2079 } 2080 2081 if (SDL_IsJoystickVirtual(guid)) { 2082 return (SDL_JoystickType)guid.data[15]; 2083 } 2084 2085 SDL_GetJoystickGUIDInfo(guid, &vendor, &product, NULL); 2086 vidpid = MAKE_VIDPID(vendor, product); 2087 2088 if (SDL_IsJoystickProductWheel(vidpid)) { 2089 return SDL_JOYSTICK_TYPE_WHEEL; 2090 } 2091 2092 if (SDL_IsJoystickProductFlightStick(vidpid)) { 2093 return SDL_JOYSTICK_TYPE_FLIGHT_STICK; 2094 } 2095 2096 if (SDL_IsJoystickProductThrottle(vidpid)) { 2097 return SDL_JOYSTICK_TYPE_THROTTLE; 2098 } 2099 2100 if (GuessControllerType(vendor, product) != k_eControllerType_UnknownNonSteamController) { 2101 return SDL_JOYSTICK_TYPE_GAMECONTROLLER; 2102 } 2103 2104 return SDL_JOYSTICK_TYPE_UNKNOWN; 2105 } 2106 2107 static SDL_bool SDL_IsPS4RemapperRunning(void) 2108 { 2109 #ifdef __WIN32__ 2110 const char *mapper_processes[] = { 2111 "DS4Windows.exe", 2112 "InputMapper.exe", 2113 }; 2114 int i; 2115 PROCESSENTRY32 pe32; 2116 SDL_bool found = SDL_FALSE; 2117 2118 /* Take a snapshot of all processes in the system */ 2119 HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); 2120 if (hProcessSnap != INVALID_HANDLE_VALUE) { 2121 pe32.dwSize = sizeof(PROCESSENTRY32); 2122 if (Process32First(hProcessSnap, &pe32)) { 2123 do 2124 { 2125 for (i = 0; i < SDL_arraysize(mapper_processes); ++i) { 2126 if (SDL_strcasecmp(pe32.szExeFile, mapper_processes[i]) == 0) { 2127 found = SDL_TRUE; 2128 } 2129 } 2130 } while (Process32Next(hProcessSnap, &pe32) && !found); 2131 } 2132 CloseHandle(hProcessSnap); 2133 } 2134 return found; 2135 #else 2136 return SDL_FALSE; 2137 #endif 2138 } 2139 2140 SDL_bool SDL_ShouldIgnoreJoystick(const char *name, SDL_JoystickGUID guid) 2141 { 2142 /* This list is taken from: 2143 https://raw.githubusercontent.com/denilsonsa/udev-joystick-blacklist/master/generate_rules.py 2144 */ 2145 static Uint32 joystick_blacklist[] = { 2146 /* Microsoft Microsoft Wireless Optical Desktop 2.10 */ 2147 /* Microsoft Wireless Desktop - Comfort Edition */ 2148 MAKE_VIDPID(0x045e, 0x009d), 2149 2150 /* Microsoft Microsoft Digital Media Pro Keyboard */ 2151 /* Microsoft Corp. Digital Media Pro Keyboard */ 2152 MAKE_VIDPID(0x045e, 0x00b0), 2153 2154 /* Microsoft Microsoft Digital Media Keyboard */ 2155 /* Microsoft Corp. Digital Media Keyboard 1.0A */ 2156 MAKE_VIDPID(0x045e, 0x00b4), 2157 2158 /* Microsoft Microsoft Digital Media Keyboard 3000 */ 2159 MAKE_VIDPID(0x045e, 0x0730), 2160 2161 /* Microsoft Microsoft 2.4GHz Transceiver v6.0 */ 2162 /* Microsoft Microsoft 2.4GHz Transceiver v8.0 */ 2163 /* Microsoft Corp. Nano Transceiver v1.0 for Bluetooth */ 2164 /* Microsoft Wireless Mobile Mouse 1000 */ 2165 /* Microsoft Wireless Desktop 3000 */ 2166 MAKE_VIDPID(0x045e, 0x0745), 2167 2168 /* Microsoft SideWinder(TM) 2.4GHz Transceiver */ 2169 MAKE_VIDPID(0x045e, 0x0748), 2170 2171 /* Microsoft Corp. Wired Keyboard 600 */ 2172 MAKE_VIDPID(0x045e, 0x0750), 2173 2174 /* Microsoft Corp. Sidewinder X4 keyboard */ 2175 MAKE_VIDPID(0x045e, 0x0768), 2176 2177 /* Microsoft Corp. Arc Touch Mouse Transceiver */ 2178 MAKE_VIDPID(0x045e, 0x0773), 2179 2180 /* Microsoft 2.4GHz Transceiver v9.0 */ 2181 /* Microsoft Nano Transceiver v2.1 */ 2182 /* Microsoft Sculpt Ergonomic Keyboard (5KV-00001) */ 2183 MAKE_VIDPID(0x045e, 0x07a5), 2184 2185 /* Microsoft Nano Transceiver v1.0 */ 2186 /* Microsoft Wireless Keyboard 800 */ 2187 MAKE_VIDPID(0x045e, 0x07b2), 2188 2189 /* Microsoft Nano Transceiver v2.0 */ 2190 MAKE_VIDPID(0x045e, 0x0800), 2191 2192 MAKE_VIDPID(0x046d, 0xc30a), /* Logitech, Inc. iTouch Composite keboard */ 2193 2194 MAKE_VIDPID(0x04d9, 0xa0df), /* Tek Syndicate Mouse (E-Signal USB Gaming Mouse) */ 2195 2196 /* List of Wacom devices at: http://linuxwacom.sourceforge.net/wiki/index.php/Device_IDs */ 2197 MAKE_VIDPID(0x056a, 0x0010), /* Wacom ET-0405 Graphire */ 2198 MAKE_VIDPID(0x056a, 0x0011), /* Wacom ET-0405A Graphire2 (4x5) */ 2199 MAKE_VIDPID(0x056a, 0x0012), /* Wacom ET-0507A Graphire2 (5x7) */ 2200 MAKE_VIDPID(0x056a, 0x0013), /* Wacom CTE-430 Graphire3 (4x5) */ 2201 MAKE_VIDPID(0x056a, 0x0014), /* Wacom CTE-630 Graphire3 (6x8) */ 2202 MAKE_VIDPID(0x056a, 0x0015), /* Wacom CTE-440 Graphire4 (4x5) */ 2203 MAKE_VIDPID(0x056a, 0x0016), /* Wacom CTE-640 Graphire4 (6x8) */ 2204 MAKE_VIDPID(0x056a, 0x0017), /* Wacom CTE-450 Bamboo Fun (4x5) */ 2205 MAKE_VIDPID(0x056a, 0x0018), /* Wacom CTE-650 Bamboo Fun 6x8 */ 2206 MAKE_VIDPID(0x056a, 0x0019), /* Wacom CTE-631 Bamboo One */ 2207 MAKE_VIDPID(0x056a, 0x00d1), /* Wacom Bamboo Pen and Touch CTH-460 */ 2208 MAKE_VIDPID(0x056a, 0x030e), /* Wacom Intuos Pen (S) CTL-480 */ 2209 2210 MAKE_VIDPID(0x09da, 0x054f), /* A4 Tech Co., G7 750 mouse */ 2211 MAKE_VIDPID(0x09da, 0x1410), /* A4 Tech Co., Ltd Bloody AL9 mouse */ 2212 MAKE_VIDPID(0x09da, 0x3043), /* A4 Tech Co., Ltd Bloody R8A Gaming Mouse */ 2213 MAKE_VIDPID(0x09da, 0x31b5), /* A4 Tech Co., Ltd Bloody TL80 Terminator Laser Gaming Mouse */ 2214 MAKE_VIDPID(0x09da, 0x3997), /* A4 Tech Co., Ltd Bloody RT7 Terminator Wireless */ 2215 MAKE_VIDPID(0x09da, 0x3f8b), /* A4 Tech Co., Ltd Bloody V8 mouse */ 2216 MAKE_VIDPID(0x09da, 0x51f4), /* Modecom MC-5006 Keyboard */ 2217 MAKE_VIDPID(0x09da, 0x5589), /* A4 Tech Co., Ltd Terminator TL9 Laser Gaming Mouse */ 2218 MAKE_VIDPID(0x09da, 0x7b22), /* A4 Tech Co., Ltd Bloody V5 */ 2219 MAKE_VIDPID(0x09da, 0x7f2d), /* A4 Tech Co., Ltd Bloody R3 mouse */ 2220 MAKE_VIDPID(0x09da, 0x8090), /* A4 Tech Co., Ltd X-718BK Oscar Optical Gaming Mouse */ 2221 MAKE_VIDPID(0x09da, 0x9033), /* A4 Tech Co., X7 X-705K */ 2222 MAKE_VIDPID(0x09da, 0x9066), /* A4 Tech Co., Sharkoon Fireglider Optical */ 2223 MAKE_VIDPID(0x09da, 0x9090), /* A4 Tech Co., Ltd XL-730K / XL-750BK / XL-755BK Laser Mouse */ 2224 MAKE_VIDPID(0x09da, 0x90c0), /* A4 Tech Co., Ltd X7 G800V keyboard */ 2225 MAKE_VIDPID(0x09da, 0xf012), /* A4 Tech Co., Ltd Bloody V7 mouse */ 2226 MAKE_VIDPID(0x09da, 0xf32a), /* A4 Tech Co., Ltd Bloody B540 keyboard */ 2227 MAKE_VIDPID(0x09da, 0xf613), /* A4 Tech Co., Ltd Bloody V2 mouse */ 2228 MAKE_VIDPID(0x09da, 0xf624), /* A4 Tech Co., Ltd Bloody B120 Keyboard */ 2229 2230 MAKE_VIDPID(0x1b1c, 0x1b3c), /* Corsair Harpoon RGB gaming mouse */ 2231 2232 MAKE_VIDPID(0x1d57, 0xad03), /* [T3] 2.4GHz and IR Air Mouse Remote Control */ 2233 2234 MAKE_VIDPID(0x1e7d, 0x2e4a), /* Roccat Tyon Mouse */ 2235 2236 MAKE_VIDPID(0x20a0, 0x422d), /* Winkeyless.kr Keyboards */ 2237 2238 MAKE_VIDPID(0x2516, 0x001f), /* Cooler Master Storm Mizar Mouse */ 2239 MAKE_VIDPID(0x2516, 0x0028), /* Cooler Master Storm Alcor Mouse */ 2240 }; 2241 2242 unsigned int i; 2243 Uint32 id; 2244 Uint16 vendor; 2245 Uint16 product; 2246 SDL_GameControllerType type; 2247 2248 SDL_GetJoystickGUIDInfo(guid, &vendor, &product, NULL); 2249 2250 /* Check the joystick blacklist */ 2251 id = MAKE_VIDPID(vendor, product); 2252 for (i = 0; i < SDL_arraysize(joystick_blacklist); ++i) { 2253 if (id == joystick_blacklist[i]) { 2254 return SDL_TRUE; 2255 } 2256 } 2257 2258 type = SDL_GetJoystickGameControllerType(name, vendor, product, -1, 0, 0, 0); 2259 if ((type == SDL_CONTROLLER_TYPE_PS4 || type == SDL_CONTROLLER_TYPE_PS5) && SDL_IsPS4RemapperRunning()) { 2260 return SDL_TRUE; 2261 } 2262 2263 if (SDL_IsGameControllerNameAndGUID(name, guid) && 2264 SDL_ShouldIgnoreGameController(name, guid)) { 2265 return SDL_TRUE; 2266 } 2267 2268 return SDL_FALSE; 2269 } 2270 2271 /* return the guid for this index */ 2272 SDL_JoystickGUID SDL_JoystickGetDeviceGUID(int device_index) 2273 { 2274 SDL_JoystickDriver *driver; 2275 SDL_JoystickGUID guid; 2276 2277 SDL_LockJoysticks(); 2278 if (SDL_GetDriverAndJoystickIndex(device_index, &driver, &device_index)) { 2279 guid = driver->GetDeviceGUID(device_index); 2280 } else { 2281 SDL_zero(guid); 2282 } 2283 SDL_UnlockJoysticks(); 2284 2285 return guid; 2286 } 2287 2288 Uint16 SDL_JoystickGetDeviceVendor(int device_index) 2289 { 2290 Uint16 vendor; 2291 SDL_JoystickGUID guid = SDL_JoystickGetDeviceGUID(device_index); 2292 2293 SDL_GetJoystickGUIDInfo(guid, &vendor, NULL, NULL); 2294 return vendor; 2295 } 2296 2297 Uint16 SDL_JoystickGetDeviceProduct(int device_index) 2298 { 2299 Uint16 product; 2300 SDL_JoystickGUID guid = SDL_JoystickGetDeviceGUID(device_index); 2301 2302 SDL_GetJoystickGUIDInfo(guid, NULL, &product, NULL); 2303 return product; 2304 } 2305 2306 Uint16 SDL_JoystickGetDeviceProductVersion(int device_index) 2307 { 2308 Uint16 version; 2309 SDL_JoystickGUID guid = SDL_JoystickGetDeviceGUID(device_index); 2310 2311 SDL_GetJoystickGUIDInfo(guid, NULL, NULL, &version); 2312 return version; 2313 } 2314 2315 SDL_JoystickType SDL_JoystickGetDeviceType(int device_index) 2316 { 2317 SDL_JoystickType type; 2318 SDL_JoystickGUID guid = SDL_JoystickGetDeviceGUID(device_index); 2319 2320 type = SDL_GetJoystickGUIDType(guid); 2321 if (type == SDL_JOYSTICK_TYPE_UNKNOWN) { 2322 if (SDL_IsGameController(device_index)) { 2323 type = SDL_JOYSTICK_TYPE_GAMECONTROLLER; 2324 } 2325 } 2326 return type; 2327 } 2328 2329 SDL_JoystickID SDL_JoystickGetDeviceInstanceID(int device_index) 2330 { 2331 SDL_JoystickDriver *driver; 2332 SDL_JoystickID instance_id = -1; 2333 2334 SDL_LockJoysticks(); 2335 if (SDL_GetDriverAndJoystickIndex(device_index, &driver, &device_index)) { 2336 instance_id = driver->GetDeviceInstanceID(device_index); 2337 } 2338 SDL_UnlockJoysticks(); 2339 2340 return instance_id; 2341 } 2342 2343 int SDL_JoystickGetDeviceIndexFromInstanceID(SDL_JoystickID instance_id) 2344 { 2345 int i, num_joysticks, device_index = -1; 2346 2347 SDL_LockJoysticks(); 2348 num_joysticks = SDL_NumJoysticks(); 2349 for (i = 0; i < num_joysticks; ++i) { 2350 if (SDL_JoystickGetDeviceInstanceID(i) == instance_id) { 2351 device_index = i; 2352 break; 2353 } 2354 } 2355 SDL_UnlockJoysticks(); 2356 2357 return device_index; 2358 } 2359 2360 SDL_JoystickGUID SDL_JoystickGetGUID(SDL_Joystick *joystick) 2361 { 2362 if (!SDL_PrivateJoystickValid(joystick)) { 2363 SDL_JoystickGUID emptyGUID; 2364 SDL_zero(emptyGUID); 2365 return emptyGUID; 2366 } 2367 return joystick->guid; 2368 } 2369 2370 Uint16 SDL_JoystickGetVendor(SDL_Joystick *joystick) 2371 { 2372 Uint16 vendor; 2373 SDL_JoystickGUID guid = SDL_JoystickGetGUID(joystick); 2374 2375 SDL_GetJoystickGUIDInfo(guid, &vendor, NULL, NULL); 2376 return vendor; 2377 } 2378 2379 Uint16 SDL_JoystickGetProduct(SDL_Joystick *joystick) 2380 { 2381 Uint16 product; 2382 SDL_JoystickGUID guid = SDL_JoystickGetGUID(joystick); 2383 2384 SDL_GetJoystickGUIDInfo(guid, NULL, &product, NULL); 2385 return product; 2386 } 2387 2388 Uint16 SDL_JoystickGetProductVersion(SDL_Joystick *joystick) 2389 { 2390 Uint16 version; 2391 SDL_JoystickGUID guid = SDL_JoystickGetGUID(joystick); 2392 2393 SDL_GetJoystickGUIDInfo(guid, NULL, NULL, &version); 2394 return version; 2395 } 2396 2397 const char *SDL_JoystickGetSerial(SDL_Joystick *joystick) 2398 { 2399 if (!SDL_PrivateJoystickValid(joystick)) { 2400 return NULL; 2401 } 2402 return joystick->serial; 2403 } 2404 2405 SDL_JoystickType SDL_JoystickGetType(SDL_Joystick *joystick) 2406 { 2407 SDL_JoystickType type; 2408 SDL_JoystickGUID guid = SDL_JoystickGetGUID(joystick); 2409 2410 type = SDL_GetJoystickGUIDType(guid); 2411 if (type == SDL_JOYSTICK_TYPE_UNKNOWN) { 2412 if (joystick && joystick->is_game_controller) { 2413 type = SDL_JOYSTICK_TYPE_GAMECONTROLLER; 2414 } 2415 } 2416 return type; 2417 } 2418 2419 /* convert the guid to a printable string */ 2420 void SDL_JoystickGetGUIDString(SDL_JoystickGUID guid, char *pszGUID, int cbGUID) 2421 { 2422 static const char k_rgchHexToASCII[] = "0123456789abcdef"; 2423 int i; 2424 2425 if ((pszGUID == NULL) || (cbGUID <= 0)) { 2426 return; 2427 } 2428 2429 for (i = 0; i < sizeof(guid.data) && i < (cbGUID-1)/2; i++) { 2430 /* each input byte writes 2 ascii chars, and might write a null byte. */ 2431 /* If we don't have room for next input byte, stop */ 2432 unsigned char c = guid.data[i]; 2433 2434 *pszGUID++ = k_rgchHexToASCII[c >> 4]; 2435 *pszGUID++ = k_rgchHexToASCII[c & 0x0F]; 2436 } 2437 *pszGUID = '\0'; 2438 } 2439 2440 /*----------------------------------------------------------------------------- 2441 * Purpose: Returns the 4 bit nibble for a hex character 2442 * Input : c - 2443 * Output : unsigned char 2444 *-----------------------------------------------------------------------------*/ 2445 static unsigned char nibble(char c) 2446 { 2447 if ((c >= '0') && (c <= '9')) { 2448 return (unsigned char)(c - '0'); 2449 } 2450 2451 if ((c >= 'A') && (c <= 'F')) { 2452 return (unsigned char)(c - 'A' + 0x0a); 2453 } 2454 2455 if ((c >= 'a') && (c <= 'f')) { 2456 return (unsigned char)(c - 'a' + 0x0a); 2457 } 2458 2459 /* received an invalid character, and no real way to return an error */ 2460 /* AssertMsg1(false, "Q_nibble invalid hex character '%c' ", c); */ 2461 return 0; 2462 } 2463 2464 /* convert the string version of a joystick guid to the struct */ 2465 SDL_JoystickGUID SDL_JoystickGetGUIDFromString(const char *pchGUID) 2466 { 2467 SDL_JoystickGUID guid; 2468 int maxoutputbytes= sizeof(guid); 2469 size_t len = SDL_strlen(pchGUID); 2470 Uint8 *p; 2471 size_t i; 2472 2473 /* Make sure it's even */ 2474 len = (len) & ~0x1; 2475 2476 SDL_memset(&guid, 0x00, sizeof(guid)); 2477 2478 p = (Uint8 *)&guid; 2479 for (i = 0; (i < len) && ((p - (Uint8 *)&guid) < maxoutputbytes); i+=2, p++) { 2480 *p = (nibble(pchGUID[i]) << 4) | nibble(pchGUID[i+1]); 2481 } 2482 2483 return guid; 2484 } 2485 2486 /* update the power level for this joystick */ 2487 void SDL_PrivateJoystickBatteryLevel(SDL_Joystick *joystick, SDL_JoystickPowerLevel ePowerLevel) 2488 { 2489 joystick->epowerlevel = ePowerLevel; 2490 } 2491 2492 /* return its power level */ 2493 SDL_JoystickPowerLevel SDL_JoystickCurrentPowerLevel(SDL_Joystick *joystick) 2494 { 2495 if (!SDL_PrivateJoystickValid(joystick)) { 2496 return SDL_JOYSTICK_POWER_UNKNOWN; 2497 } 2498 return joystick->epowerlevel; 2499 } 2500 2501 int SDL_PrivateJoystickTouchpad(SDL_Joystick *joystick, int touchpad, int finger, Uint8 state, float x, float y, float pressure) 2502 { 2503 SDL_JoystickTouchpadInfo *touchpad_info; 2504 SDL_JoystickTouchpadFingerInfo *finger_info; 2505 int posted; 2506 #if !SDL_EVENTS_DISABLED 2507 Uint32 event_type; 2508 #endif 2509 2510 if (touchpad < 0 || touchpad >= joystick->ntouchpads) { 2511 return 0; 2512 } 2513 2514 touchpad_info = &joystick->touchpads[touchpad]; 2515 if (finger < 0 || finger >= touchpad_info->nfingers) { 2516 return 0; 2517 } 2518 2519 finger_info = &touchpad_info->fingers[finger]; 2520 2521 if (!state) { 2522 if (x == 0.0f && y == 0.0f) { 2523 x = finger_info->x; 2524 y = finger_info->y; 2525 } 2526 pressure = 0.0f; 2527 } 2528 2529 if (x < 0.0f) { 2530 x = 0.0f; 2531 } else if (x > 1.0f) { 2532 x = 1.0f; 2533 } 2534 if (y < 0.0f) { 2535 y = 0.0f; 2536 } else if (y > 1.0f) { 2537 y = 1.0f; 2538 } 2539 if (pressure < 0.0f) { 2540 pressure = 0.0f; 2541 } else if (pressure > 1.0f) { 2542 pressure = 1.0f; 2543 } 2544 2545 if (state == finger_info->state) { 2546 if (!state || 2547 (x == finger_info->x && y == finger_info->y && pressure == finger_info->pressure)) { 2548 return 0; 2549 } 2550 } 2551 2552 #if !SDL_EVENTS_DISABLED 2553 if (state == finger_info->state) { 2554 event_type = SDL_CONTROLLERTOUCHPADMOTION; 2555 } else if (state) { 2556 event_type = SDL_CONTROLLERTOUCHPADDOWN; 2557 } else { 2558 event_type = SDL_CONTROLLERTOUCHPADUP; 2559 } 2560 #endif 2561 2562 /* Update internal joystick state */ 2563 finger_info->state = state; 2564 finger_info->x = x; 2565 finger_info->y = y; 2566 finger_info->pressure = pressure; 2567 2568 /* Post the event, if desired */ 2569 posted = 0; 2570 #if !SDL_EVENTS_DISABLED 2571 if (SDL_GetEventState(event_type) == SDL_ENABLE) { 2572 SDL_Event event; 2573 event.type = event_type; 2574 event.ctouchpad.which = joystick->instance_id; 2575 event.ctouchpad.touchpad = touchpad; 2576 event.ctouchpad.finger = finger; 2577 event.ctouchpad.x = x; 2578 event.ctouchpad.y = y; 2579 event.ctouchpad.pressure = pressure; 2580 posted = SDL_PushEvent(&event) == 1; 2581 } 2582 #endif /* !SDL_EVENTS_DISABLED */ 2583 return posted; 2584 } 2585 2586 int SDL_PrivateJoystickSensor(SDL_Joystick *joystick, SDL_SensorType type, const float *data, int num_values) 2587 { 2588 int i; 2589 int posted = 0; 2590 2591 for (i = 0; i < joystick->nsensors; ++i) { 2592 SDL_JoystickSensorInfo *sensor = &joystick->sensors[i]; 2593 2594 if (sensor->type == type) { 2595 if (sensor->enabled) { 2596 num_values = SDL_min(num_values, SDL_arraysize(sensor->data)); 2597 if (SDL_memcmp(data, sensor->data, num_values*sizeof(*data)) != 0) { 2598 2599 /* Update internal sensor state */ 2600 SDL_memcpy(sensor->data, data, num_values*sizeof(*data)); 2601 2602 /* Post the event, if desired */ 2603 #if !SDL_EVENTS_DISABLED 2604 if (SDL_GetEventState(SDL_CONTROLLERSENSORUPDATE) == SDL_ENABLE) { 2605 SDL_Event event; 2606 event.type = SDL_CONTROLLERSENSORUPDATE; 2607 event.csensor.which = joystick->instance_id; 2608 event.csensor.sensor = type; 2609 num_values = SDL_min(num_values, SDL_arraysize(event.csensor.data)); 2610 SDL_memset(event.csensor.data, 0, sizeof(event.csensor.data)); 2611 SDL_memcpy(event.csensor.data, data, num_values*sizeof(*data)); 2612 posted = SDL_PushEvent(&event) == 1; 2613 } 2614 #endif /* !SDL_EVENTS_DISABLED */ 2615 } 2616 } 2617 break; 2618 } 2619 } 2620 return posted; 2621 } 2622 2623 /* vi: set ts=4 sw=4 expandtab: */