SDL 2.0
SDL_gamecontroller.h File Reference
#include "SDL_stdinc.h"
#include "SDL_error.h"
#include "SDL_rwops.h"
#include "SDL_joystick.h"
#include "begin_code.h"
#include "close_code.h"
+ Include dependency graph for SDL_gamecontroller.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  SDL_GameControllerButtonBind
 

Macros

#define SDL_GameControllerAddMappingsFromFile(file)   SDL_GameControllerAddMappingsFromRW(SDL_RWFromFile(file, "rb"), 1)
 

Enumerations

enum  SDL_GameControllerBindType {
  SDL_CONTROLLER_BINDTYPE_NONE = 0 ,
  SDL_CONTROLLER_BINDTYPE_BUTTON ,
  SDL_CONTROLLER_BINDTYPE_AXIS ,
  SDL_CONTROLLER_BINDTYPE_HAT
}
 
enum  SDL_GameControllerAxis {
  SDL_CONTROLLER_AXIS_INVALID = -1 ,
  SDL_CONTROLLER_AXIS_LEFTX ,
  SDL_CONTROLLER_AXIS_LEFTY ,
  SDL_CONTROLLER_AXIS_RIGHTX ,
  SDL_CONTROLLER_AXIS_RIGHTY ,
  SDL_CONTROLLER_AXIS_TRIGGERLEFT ,
  SDL_CONTROLLER_AXIS_TRIGGERRIGHT ,
  SDL_CONTROLLER_AXIS_MAX
}
 
enum  SDL_GameControllerButton {
  SDL_CONTROLLER_BUTTON_INVALID = -1 ,
  SDL_CONTROLLER_BUTTON_A ,
  SDL_CONTROLLER_BUTTON_B ,
  SDL_CONTROLLER_BUTTON_X ,
  SDL_CONTROLLER_BUTTON_Y ,
  SDL_CONTROLLER_BUTTON_BACK ,
  SDL_CONTROLLER_BUTTON_GUIDE ,
  SDL_CONTROLLER_BUTTON_START ,
  SDL_CONTROLLER_BUTTON_LEFTSTICK ,
  SDL_CONTROLLER_BUTTON_RIGHTSTICK ,
  SDL_CONTROLLER_BUTTON_LEFTSHOULDER ,
  SDL_CONTROLLER_BUTTON_RIGHTSHOULDER ,
  SDL_CONTROLLER_BUTTON_DPAD_UP ,
  SDL_CONTROLLER_BUTTON_DPAD_DOWN ,
  SDL_CONTROLLER_BUTTON_DPAD_LEFT ,
  SDL_CONTROLLER_BUTTON_DPAD_RIGHT ,
  SDL_CONTROLLER_BUTTON_MAX
}
 

Functions

int SDL_GameControllerAddMappingsFromRW (SDL_RWops *rw, int freerw)
 
int SDL_GameControllerAddMapping (const char *mappingString)
 
int SDL_GameControllerNumMappings (void)
 
char * SDL_GameControllerMappingForIndex (int mapping_index)
 
char * SDL_GameControllerMappingForGUID (SDL_JoystickGUID guid)
 
char * SDL_GameControllerMapping (SDL_GameController *gamecontroller)
 
SDL_bool SDL_IsGameController (int joystick_index)
 
const char * SDL_GameControllerNameForIndex (int joystick_index)
 
char * SDL_GameControllerMappingForDeviceIndex (int joystick_index)
 
SDL_GameController * SDL_GameControllerOpen (int joystick_index)
 
SDL_GameController * SDL_GameControllerFromInstanceID (SDL_JoystickID joyid)
 
const char * SDL_GameControllerName (SDL_GameController *gamecontroller)
 
int SDL_GameControllerGetPlayerIndex (SDL_GameController *gamecontroller)
 
Uint16 SDL_GameControllerGetVendor (SDL_GameController *gamecontroller)
 
Uint16 SDL_GameControllerGetProduct (SDL_GameController *gamecontroller)
 
Uint16 SDL_GameControllerGetProductVersion (SDL_GameController *gamecontroller)
 
SDL_bool SDL_GameControllerGetAttached (SDL_GameController *gamecontroller)
 
SDL_Joystick * SDL_GameControllerGetJoystick (SDL_GameController *gamecontroller)
 
int SDL_GameControllerEventState (int state)
 
void SDL_GameControllerUpdate (void)
 
SDL_GameControllerAxis SDL_GameControllerGetAxisFromString (const char *pchString)
 
const char * SDL_GameControllerGetStringForAxis (SDL_GameControllerAxis axis)
 
SDL_GameControllerButtonBind SDL_GameControllerGetBindForAxis (SDL_GameController *gamecontroller, SDL_GameControllerAxis axis)
 
Sint16 SDL_GameControllerGetAxis (SDL_GameController *gamecontroller, SDL_GameControllerAxis axis)
 
SDL_GameControllerButton SDL_GameControllerGetButtonFromString (const char *pchString)
 
const char * SDL_GameControllerGetStringForButton (SDL_GameControllerButton button)
 
SDL_GameControllerButtonBind SDL_GameControllerGetBindForButton (SDL_GameController *gamecontroller, SDL_GameControllerButton button)
 
Uint8 SDL_GameControllerGetButton (SDL_GameController *gamecontroller, SDL_GameControllerButton button)
 
int SDL_GameControllerRumble (SDL_GameController *gamecontroller, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble, Uint32 duration_ms)
 
void SDL_GameControllerClose (SDL_GameController *gamecontroller)
 

Detailed Description

Include file for SDL game controller event handling

In order to use these functions, SDL_Init() must have been called with the SDL_INIT_GAMECONTROLLER flag. This causes SDL to scan the system for game controllers, and load appropriate drivers.

If you would like to receive controller updates while the application is in the background, you should set the following hint before calling SDL_Init(): SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS

Definition in file SDL_gamecontroller.h.

Macro Definition Documentation

◆ SDL_GameControllerAddMappingsFromFile

#define SDL_GameControllerAddMappingsFromFile (   file)    SDL_GameControllerAddMappingsFromRW(SDL_RWFromFile(file, "rb"), 1)

Load a set of mappings from a file, filtered by the current SDL_GetPlatform()

Convenience macro.

Definition at line 129 of file SDL_gamecontroller.h.

Enumeration Type Documentation

◆ SDL_GameControllerAxis

The list of axes available from a controller

Thumbstick axis values range from SDL_JOYSTICK_AXIS_MIN to SDL_JOYSTICK_AXIS_MAX, and are centered within ~8000 of zero, though advanced UI will allow users to set or autodetect the dead zone, which varies between controllers.

Trigger axis values range from 0 to SDL_JOYSTICK_AXIS_MAX.

Enumerator
SDL_CONTROLLER_AXIS_INVALID 
SDL_CONTROLLER_AXIS_LEFTX 
SDL_CONTROLLER_AXIS_LEFTY 
SDL_CONTROLLER_AXIS_RIGHTX 
SDL_CONTROLLER_AXIS_RIGHTY 
SDL_CONTROLLER_AXIS_TRIGGERLEFT 
SDL_CONTROLLER_AXIS_TRIGGERRIGHT 
SDL_CONTROLLER_AXIS_MAX 

Definition at line 272 of file SDL_gamecontroller.h.

◆ SDL_GameControllerBindType

Enumerator
SDL_CONTROLLER_BINDTYPE_NONE 
SDL_CONTROLLER_BINDTYPE_BUTTON 
SDL_CONTROLLER_BINDTYPE_AXIS 
SDL_CONTROLLER_BINDTYPE_HAT 

Definition at line 61 of file SDL_gamecontroller.h.

◆ SDL_GameControllerButton

The list of buttons available from a controller

Enumerator
SDL_CONTROLLER_BUTTON_INVALID 
SDL_CONTROLLER_BUTTON_A 
SDL_CONTROLLER_BUTTON_B 
SDL_CONTROLLER_BUTTON_X 
SDL_CONTROLLER_BUTTON_Y 
SDL_CONTROLLER_BUTTON_BACK 
SDL_CONTROLLER_BUTTON_GUIDE 
SDL_CONTROLLER_BUTTON_START 
SDL_CONTROLLER_BUTTON_LEFTSTICK 
SDL_CONTROLLER_BUTTON_RIGHTSTICK 
SDL_CONTROLLER_BUTTON_LEFTSHOULDER 
SDL_CONTROLLER_BUTTON_RIGHTSHOULDER 
SDL_CONTROLLER_BUTTON_DPAD_UP 
SDL_CONTROLLER_BUTTON_DPAD_DOWN 
SDL_CONTROLLER_BUTTON_DPAD_LEFT 
SDL_CONTROLLER_BUTTON_DPAD_RIGHT 
SDL_CONTROLLER_BUTTON_MAX 

Definition at line 316 of file SDL_gamecontroller.h.

317{
SDL_GameControllerButton
@ SDL_CONTROLLER_BUTTON_B
@ SDL_CONTROLLER_BUTTON_BACK
@ SDL_CONTROLLER_BUTTON_LEFTSTICK
@ SDL_CONTROLLER_BUTTON_START
@ SDL_CONTROLLER_BUTTON_DPAD_LEFT
@ SDL_CONTROLLER_BUTTON_RIGHTSHOULDER
@ SDL_CONTROLLER_BUTTON_INVALID
@ SDL_CONTROLLER_BUTTON_DPAD_DOWN
@ SDL_CONTROLLER_BUTTON_DPAD_UP
@ SDL_CONTROLLER_BUTTON_MAX
@ SDL_CONTROLLER_BUTTON_LEFTSHOULDER
@ SDL_CONTROLLER_BUTTON_GUIDE
@ SDL_CONTROLLER_BUTTON_DPAD_RIGHT
@ SDL_CONTROLLER_BUTTON_X
@ SDL_CONTROLLER_BUTTON_RIGHTSTICK
@ SDL_CONTROLLER_BUTTON_Y
@ SDL_CONTROLLER_BUTTON_A

Function Documentation

◆ SDL_GameControllerAddMapping()

int SDL_GameControllerAddMapping ( const char *  mappingString)

Add or update an existing mapping configuration

Returns
1 if mapping is added, 0 if updated, -1 on error

Definition at line 1200 of file SDL_gamecontroller.c.

1201{
1203}
@ SDL_CONTROLLER_MAPPING_PRIORITY_API
static int SDL_PrivateGameControllerAddMapping(const char *mappingString, SDL_ControllerMappingPriority priority)

References SDL_CONTROLLER_MAPPING_PRIORITY_API, and SDL_PrivateGameControllerAddMapping().

Referenced by SDL_GameControllerAddMappingsFromRW().

◆ SDL_GameControllerAddMappingsFromRW()

int SDL_GameControllerAddMappingsFromRW ( SDL_RWops rw,
int  freerw 
)

To count the number of game controllers in the system for the following: int nJoysticks = SDL_NumJoysticks(); int nGameControllers = 0; for (int i = 0; i < nJoysticks; i++) { if (SDL_IsGameController(i)) { nGameControllers++; } }

Using the SDL_HINT_GAMECONTROLLERCONFIG hint or the SDL_GameControllerAddMapping() you can add support for controllers SDL is unaware of or cause an existing controller to have a different binding. The format is: guid,name,mappings

Where GUID is the string value from SDL_JoystickGetGUIDString(), name is the human readable string for the device and mappings are controller mappings to joystick ones. Under Windows there is a reserved GUID of "xinput" that covers any XInput devices. The mapping format for joystick is: bX - a joystick button, index X hX.Y - hat X with value Y aX - axis X of the joystick Buttons can be used as a controller axis and vice versa.

This string shows an example of a valid mapping for a controller "03000000341a00003608000000000000,PS3 Controller,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b8,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftshoulder:b4,rightshoulder:b5,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7", Load a set of mappings from a seekable SDL data stream (memory or file), filtered by the current SDL_GetPlatform() A community sourced database of controllers is available at https://raw.github.com/gabomdq/SDL_GameControllerDB/master/gamecontrollerdb.txt

If freerw is non-zero, the stream will be closed after being read.

Returns
number of mappings added, -1 on error

Definition at line 1078 of file SDL_gamecontroller.c.

1079{
1080 const char *platform = SDL_GetPlatform();
1081 int controllers = 0;
1082 char *buf, *line, *line_end, *tmp, *comma, line_platform[64];
1083 size_t db_size, platform_len;
1084
1085 if (rw == NULL) {
1086 return SDL_SetError("Invalid RWops");
1087 }
1088 db_size = (size_t)SDL_RWsize(rw);
1089
1090 buf = (char *)SDL_malloc(db_size + 1);
1091 if (buf == NULL) {
1092 if (freerw) {
1093 SDL_RWclose(rw);
1094 }
1095 return SDL_SetError("Could not allocate space to read DB into memory");
1096 }
1097
1098 if (SDL_RWread(rw, buf, db_size, 1) != 1) {
1099 if (freerw) {
1100 SDL_RWclose(rw);
1101 }
1102 SDL_free(buf);
1103 return SDL_SetError("Could not read DB");
1104 }
1105
1106 if (freerw) {
1107 SDL_RWclose(rw);
1108 }
1109
1110 buf[db_size] = '\0';
1111 line = buf;
1112
1113 while (line < buf + db_size) {
1114 line_end = SDL_strchr(line, '\n');
1115 if (line_end != NULL) {
1116 *line_end = '\0';
1117 } else {
1118 line_end = buf + db_size;
1119 }
1120
1121 /* Extract and verify the platform */
1123 if (tmp != NULL) {
1125 comma = SDL_strchr(tmp, ',');
1126 if (comma != NULL) {
1127 platform_len = comma - tmp + 1;
1128 if (platform_len + 1 < SDL_arraysize(line_platform)) {
1129 SDL_strlcpy(line_platform, tmp, platform_len);
1130 if (SDL_strncasecmp(line_platform, platform, platform_len) == 0 &&
1131 SDL_GameControllerAddMapping(line) > 0) {
1132 controllers++;
1133 }
1134 }
1135 }
1136 }
1137
1138 line = line_end + 1;
1139 }
1140
1141 SDL_free(buf);
1142 return controllers;
1143}
unsigned int size_t
#define SDL_SetError
#define SDL_strchr
#define SDL_RWread
#define SDL_malloc
#define SDL_strlen
#define SDL_strlcpy
#define SDL_GetPlatform
#define SDL_free
#define SDL_strstr
#define SDL_RWsize
#define SDL_RWclose
#define SDL_strncasecmp
int SDL_GameControllerAddMapping(const char *mappingString)
#define SDL_CONTROLLER_PLATFORM_FIELD
GLenum GLuint GLenum GLsizei const GLchar * buf
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:115
#define NULL
Definition: begin_code.h:167

References sort_controllers::controllers, NULL, SDL_arraysize, SDL_CONTROLLER_PLATFORM_FIELD, SDL_free, SDL_GameControllerAddMapping(), SDL_GetPlatform, SDL_malloc, SDL_RWclose, SDL_RWread, SDL_RWsize, SDL_SetError, SDL_strchr, SDL_strlcpy, SDL_strlen, SDL_strncasecmp, and SDL_strstr.

◆ SDL_GameControllerClose()

void SDL_GameControllerClose ( SDL_GameController *  gamecontroller)

Close a controller previously opened with SDL_GameControllerOpen().

Definition at line 1885 of file SDL_gamecontroller.c.

1886{
1887 SDL_GameController *gamecontrollerlist, *gamecontrollerlistprev;
1888
1889 if (!gamecontroller)
1890 return;
1891
1893
1894 /* First decrement ref count */
1895 if (--gamecontroller->ref_count > 0) {
1897 return;
1898 }
1899
1900 SDL_JoystickClose(gamecontroller->joystick);
1901
1902 gamecontrollerlist = SDL_gamecontrollers;
1903 gamecontrollerlistprev = NULL;
1904 while (gamecontrollerlist) {
1905 if (gamecontroller == gamecontrollerlist) {
1906 if (gamecontrollerlistprev) {
1907 /* unlink this entry */
1908 gamecontrollerlistprev->next = gamecontrollerlist->next;
1909 } else {
1910 SDL_gamecontrollers = gamecontroller->next;
1911 }
1912 break;
1913 }
1914 gamecontrollerlistprev = gamecontrollerlist;
1915 gamecontrollerlist = gamecontrollerlist->next;
1916 }
1917
1918 SDL_free(gamecontroller->bindings);
1919 SDL_free(gamecontroller->last_match_axis);
1920 SDL_free(gamecontroller->last_hat_mask);
1921 SDL_free(gamecontroller);
1922
1924}
#define SDL_LockJoysticks
#define SDL_JoystickClose
#define SDL_UnlockJoysticks
static SDL_GameController * SDL_gamecontrollers

References NULL, SDL_free, SDL_gamecontrollers, SDL_JoystickClose, SDL_LockJoysticks, and SDL_UnlockJoysticks.

Referenced by SDL_GameControllerQuit().

◆ SDL_GameControllerEventState()

int SDL_GameControllerEventState ( int  state)

Enable/disable controller event polling.

If controller events are disabled, you must call SDL_GameControllerUpdate() yourself and check the state of the controller when you want controller information.

The state can be one of SDL_QUERY, SDL_ENABLE or SDL_IGNORE.

Definition at line 2056 of file SDL_gamecontroller.c.

2057{
2058#if SDL_EVENTS_DISABLED
2059 return SDL_IGNORE;
2060#else
2061 const Uint32 event_list[] = {
2064 };
2065 unsigned int i;
2066
2067 switch (state) {
2068 case SDL_QUERY:
2069 state = SDL_IGNORE;
2070 for (i = 0; i < SDL_arraysize(event_list); ++i) {
2071 state = SDL_EventState(event_list[i], SDL_QUERY);
2072 if (state == SDL_ENABLE) {
2073 break;
2074 }
2075 }
2076 break;
2077 default:
2078 for (i = 0; i < SDL_arraysize(event_list); ++i) {
2079 SDL_EventState(event_list[i], state);
2080 }
2081 break;
2082 }
2083 return (state);
2084#endif /* SDL_EVENTS_DISABLED */
2085}
#define SDL_EventState
@ SDL_CONTROLLERBUTTONUP
Definition: SDL_events.h:122
@ SDL_CONTROLLERDEVICEADDED
Definition: SDL_events.h:123
@ SDL_CONTROLLERBUTTONDOWN
Definition: SDL_events.h:121
@ SDL_CONTROLLERAXISMOTION
Definition: SDL_events.h:120
@ SDL_CONTROLLERDEVICEREMOVED
Definition: SDL_events.h:124
@ SDL_CONTROLLERDEVICEREMAPPED
Definition: SDL_events.h:125
#define SDL_QUERY
Definition: SDL_events.h:756
#define SDL_ENABLE
Definition: SDL_events.h:759
#define SDL_IGNORE
Definition: SDL_events.h:757
uint32_t Uint32
Definition: SDL_stdinc.h:203
struct xkb_state * state
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50

References i, SDL_arraysize, SDL_CONTROLLERAXISMOTION, SDL_CONTROLLERBUTTONDOWN, SDL_CONTROLLERBUTTONUP, SDL_CONTROLLERDEVICEADDED, SDL_CONTROLLERDEVICEREMAPPED, SDL_CONTROLLERDEVICEREMOVED, SDL_ENABLE, SDL_EventState, SDL_IGNORE, SDL_QUERY, and state.

◆ SDL_GameControllerFromInstanceID()

SDL_GameController * SDL_GameControllerFromInstanceID ( SDL_JoystickID  joyid)

Return the SDL_GameController associated with an instance id.

Definition at line 1797 of file SDL_gamecontroller.c.

1798{
1799 SDL_GameController *gamecontroller;
1800
1802 gamecontroller = SDL_gamecontrollers;
1803 while (gamecontroller) {
1804 if (gamecontroller->joystick->instance_id == joyid) {
1806 return gamecontroller;
1807 }
1808 gamecontroller = gamecontroller->next;
1809 }
1811 return NULL;
1812}

References NULL, SDL_gamecontrollers, SDL_LockJoysticks, and SDL_UnlockJoysticks.

◆ SDL_GameControllerGetAttached()

SDL_bool SDL_GameControllerGetAttached ( SDL_GameController *  gamecontroller)

Returns SDL_TRUE if the controller has been opened and currently connected, or SDL_FALSE if it has not.

Definition at line 1773 of file SDL_gamecontroller.c.

1774{
1775 if (!gamecontroller)
1776 return SDL_FALSE;
1777
1778 return SDL_JoystickGetAttached(gamecontroller->joystick);
1779}
#define SDL_JoystickGetAttached
@ SDL_FALSE
Definition: SDL_stdinc.h:163

References SDL_FALSE, and SDL_JoystickGetAttached.

◆ SDL_GameControllerGetAxis()

Sint16 SDL_GameControllerGetAxis ( SDL_GameController *  gamecontroller,
SDL_GameControllerAxis  axis 
)

Get the current state of an axis control on a game controller.

The state is a value ranging from -32768 to 32767 (except for the triggers, which range from 0 to 32767).

The axis indices start at index 0.

Definition at line 1635 of file SDL_gamecontroller.c.

1636{
1637 int i;
1638
1639 if (!gamecontroller)
1640 return 0;
1641
1642 for (i = 0; i < gamecontroller->num_bindings; ++i) {
1643 SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1644 if (binding->outputType == SDL_CONTROLLER_BINDTYPE_AXIS && binding->output.axis.axis == axis) {
1645 int value = 0;
1646 SDL_bool valid_input_range;
1647 SDL_bool valid_output_range;
1648
1649 if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1650 value = SDL_JoystickGetAxis(gamecontroller->joystick, binding->input.axis.axis);
1651 if (binding->input.axis.axis_min < binding->input.axis.axis_max) {
1652 valid_input_range = (value >= binding->input.axis.axis_min && value <= binding->input.axis.axis_max);
1653 } else {
1654 valid_input_range = (value >= binding->input.axis.axis_max && value <= binding->input.axis.axis_min);
1655 }
1656 if (valid_input_range) {
1657 if (binding->input.axis.axis_min != binding->output.axis.axis_min || binding->input.axis.axis_max != binding->output.axis.axis_max) {
1658 float normalized_value = (float)(value - binding->input.axis.axis_min) / (binding->input.axis.axis_max - binding->input.axis.axis_min);
1659 value = binding->output.axis.axis_min + (int)(normalized_value * (binding->output.axis.axis_max - binding->output.axis.axis_min));
1660 }
1661 } else {
1662 value = 0;
1663 }
1664 } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1665 value = SDL_JoystickGetButton(gamecontroller->joystick, binding->input.button);
1666 if (value == SDL_PRESSED) {
1667 value = binding->output.axis.axis_max;
1668 }
1669 } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1670 int hat_mask = SDL_JoystickGetHat(gamecontroller->joystick, binding->input.hat.hat);
1671 if (hat_mask & binding->input.hat.hat_mask) {
1672 value = binding->output.axis.axis_max;
1673 }
1674 }
1675
1676 if (binding->output.axis.axis_min < binding->output.axis.axis_max) {
1677 valid_output_range = (value >= binding->output.axis.axis_min && value <= binding->output.axis.axis_max);
1678 } else {
1679 valid_output_range = (value >= binding->output.axis.axis_max && value <= binding->output.axis.axis_min);
1680 }
1681 /* If the value is zero, there might be another binding that makes it non-zero */
1682 if (value != 0 && valid_output_range) {
1683 return (Sint16)value;
1684 }
1685 }
1686 }
1687 return 0;
1688}
#define SDL_JoystickGetAxis
#define SDL_JoystickGetHat
#define SDL_JoystickGetButton
#define SDL_PRESSED
Definition: SDL_events.h:50
GLsizei const GLfloat * value
SDL_bool
Definition: SDL_stdinc.h:162
int16_t Sint16
Definition: SDL_stdinc.h:185
SDL_GameControllerBindType outputType
union SDL_ExtendedGameControllerBind::@24 input
union SDL_ExtendedGameControllerBind::@25 output
SDL_GameControllerBindType inputType
SDL_Texture * axis

References SDL_ExtendedGameControllerBind::axis, axis, SDL_ExtendedGameControllerBind::button, SDL_ExtendedGameControllerBind::hat, i, SDL_ExtendedGameControllerBind::input, SDL_ExtendedGameControllerBind::inputType, SDL_ExtendedGameControllerBind::output, SDL_ExtendedGameControllerBind::outputType, SDL_CONTROLLER_BINDTYPE_AXIS, SDL_CONTROLLER_BINDTYPE_BUTTON, SDL_CONTROLLER_BINDTYPE_HAT, SDL_JoystickGetAxis, SDL_JoystickGetButton, SDL_JoystickGetHat, and SDL_PRESSED.

◆ SDL_GameControllerGetAxisFromString()

SDL_GameControllerAxis SDL_GameControllerGetAxisFromString ( const char *  pchString)

turn this string into a axis mapping

Definition at line 462 of file SDL_gamecontroller.c.

463{
464 int entry;
465
466 if (pchString && (*pchString == '+' || *pchString == '-')) {
467 ++pchString;
468 }
469
470 if (!pchString || !pchString[0]) {
472 }
473
474 for (entry = 0; map_StringForControllerAxis[entry]; ++entry) {
475 if (!SDL_strcasecmp(pchString, map_StringForControllerAxis[entry]))
476 return (SDL_GameControllerAxis) entry;
477 }
479}
#define SDL_strcasecmp
static const char * map_StringForControllerAxis[]

References map_StringForControllerAxis, SDL_CONTROLLER_AXIS_INVALID, and SDL_strcasecmp.

Referenced by SDL_PrivateGameControllerParseElement().

◆ SDL_GameControllerGetBindForAxis()

SDL_GameControllerButtonBind SDL_GameControllerGetBindForAxis ( SDL_GameController *  gamecontroller,
SDL_GameControllerAxis  axis 
)

Get the SDL joystick layer binding for this controller button mapping

Definition at line 1818 of file SDL_gamecontroller.c.

1819{
1820 int i;
1822 SDL_zero(bind);
1823
1824 if (!gamecontroller || axis == SDL_CONTROLLER_AXIS_INVALID)
1825 return bind;
1826
1827 for (i = 0; i < gamecontroller->num_bindings; ++i) {
1828 SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1829 if (binding->outputType == SDL_CONTROLLER_BINDTYPE_AXIS && binding->output.axis.axis == axis) {
1830 bind.bindType = binding->inputType;
1831 if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1832 /* FIXME: There might be multiple axes bound now that we have axis ranges... */
1833 bind.value.axis = binding->input.axis.axis;
1834 } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1835 bind.value.button = binding->input.button;
1836 } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1837 bind.value.hat.hat = binding->input.hat.hat;
1838 bind.value.hat.hat_mask = binding->input.hat.hat_mask;
1839 }
1840 break;
1841 }
1842 }
1843 return bind;
1844}
#define SDL_zero(x)
Definition: SDL_stdinc.h:416
SDL_GameControllerBindType bindType
union SDL_GameControllerButtonBind::@0 value

References SDL_GameControllerButtonBind::axis, SDL_ExtendedGameControllerBind::axis, axis, SDL_GameControllerButtonBind::bindType, SDL_GameControllerButtonBind::button, SDL_ExtendedGameControllerBind::button, SDL_GameControllerButtonBind::hat, SDL_ExtendedGameControllerBind::hat, i, SDL_ExtendedGameControllerBind::input, SDL_ExtendedGameControllerBind::inputType, SDL_ExtendedGameControllerBind::output, SDL_ExtendedGameControllerBind::outputType, SDL_CONTROLLER_AXIS_INVALID, SDL_CONTROLLER_BINDTYPE_AXIS, SDL_CONTROLLER_BINDTYPE_BUTTON, SDL_CONTROLLER_BINDTYPE_HAT, SDL_zero, and SDL_GameControllerButtonBind::value.

◆ SDL_GameControllerGetBindForButton()

SDL_GameControllerButtonBind SDL_GameControllerGetBindForButton ( SDL_GameController *  gamecontroller,
SDL_GameControllerButton  button 
)

Get the SDL joystick layer binding for this controller button mapping

Definition at line 1850 of file SDL_gamecontroller.c.

1851{
1852 int i;
1854 SDL_zero(bind);
1855
1856 if (!gamecontroller || button == SDL_CONTROLLER_BUTTON_INVALID)
1857 return bind;
1858
1859 for (i = 0; i < gamecontroller->num_bindings; ++i) {
1860 SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1861 if (binding->outputType == SDL_CONTROLLER_BINDTYPE_BUTTON && binding->output.button == button) {
1862 bind.bindType = binding->inputType;
1863 if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1864 bind.value.axis = binding->input.axis.axis;
1865 } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1866 bind.value.button = binding->input.button;
1867 } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1868 bind.value.hat.hat = binding->input.hat.hat;
1869 bind.value.hat.hat_mask = binding->input.hat.hat_mask;
1870 }
1871 break;
1872 }
1873 }
1874 return bind;
1875}
SDL_Texture * button

References SDL_GameControllerButtonBind::axis, SDL_ExtendedGameControllerBind::axis, SDL_GameControllerButtonBind::bindType, SDL_GameControllerButtonBind::button, SDL_ExtendedGameControllerBind::button, button, SDL_GameControllerButtonBind::hat, SDL_ExtendedGameControllerBind::hat, i, SDL_ExtendedGameControllerBind::input, SDL_ExtendedGameControllerBind::inputType, SDL_ExtendedGameControllerBind::output, SDL_ExtendedGameControllerBind::outputType, SDL_CONTROLLER_BINDTYPE_AXIS, SDL_CONTROLLER_BINDTYPE_BUTTON, SDL_CONTROLLER_BINDTYPE_HAT, SDL_CONTROLLER_BUTTON_INVALID, SDL_zero, and SDL_GameControllerButtonBind::value.

◆ SDL_GameControllerGetButton()

Uint8 SDL_GameControllerGetButton ( SDL_GameController *  gamecontroller,
SDL_GameControllerButton  button 
)

Get the current state of a button on a game controller.

The button indices start at index 0.

Definition at line 1694 of file SDL_gamecontroller.c.

1695{
1696 int i;
1697
1698 if (!gamecontroller)
1699 return 0;
1700
1701 for (i = 0; i < gamecontroller->num_bindings; ++i) {
1702 SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1703 if (binding->outputType == SDL_CONTROLLER_BINDTYPE_BUTTON && binding->output.button == button) {
1704 if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1705 SDL_bool valid_input_range;
1706
1707 int value = SDL_JoystickGetAxis(gamecontroller->joystick, binding->input.axis.axis);
1708 int threshold = binding->input.axis.axis_min + (binding->input.axis.axis_max - binding->input.axis.axis_min) / 2;
1709 if (binding->input.axis.axis_min < binding->input.axis.axis_max) {
1710 valid_input_range = (value >= binding->input.axis.axis_min && value <= binding->input.axis.axis_max);
1711 if (valid_input_range) {
1712 return (value >= threshold) ? SDL_PRESSED : SDL_RELEASED;
1713 }
1714 } else {
1715 valid_input_range = (value >= binding->input.axis.axis_max && value <= binding->input.axis.axis_min);
1716 if (valid_input_range) {
1717 return (value <= threshold) ? SDL_PRESSED : SDL_RELEASED;
1718 }
1719 }
1720 } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1721 return SDL_JoystickGetButton(gamecontroller->joystick, binding->input.button);
1722 } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1723 int hat_mask = SDL_JoystickGetHat(gamecontroller->joystick, binding->input.hat.hat);
1724 return (hat_mask & binding->input.hat.hat_mask) ? SDL_PRESSED : SDL_RELEASED;
1725 }
1726 }
1727 }
1728 return SDL_RELEASED;
1729}
#define SDL_RELEASED
Definition: SDL_events.h:49

References SDL_ExtendedGameControllerBind::axis, SDL_ExtendedGameControllerBind::button, button, SDL_ExtendedGameControllerBind::hat, i, SDL_ExtendedGameControllerBind::input, SDL_ExtendedGameControllerBind::inputType, SDL_ExtendedGameControllerBind::output, SDL_ExtendedGameControllerBind::outputType, SDL_CONTROLLER_BINDTYPE_AXIS, SDL_CONTROLLER_BINDTYPE_BUTTON, SDL_CONTROLLER_BINDTYPE_HAT, SDL_JoystickGetAxis, SDL_JoystickGetButton, SDL_JoystickGetHat, SDL_PRESSED, and SDL_RELEASED.

◆ SDL_GameControllerGetButtonFromString()

SDL_GameControllerButton SDL_GameControllerGetButtonFromString ( const char *  pchString)

turn this string into a button mapping

Definition at line 514 of file SDL_gamecontroller.c.

515{
516 int entry;
517 if (!pchString || !pchString[0])
519
520 for (entry = 0; map_StringForControllerButton[entry]; ++entry) {
521 if (SDL_strcasecmp(pchString, map_StringForControllerButton[entry]) == 0)
522 return (SDL_GameControllerButton) entry;
523 }
525}
static const char * map_StringForControllerButton[]

References map_StringForControllerButton, SDL_CONTROLLER_BUTTON_INVALID, and SDL_strcasecmp.

Referenced by SDL_PrivateGameControllerParseElement().

◆ SDL_GameControllerGetJoystick()

SDL_Joystick * SDL_GameControllerGetJoystick ( SDL_GameController *  gamecontroller)

Get the underlying joystick object used by a controller

Definition at line 1784 of file SDL_gamecontroller.c.

1785{
1786 if (!gamecontroller)
1787 return NULL;
1788
1789 return gamecontroller->joystick;
1790}

References NULL.

Referenced by SDL_GameControllerGetPlayerIndex(), SDL_GameControllerGetProduct(), SDL_GameControllerGetProductVersion(), SDL_GameControllerGetVendor(), SDL_GameControllerName(), and SDL_GameControllerRumble().

◆ SDL_GameControllerGetPlayerIndex()

int SDL_GameControllerGetPlayerIndex ( SDL_GameController *  gamecontroller)

Get the player index of an opened game controller, or -1 if it's not available

For XInput controllers this returns the XInput user index.

Definition at line 1745 of file SDL_gamecontroller.c.

1746{
1748}
#define SDL_JoystickGetPlayerIndex
SDL_Joystick * SDL_GameControllerGetJoystick(SDL_GameController *gamecontroller)

References SDL_GameControllerGetJoystick(), and SDL_JoystickGetPlayerIndex.

◆ SDL_GameControllerGetProduct()

Uint16 SDL_GameControllerGetProduct ( SDL_GameController *  gamecontroller)

Get the USB product ID of an opened controller, if available. If the product ID isn't available this function returns 0.

Definition at line 1757 of file SDL_gamecontroller.c.

1758{
1760}
#define SDL_JoystickGetProduct

References SDL_GameControllerGetJoystick(), and SDL_JoystickGetProduct.

◆ SDL_GameControllerGetProductVersion()

Uint16 SDL_GameControllerGetProductVersion ( SDL_GameController *  gamecontroller)

Get the product version of an opened controller, if available. If the product version isn't available this function returns 0.

Definition at line 1763 of file SDL_gamecontroller.c.

1764{
1766}
#define SDL_JoystickGetProductVersion

References SDL_GameControllerGetJoystick(), and SDL_JoystickGetProductVersion.

◆ SDL_GameControllerGetStringForAxis()

const char * SDL_GameControllerGetStringForAxis ( SDL_GameControllerAxis  axis)

turn this axis enum into a string mapping

Definition at line 484 of file SDL_gamecontroller.c.

485{
488 }
489 return NULL;
490}

References axis, map_StringForControllerAxis, NULL, SDL_CONTROLLER_AXIS_INVALID, and SDL_CONTROLLER_AXIS_MAX.

◆ SDL_GameControllerGetStringForButton()

const char * SDL_GameControllerGetStringForButton ( SDL_GameControllerButton  button)

turn this button enum into a string mapping

Definition at line 530 of file SDL_gamecontroller.c.

531{
534 }
535 return NULL;
536}

References axis, map_StringForControllerButton, NULL, SDL_CONTROLLER_BUTTON_INVALID, and SDL_CONTROLLER_BUTTON_MAX.

◆ SDL_GameControllerGetVendor()

Uint16 SDL_GameControllerGetVendor ( SDL_GameController *  gamecontroller)

Get the USB vendor ID of an opened controller, if available. If the vendor ID isn't available this function returns 0.

Definition at line 1751 of file SDL_gamecontroller.c.

1752{
1754}
#define SDL_JoystickGetVendor

References SDL_GameControllerGetJoystick(), and SDL_JoystickGetVendor.

◆ SDL_GameControllerMapping()

char * SDL_GameControllerMapping ( SDL_GameController *  gamecontroller)

Get a mapping string for an open GameController

Returns
the mapping string. Must be freed with SDL_free(). Returns NULL if no mapping is available

Definition at line 1284 of file SDL_gamecontroller.c.

1285{
1286 if (!gamecontroller) {
1287 return NULL;
1288 }
1289
1290 return SDL_GameControllerMappingForGUID(gamecontroller->joystick->guid);
1291}
char * SDL_GameControllerMappingForGUID(SDL_JoystickGUID guid)

References NULL, and SDL_GameControllerMappingForGUID().

◆ SDL_GameControllerMappingForDeviceIndex()

char * SDL_GameControllerMappingForDeviceIndex ( int  joystick_index)

Get the mapping of a game controller. This can be called before any controllers are opened.

Returns
the mapping string. Must be freed with SDL_free(). Returns NULL if no mapping is available

Get the mapping of a game controller. This can be called before any controllers are opened. If no mapping can be found, this function returns NULL.

Definition at line 1419 of file SDL_gamecontroller.c.

1420{
1421 char *pMappingString = NULL;
1423
1425 mapping = SDL_PrivateGetControllerMapping(joystick_index);
1426 if (mapping) {
1427 SDL_JoystickGUID guid;
1428 char pchGUID[33];
1429 size_t needed;
1430 guid = SDL_JoystickGetDeviceGUID(joystick_index);
1431 SDL_JoystickGetGUIDString(guid, pchGUID, sizeof(pchGUID));
1432 /* allocate enough memory for GUID + ',' + name + ',' + mapping + \0 */
1433 needed = SDL_strlen(pchGUID) + 1 + SDL_strlen(mapping->name) + 1 + SDL_strlen(mapping->mapping) + 1;
1434 pMappingString = SDL_malloc(needed);
1435 if (!pMappingString) {
1438 return NULL;
1439 }
1440 SDL_snprintf(pMappingString, needed, "%s,%s,%s", pchGUID, mapping->name, mapping->mapping);
1441 }
1443 return pMappingString;
1444}
#define SDL_JoystickGetGUIDString
#define SDL_JoystickGetDeviceGUID
#define SDL_snprintf
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
static ControllerMapping_t * SDL_PrivateGetControllerMapping(int device_index)
GLenum GLenum GLenum GLenum mapping

References NULL, SDL_JoystickGetDeviceGUID, SDL_JoystickGetGUIDString, SDL_LockJoysticks, SDL_malloc, SDL_OutOfMemory, SDL_PrivateGetControllerMapping(), SDL_snprintf, SDL_strlen, and SDL_UnlockJoysticks.

◆ SDL_GameControllerMappingForGUID()

char * SDL_GameControllerMappingForGUID ( SDL_JoystickGUID  guid)

Get a mapping string for a GUID

Returns
the mapping string. Must be freed with SDL_free(). Returns NULL if no mapping is available

Definition at line 1260 of file SDL_gamecontroller.c.

1261{
1262 char *pMappingString = NULL;
1264 if (mapping) {
1265 char pchGUID[33];
1266 size_t needed;
1267 SDL_JoystickGetGUIDString(guid, pchGUID, sizeof(pchGUID));
1268 /* allocate enough memory for GUID + ',' + name + ',' + mapping + \0 */
1269 needed = SDL_strlen(pchGUID) + 1 + SDL_strlen(mapping->name) + 1 + SDL_strlen(mapping->mapping) + 1;
1270 pMappingString = SDL_malloc(needed);
1271 if (!pMappingString) {
1273 return NULL;
1274 }
1275 SDL_snprintf(pMappingString, needed, "%s,%s,%s", pchGUID, mapping->name, mapping->mapping);
1276 }
1277 return pMappingString;
1278}
static ControllerMapping_t * SDL_PrivateGetControllerMappingForGUID(SDL_JoystickGUID *guid, SDL_bool exact_match)

References NULL, SDL_FALSE, SDL_JoystickGetGUIDString, SDL_malloc, SDL_OutOfMemory, SDL_PrivateGetControllerMappingForGUID(), SDL_snprintf, and SDL_strlen.

Referenced by SDL_GameControllerMapping().

◆ SDL_GameControllerMappingForIndex()

char * SDL_GameControllerMappingForIndex ( int  mapping_index)

Get the mapping at a particular index.

Returns
the mapping string. Must be freed with SDL_free(). Returns NULL if the index is out of range.

Definition at line 1227 of file SDL_gamecontroller.c.

1228{
1230
1232 if (SDL_memcmp(&mapping->guid, &s_zeroGUID, sizeof(mapping->guid)) == 0) {
1233 continue;
1234 }
1235 if (mapping_index == 0) {
1236 char *pMappingString;
1237 char pchGUID[33];
1238 size_t needed;
1239
1240 SDL_JoystickGetGUIDString(mapping->guid, pchGUID, sizeof(pchGUID));
1241 /* allocate enough memory for GUID + ',' + name + ',' + mapping + \0 */
1242 needed = SDL_strlen(pchGUID) + 1 + SDL_strlen(mapping->name) + 1 + SDL_strlen(mapping->mapping) + 1;
1243 pMappingString = SDL_malloc(needed);
1244 if (!pMappingString) {
1246 return NULL;
1247 }
1248 SDL_snprintf(pMappingString, needed, "%s,%s,%s", pchGUID, mapping->name, mapping->mapping);
1249 return pMappingString;
1250 }
1251 --mapping_index;
1252 }
1253 return NULL;
1254}
#define SDL_memcmp
static ControllerMapping_t * s_pSupportedControllers
static SDL_JoystickGUID s_zeroGUID

References NULL, s_pSupportedControllers, s_zeroGUID, SDL_JoystickGetGUIDString, SDL_malloc, SDL_memcmp, SDL_OutOfMemory, SDL_snprintf, and SDL_strlen.

◆ SDL_GameControllerName()

const char * SDL_GameControllerName ( SDL_GameController *  gamecontroller)

Return the name for this currently opened controller

Definition at line 1732 of file SDL_gamecontroller.c.

1733{
1734 if (!gamecontroller)
1735 return NULL;
1736
1737 if (SDL_strcmp(gamecontroller->name, "*") == 0) {
1738 return SDL_JoystickName(SDL_GameControllerGetJoystick(gamecontroller));
1739 } else {
1740 return gamecontroller->name;
1741 }
1742}
#define SDL_JoystickName
#define SDL_strcmp

References NULL, SDL_GameControllerGetJoystick(), SDL_JoystickName, and SDL_strcmp.

◆ SDL_GameControllerNameForIndex()

const char * SDL_GameControllerNameForIndex ( int  joystick_index)

Get the implementation dependent name of a game controller. This can be called before any controllers are opened. If no name can be found, this function returns NULL.

Definition at line 1399 of file SDL_gamecontroller.c.

1400{
1401 ControllerMapping_t *pSupportedController = SDL_PrivateGetControllerMapping(device_index);
1402 if (pSupportedController) {
1403 if (SDL_strcmp(pSupportedController->name, "*") == 0) {
1404 return SDL_JoystickNameForIndex(device_index);
1405 } else {
1406 return pSupportedController->name;
1407 }
1408 }
1409 return NULL;
1410}
#define SDL_JoystickNameForIndex

References ControllerMapping_t::name, NULL, SDL_JoystickNameForIndex, SDL_PrivateGetControllerMapping(), and SDL_strcmp.

◆ SDL_GameControllerNumMappings()

int SDL_GameControllerNumMappings ( void  )

Get the number of mappings installed

Returns
the number of mappings

Definition at line 1209 of file SDL_gamecontroller.c.

1210{
1211 int num_mappings = 0;
1213
1215 if (SDL_memcmp(&mapping->guid, &s_zeroGUID, sizeof(mapping->guid)) == 0) {
1216 continue;
1217 }
1218 ++num_mappings;
1219 }
1220 return num_mappings;
1221}

References s_pSupportedControllers, s_zeroGUID, and SDL_memcmp.

◆ SDL_GameControllerOpen()

SDL_GameController * SDL_GameControllerOpen ( int  joystick_index)

Open a game controller for use. The index passed as an argument refers to the N'th game controller on the system. This index is not the value which will identify this controller in future controller events. The joystick's instance id (SDL_JoystickID) will be used there instead.

Returns
A controller identifier, or NULL if an error occurred.

Definition at line 1541 of file SDL_gamecontroller.c.

1542{
1543 SDL_JoystickID instance_id;
1544 SDL_GameController *gamecontroller;
1545 SDL_GameController *gamecontrollerlist;
1546 ControllerMapping_t *pSupportedController = NULL;
1547
1549
1550 gamecontrollerlist = SDL_gamecontrollers;
1551 /* If the controller is already open, return it */
1552 instance_id = SDL_JoystickGetDeviceInstanceID(device_index);
1553 while (gamecontrollerlist) {
1554 if (instance_id == gamecontrollerlist->joystick->instance_id) {
1555 gamecontroller = gamecontrollerlist;
1556 ++gamecontroller->ref_count;
1558 return (gamecontroller);
1559 }
1560 gamecontrollerlist = gamecontrollerlist->next;
1561 }
1562
1563 /* Find a controller mapping */
1564 pSupportedController = SDL_PrivateGetControllerMapping(device_index);
1565 if (!pSupportedController) {
1566 SDL_SetError("Couldn't find mapping for device (%d)", device_index);
1568 return NULL;
1569 }
1570
1571 /* Create and initialize the controller */
1572 gamecontroller = (SDL_GameController *) SDL_calloc(1, sizeof(*gamecontroller));
1573 if (gamecontroller == NULL) {
1576 return NULL;
1577 }
1578
1579 gamecontroller->joystick = SDL_JoystickOpen(device_index);
1580 if (!gamecontroller->joystick) {
1581 SDL_free(gamecontroller);
1583 return NULL;
1584 }
1585
1586 if (gamecontroller->joystick->naxes) {
1587 gamecontroller->last_match_axis = (SDL_ExtendedGameControllerBind **)SDL_calloc(gamecontroller->joystick->naxes, sizeof(*gamecontroller->last_match_axis));
1588 if (!gamecontroller->last_match_axis) {
1590 SDL_JoystickClose(gamecontroller->joystick);
1591 SDL_free(gamecontroller);
1593 return NULL;
1594 }
1595 }
1596 if (gamecontroller->joystick->nhats) {
1597 gamecontroller->last_hat_mask = (Uint8 *)SDL_calloc(gamecontroller->joystick->nhats, sizeof(*gamecontroller->last_hat_mask));
1598 if (!gamecontroller->last_hat_mask) {
1600 SDL_JoystickClose(gamecontroller->joystick);
1601 SDL_free(gamecontroller->last_match_axis);
1602 SDL_free(gamecontroller);
1604 return NULL;
1605 }
1606 }
1607
1608 SDL_PrivateLoadButtonMapping(gamecontroller, pSupportedController->name, pSupportedController->mapping);
1609
1610 /* Add the controller to list */
1611 ++gamecontroller->ref_count;
1612 /* Link the controller in the list */
1613 gamecontroller->next = SDL_gamecontrollers;
1614 SDL_gamecontrollers = gamecontroller;
1615
1617
1618 return (gamecontroller);
1619}
#define SDL_JoystickGetDeviceInstanceID
#define SDL_JoystickOpen
#define SDL_calloc
static void SDL_PrivateLoadButtonMapping(SDL_GameController *gamecontroller, const char *pchName, const char *pchMapping)
Sint32 SDL_JoystickID
Definition: SDL_joystick.h:81
uint8_t Uint8
Definition: SDL_stdinc.h:179

References ControllerMapping_t::mapping, ControllerMapping_t::name, NULL, SDL_calloc, SDL_free, SDL_gamecontrollers, SDL_JoystickClose, SDL_JoystickGetDeviceInstanceID, SDL_JoystickOpen, SDL_LockJoysticks, SDL_OutOfMemory, SDL_PrivateGetControllerMapping(), SDL_PrivateLoadButtonMapping(), SDL_SetError, and SDL_UnlockJoysticks.

◆ SDL_GameControllerRumble()

int SDL_GameControllerRumble ( SDL_GameController *  gamecontroller,
Uint16  low_frequency_rumble,
Uint16  high_frequency_rumble,
Uint32  duration_ms 
)

Trigger a rumble effect Each call to this function cancels any previous rumble effect, and calling it with 0 intensity stops any rumbling.

Parameters
gamecontrollerThe controller to vibrate
low_frequency_rumbleThe intensity of the low frequency (left) rumble motor, from 0 to 0xFFFF
high_frequency_rumbleThe intensity of the high frequency (right) rumble motor, from 0 to 0xFFFF
duration_msThe duration of the rumble effect, in milliseconds
Returns
0, or -1 if rumble isn't supported on this joystick

Definition at line 1879 of file SDL_gamecontroller.c.

1880{
1881 return SDL_JoystickRumble(SDL_GameControllerGetJoystick(gamecontroller), low_frequency_rumble, high_frequency_rumble, duration_ms);
1882}
#define SDL_JoystickRumble

References SDL_GameControllerGetJoystick(), and SDL_JoystickRumble.

◆ SDL_GameControllerUpdate()

void SDL_GameControllerUpdate ( void  )

Update the current state of the open game controllers.

This is called automatically by the event loop if any game controller events are enabled.

Definition at line 1625 of file SDL_gamecontroller.c.

1626{
1627 /* Just for API completeness; the joystick API does all the work. */
1629}
#define SDL_JoystickUpdate

References SDL_JoystickUpdate.

◆ SDL_IsGameController()

SDL_bool SDL_IsGameController ( int  joystick_index)

Is the joystick on this index supported by the game controller interface?

Definition at line 1464 of file SDL_gamecontroller.c.

1465{
1466 ControllerMapping_t *pSupportedController = SDL_PrivateGetControllerMapping(device_index);
1467 if (pSupportedController) {
1468 return SDL_TRUE;
1469 }
1470 return SDL_FALSE;
1471}
@ SDL_TRUE
Definition: SDL_stdinc.h:164

References SDL_FALSE, SDL_PrivateGetControllerMapping(), and SDL_TRUE.

Referenced by SDL_GameControllerEventWatcher(), and SDL_GameControllerInit().