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.

Referenced by main(), and SDL_GameControllerInitMappings().

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

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 1186 of file SDL_gamecontroller.c.

References SDL_CONTROLLER_MAPPING_PRIORITY_API, and SDL_PrivateGameControllerAddMapping().

Referenced by SDL_GameControllerAddMappingsFromRW().

1187 {
1189 }
static int SDL_PrivateGameControllerAddMapping(const char *mappingString, SDL_ControllerMappingPriority priority)

◆ 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 1064 of file SDL_gamecontroller.c.

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.

1065 {
1066  const char *platform = SDL_GetPlatform();
1067  int controllers = 0;
1068  char *buf, *line, *line_end, *tmp, *comma, line_platform[64];
1069  size_t db_size, platform_len;
1070 
1071  if (rw == NULL) {
1072  return SDL_SetError("Invalid RWops");
1073  }
1074  db_size = (size_t)SDL_RWsize(rw);
1075 
1076  buf = (char *)SDL_malloc(db_size + 1);
1077  if (buf == NULL) {
1078  if (freerw) {
1079  SDL_RWclose(rw);
1080  }
1081  return SDL_SetError("Could not allocate space to read DB into memory");
1082  }
1083 
1084  if (SDL_RWread(rw, buf, db_size, 1) != 1) {
1085  if (freerw) {
1086  SDL_RWclose(rw);
1087  }
1088  SDL_free(buf);
1089  return SDL_SetError("Could not read DB");
1090  }
1091 
1092  if (freerw) {
1093  SDL_RWclose(rw);
1094  }
1095 
1096  buf[db_size] = '\0';
1097  line = buf;
1098 
1099  while (line < buf + db_size) {
1100  line_end = SDL_strchr(line, '\n');
1101  if (line_end != NULL) {
1102  *line_end = '\0';
1103  } else {
1104  line_end = buf + db_size;
1105  }
1106 
1107  /* Extract and verify the platform */
1109  if (tmp != NULL) {
1111  comma = SDL_strchr(tmp, ',');
1112  if (comma != NULL) {
1113  platform_len = comma - tmp + 1;
1114  if (platform_len + 1 < SDL_arraysize(line_platform)) {
1115  SDL_strlcpy(line_platform, tmp, platform_len);
1116  if (SDL_strncasecmp(line_platform, platform, platform_len) == 0 &&
1117  SDL_GameControllerAddMapping(line) > 0) {
1118  controllers++;
1119  }
1120  }
1121  }
1122  }
1123 
1124  line = line_end + 1;
1125  }
1126 
1127  SDL_free(buf);
1128  return controllers;
1129 }
#define SDL_strlcpy
#define SDL_CONTROLLER_PLATFORM_FIELD
#define SDL_RWsize(ctx)
Definition: SDL_rwops.h:184
#define SDL_RWread(ctx, ptr, size, n)
Definition: SDL_rwops.h:187
#define SDL_strncasecmp
unsigned int size_t
#define SDL_strchr
#define SDL_free
int SDL_GameControllerAddMapping(const char *mappingString)
#define SDL_GetPlatform
GLenum GLuint GLenum GLsizei const GLchar * buf
#define NULL
Definition: begin_code.h:164
#define SDL_RWclose(ctx)
Definition: SDL_rwops.h:189
#define SDL_SetError
#define SDL_strlen
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:115
#define SDL_malloc
#define SDL_strstr

◆ SDL_GameControllerClose()

void SDL_GameControllerClose ( SDL_GameController *  gamecontroller)

Close a controller previously opened with SDL_GameControllerOpen().

Definition at line 1860 of file SDL_gamecontroller.c.

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

Referenced by SDL_GameControllerQuit().

1861 {
1862  SDL_GameController *gamecontrollerlist, *gamecontrollerlistprev;
1863 
1864  if (!gamecontroller)
1865  return;
1866 
1868 
1869  /* First decrement ref count */
1870  if (--gamecontroller->ref_count > 0) {
1872  return;
1873  }
1874 
1875  SDL_JoystickClose(gamecontroller->joystick);
1876 
1877  gamecontrollerlist = SDL_gamecontrollers;
1878  gamecontrollerlistprev = NULL;
1879  while (gamecontrollerlist) {
1880  if (gamecontroller == gamecontrollerlist) {
1881  if (gamecontrollerlistprev) {
1882  /* unlink this entry */
1883  gamecontrollerlistprev->next = gamecontrollerlist->next;
1884  } else {
1885  SDL_gamecontrollers = gamecontroller->next;
1886  }
1887  break;
1888  }
1889  gamecontrollerlistprev = gamecontrollerlist;
1890  gamecontrollerlist = gamecontrollerlist->next;
1891  }
1892 
1893  SDL_free(gamecontroller->bindings);
1894  SDL_free(gamecontroller->last_match_axis);
1895  SDL_free(gamecontroller->last_hat_mask);
1896  SDL_free(gamecontroller);
1897 
1899 }
#define SDL_UnlockJoysticks
#define SDL_JoystickClose
static SDL_GameController * SDL_gamecontrollers
#define SDL_free
#define NULL
Definition: begin_code.h:164
#define SDL_LockJoysticks

◆ 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 2031 of file SDL_gamecontroller.c.

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

2032 {
2033 #if SDL_EVENTS_DISABLED
2034  return SDL_IGNORE;
2035 #else
2036  const Uint32 event_list[] = {
2039  };
2040  unsigned int i;
2041 
2042  switch (state) {
2043  case SDL_QUERY:
2044  state = SDL_IGNORE;
2045  for (i = 0; i < SDL_arraysize(event_list); ++i) {
2046  state = SDL_EventState(event_list[i], SDL_QUERY);
2047  if (state == SDL_ENABLE) {
2048  break;
2049  }
2050  }
2051  break;
2052  default:
2053  for (i = 0; i < SDL_arraysize(event_list); ++i) {
2054  SDL_EventState(event_list[i], state);
2055  }
2056  break;
2057  }
2058  return (state);
2059 #endif /* SDL_EVENTS_DISABLED */
2060 }
struct xkb_state * state
#define SDL_ENABLE
Definition: SDL_events.h:756
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
#define SDL_EventState
uint32_t Uint32
Definition: SDL_stdinc.h:203
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:115
#define SDL_QUERY
Definition: SDL_events.h:753
#define SDL_IGNORE
Definition: SDL_events.h:754

◆ SDL_GameControllerFromInstanceID()

SDL_GameController* SDL_GameControllerFromInstanceID ( SDL_JoystickID  joyid)

Return the SDL_GameController associated with an instance id.

Definition at line 1772 of file SDL_gamecontroller.c.

References NULL, SDL_gamecontrollers, SDL_LockJoysticks, and SDL_UnlockJoysticks.

1773 {
1774  SDL_GameController *gamecontroller;
1775 
1777  gamecontroller = SDL_gamecontrollers;
1778  while (gamecontroller) {
1779  if (gamecontroller->joystick->instance_id == joyid) {
1781  return gamecontroller;
1782  }
1783  gamecontroller = gamecontroller->next;
1784  }
1786  return NULL;
1787 }
#define SDL_UnlockJoysticks
static SDL_GameController * SDL_gamecontrollers
#define NULL
Definition: begin_code.h:164
#define SDL_LockJoysticks

◆ 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 1748 of file SDL_gamecontroller.c.

References SDL_FALSE, and SDL_JoystickGetAttached.

1749 {
1750  if (!gamecontroller)
1751  return SDL_FALSE;
1752 
1753  return SDL_JoystickGetAttached(gamecontroller->joystick);
1754 }
#define 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 1612 of file SDL_gamecontroller.c.

References SDL_ExtendedGameControllerBind::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.

1613 {
1614  int i;
1615 
1616  if (!gamecontroller)
1617  return 0;
1618 
1619  for (i = 0; i < gamecontroller->num_bindings; ++i) {
1620  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1621  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_AXIS && binding->output.axis.axis == axis) {
1622  int value = 0;
1623  SDL_bool valid_input_range;
1624  SDL_bool valid_output_range;
1625 
1626  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1627  value = SDL_JoystickGetAxis(gamecontroller->joystick, binding->input.axis.axis);
1628  if (binding->input.axis.axis_min < binding->input.axis.axis_max) {
1629  valid_input_range = (value >= binding->input.axis.axis_min && value <= binding->input.axis.axis_max);
1630  } else {
1631  valid_input_range = (value >= binding->input.axis.axis_max && value <= binding->input.axis.axis_min);
1632  }
1633  if (valid_input_range) {
1634  if (binding->input.axis.axis_min != binding->output.axis.axis_min || binding->input.axis.axis_max != binding->output.axis.axis_max) {
1635  float normalized_value = (float)(value - binding->input.axis.axis_min) / (binding->input.axis.axis_max - binding->input.axis.axis_min);
1636  value = binding->output.axis.axis_min + (int)(normalized_value * (binding->output.axis.axis_max - binding->output.axis.axis_min));
1637  }
1638  }
1639  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1640  value = SDL_JoystickGetButton(gamecontroller->joystick, binding->input.button);
1641  if (value == SDL_PRESSED) {
1642  value = binding->output.axis.axis_max;
1643  }
1644  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1645  int hat_mask = SDL_JoystickGetHat(gamecontroller->joystick, binding->input.hat.hat);
1646  if (hat_mask & binding->input.hat.hat_mask) {
1647  value = binding->output.axis.axis_max;
1648  }
1649  }
1650 
1651  if (binding->output.axis.axis_min < binding->output.axis.axis_max) {
1652  valid_output_range = (value >= binding->output.axis.axis_min && value <= binding->output.axis.axis_max);
1653  } else {
1654  valid_output_range = (value >= binding->output.axis.axis_max && value <= binding->output.axis.axis_min);
1655  }
1656  /* If the value is zero, there might be another binding that makes it non-zero */
1657  if (value != 0 && valid_output_range) {
1658  return (Sint16)value;
1659  }
1660  }
1661  }
1662  return 0;
1663 }
#define SDL_JoystickGetButton
union SDL_ExtendedGameControllerBind::@26 output
union SDL_ExtendedGameControllerBind::@25 input
SDL_GameControllerBindType inputType
SDL_Texture * axis
#define SDL_JoystickGetHat
SDL_GameControllerBindType outputType
GLsizei const GLfloat * value
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
SDL_bool
Definition: SDL_stdinc.h:161
#define SDL_JoystickGetAxis
#define SDL_PRESSED
Definition: SDL_events.h:50
int16_t Sint16
Definition: SDL_stdinc.h:185

◆ SDL_GameControllerGetAxisFromString()

SDL_GameControllerAxis SDL_GameControllerGetAxisFromString ( const char *  pchString)

turn this string into a axis mapping

Definition at line 461 of file SDL_gamecontroller.c.

References map_StringForControllerAxis, SDL_CONTROLLER_AXIS_INVALID, and SDL_strcasecmp.

Referenced by SDL_PrivateGameControllerParseElement().

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

◆ 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 1793 of file SDL_gamecontroller.c.

References SDL_ExtendedGameControllerBind::axis, SDL_GameControllerButtonBind::axis, SDL_GameControllerButtonBind::bindType, SDL_ExtendedGameControllerBind::button, SDL_GameControllerButtonBind::button, SDL_ExtendedGameControllerBind::hat, SDL_GameControllerButtonBind::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.

1794 {
1795  int i;
1797  SDL_zero(bind);
1798 
1799  if (!gamecontroller || axis == SDL_CONTROLLER_AXIS_INVALID)
1800  return bind;
1801 
1802  for (i = 0; i < gamecontroller->num_bindings; ++i) {
1803  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1804  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_AXIS && binding->output.axis.axis == axis) {
1805  bind.bindType = binding->inputType;
1806  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1807  /* FIXME: There might be multiple axes bound now that we have axis ranges... */
1808  bind.value.axis = binding->input.axis.axis;
1809  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1810  bind.value.button = binding->input.button;
1811  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1812  bind.value.hat.hat = binding->input.hat.hat;
1813  bind.value.hat.hat_mask = binding->input.hat.hat_mask;
1814  }
1815  break;
1816  }
1817  }
1818  return bind;
1819 }
union SDL_ExtendedGameControllerBind::@26 output
union SDL_ExtendedGameControllerBind::@25 input
SDL_GameControllerBindType inputType
SDL_Texture * axis
SDL_GameControllerBindType bindType
SDL_GameControllerBindType outputType
#define SDL_zero(x)
Definition: SDL_stdinc.h:416
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
union SDL_GameControllerButtonBind::@0 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 1825 of file SDL_gamecontroller.c.

References SDL_ExtendedGameControllerBind::axis, SDL_GameControllerButtonBind::axis, SDL_GameControllerButtonBind::bindType, SDL_ExtendedGameControllerBind::button, SDL_GameControllerButtonBind::button, SDL_ExtendedGameControllerBind::hat, SDL_GameControllerButtonBind::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.

1826 {
1827  int i;
1829  SDL_zero(bind);
1830 
1831  if (!gamecontroller || button == SDL_CONTROLLER_BUTTON_INVALID)
1832  return bind;
1833 
1834  for (i = 0; i < gamecontroller->num_bindings; ++i) {
1835  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1836  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_BUTTON && binding->output.button == button) {
1837  bind.bindType = binding->inputType;
1838  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1839  bind.value.axis = binding->input.axis.axis;
1840  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1841  bind.value.button = binding->input.button;
1842  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1843  bind.value.hat.hat = binding->input.hat.hat;
1844  bind.value.hat.hat_mask = binding->input.hat.hat_mask;
1845  }
1846  break;
1847  }
1848  }
1849  return bind;
1850 }
SDL_Texture * button
union SDL_ExtendedGameControllerBind::@26 output
union SDL_ExtendedGameControllerBind::@25 input
SDL_GameControllerBindType inputType
SDL_GameControllerBindType bindType
SDL_GameControllerBindType outputType
#define SDL_zero(x)
Definition: SDL_stdinc.h:416
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
union SDL_GameControllerButtonBind::@0 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 1669 of file SDL_gamecontroller.c.

References SDL_ExtendedGameControllerBind::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, SDL_PRESSED, and SDL_RELEASED.

1670 {
1671  int i;
1672 
1673  if (!gamecontroller)
1674  return 0;
1675 
1676  for (i = 0; i < gamecontroller->num_bindings; ++i) {
1677  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1678  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_BUTTON && binding->output.button == button) {
1679  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1680  SDL_bool valid_input_range;
1681 
1682  int value = SDL_JoystickGetAxis(gamecontroller->joystick, binding->input.axis.axis);
1683  int threshold = binding->input.axis.axis_min + (binding->input.axis.axis_max - binding->input.axis.axis_min) / 2;
1684  if (binding->input.axis.axis_min < binding->input.axis.axis_max) {
1685  valid_input_range = (value >= binding->input.axis.axis_min && value <= binding->input.axis.axis_max);
1686  if (valid_input_range) {
1687  return (value >= threshold) ? SDL_PRESSED : SDL_RELEASED;
1688  }
1689  } else {
1690  valid_input_range = (value >= binding->input.axis.axis_max && value <= binding->input.axis.axis_min);
1691  if (valid_input_range) {
1692  return (value <= threshold) ? SDL_PRESSED : SDL_RELEASED;
1693  }
1694  }
1695  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1696  return SDL_JoystickGetButton(gamecontroller->joystick, binding->input.button);
1697  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1698  int hat_mask = SDL_JoystickGetHat(gamecontroller->joystick, binding->input.hat.hat);
1699  return (hat_mask & binding->input.hat.hat_mask) ? SDL_PRESSED : SDL_RELEASED;
1700  }
1701  }
1702  }
1703  return SDL_RELEASED;
1704 }
#define SDL_JoystickGetButton
SDL_Texture * button
union SDL_ExtendedGameControllerBind::@26 output
union SDL_ExtendedGameControllerBind::@25 input
SDL_GameControllerBindType inputType
#define SDL_JoystickGetHat
SDL_GameControllerBindType outputType
GLsizei const GLfloat * value
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
SDL_bool
Definition: SDL_stdinc.h:161
#define SDL_JoystickGetAxis
#define SDL_PRESSED
Definition: SDL_events.h:50
#define SDL_RELEASED
Definition: SDL_events.h:49

◆ SDL_GameControllerGetButtonFromString()

SDL_GameControllerButton SDL_GameControllerGetButtonFromString ( const char *  pchString)

turn this string into a button mapping

Definition at line 513 of file SDL_gamecontroller.c.

References map_StringForControllerButton, SDL_CONTROLLER_BUTTON_INVALID, and SDL_strcasecmp.

Referenced by SDL_PrivateGameControllerParseElement().

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

◆ SDL_GameControllerGetJoystick()

SDL_Joystick* SDL_GameControllerGetJoystick ( SDL_GameController *  gamecontroller)

Get the underlying joystick object used by a controller

Definition at line 1759 of file SDL_gamecontroller.c.

References NULL.

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

1760 {
1761  if (!gamecontroller)
1762  return NULL;
1763 
1764  return gamecontroller->joystick;
1765 }
#define NULL
Definition: begin_code.h:164

◆ 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 1720 of file SDL_gamecontroller.c.

References SDL_GameControllerGetJoystick(), and SDL_JoystickGetPlayerIndex.

1721 {
1723 }
#define SDL_JoystickGetPlayerIndex
SDL_Joystick * SDL_GameControllerGetJoystick(SDL_GameController *gamecontroller)

◆ 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 1732 of file SDL_gamecontroller.c.

References SDL_GameControllerGetJoystick(), and SDL_JoystickGetProduct.

1733 {
1734  return SDL_JoystickGetProduct(SDL_GameControllerGetJoystick(gamecontroller));
1735 }
#define SDL_JoystickGetProduct
SDL_Joystick * SDL_GameControllerGetJoystick(SDL_GameController *gamecontroller)

◆ 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 1738 of file SDL_gamecontroller.c.

References SDL_GameControllerGetJoystick(), and SDL_JoystickGetProductVersion.

1739 {
1741 }
SDL_Joystick * SDL_GameControllerGetJoystick(SDL_GameController *gamecontroller)
#define SDL_JoystickGetProductVersion

◆ SDL_GameControllerGetStringForAxis()

const char* SDL_GameControllerGetStringForAxis ( SDL_GameControllerAxis  axis)

turn this axis enum into a string mapping

Definition at line 483 of file SDL_gamecontroller.c.

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

484 {
487  }
488  return NULL;
489 }
static const char * map_StringForControllerAxis[]
SDL_Texture * axis
#define NULL
Definition: begin_code.h:164

◆ SDL_GameControllerGetStringForButton()

const char* SDL_GameControllerGetStringForButton ( SDL_GameControllerButton  button)

turn this button enum into a string mapping

Definition at line 529 of file SDL_gamecontroller.c.

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

530 {
533  }
534  return NULL;
535 }
SDL_Texture * axis
static const char * map_StringForControllerButton[]
#define NULL
Definition: begin_code.h:164

◆ 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 1726 of file SDL_gamecontroller.c.

References SDL_GameControllerGetJoystick(), and SDL_JoystickGetVendor.

1727 {
1728  return SDL_JoystickGetVendor(SDL_GameControllerGetJoystick(gamecontroller));
1729 }
#define SDL_JoystickGetVendor
SDL_Joystick * SDL_GameControllerGetJoystick(SDL_GameController *gamecontroller)

◆ 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 1270 of file SDL_gamecontroller.c.

References NULL, and SDL_GameControllerMappingForGUID().

1271 {
1272  if (!gamecontroller) {
1273  return NULL;
1274  }
1275 
1276  return SDL_GameControllerMappingForGUID(gamecontroller->joystick->guid);
1277 }
#define NULL
Definition: begin_code.h:164
char * SDL_GameControllerMappingForGUID(SDL_JoystickGUID guid)

◆ 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 1403 of file SDL_gamecontroller.c.

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

1404 {
1405  char *pMappingString = NULL;
1407 
1409  mapping = SDL_PrivateGetControllerMapping(joystick_index);
1410  if (mapping) {
1411  SDL_JoystickGUID guid;
1412  char pchGUID[33];
1413  size_t needed;
1414  guid = SDL_JoystickGetDeviceGUID(joystick_index);
1415  SDL_JoystickGetGUIDString(guid, pchGUID, sizeof(pchGUID));
1416  /* allocate enough memory for GUID + ',' + name + ',' + mapping + \0 */
1417  needed = SDL_strlen(pchGUID) + 1 + SDL_strlen(mapping->name) + 1 + SDL_strlen(mapping->mapping) + 1;
1418  pMappingString = SDL_malloc(needed);
1419  if (!pMappingString) {
1420  SDL_OutOfMemory();
1422  return NULL;
1423  }
1424  SDL_snprintf(pMappingString, needed, "%s,%s,%s", pchGUID, mapping->name, mapping->mapping);
1425  }
1427  return pMappingString;
1428 }
#define SDL_UnlockJoysticks
#define SDL_JoystickGetGUIDString
#define SDL_JoystickGetDeviceGUID
static ControllerMapping_t * SDL_PrivateGetControllerMapping(int device_index)
#define NULL
Definition: begin_code.h:164
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
#define SDL_strlen
#define SDL_snprintf
GLenum GLenum GLenum GLenum mapping
#define SDL_malloc
#define SDL_LockJoysticks

◆ 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 1246 of file SDL_gamecontroller.c.

References ControllerMapping_t::mapping, ControllerMapping_t::name, NULL, SDL_FALSE, SDL_JoystickGetGUIDString, SDL_malloc, SDL_OutOfMemory, SDL_PrivateGetControllerMappingForGUID(), SDL_snprintf, and SDL_strlen.

Referenced by SDL_GameControllerMapping().

1247 {
1248  char *pMappingString = NULL;
1250  if (mapping) {
1251  char pchGUID[33];
1252  size_t needed;
1253  SDL_JoystickGetGUIDString(guid, pchGUID, sizeof(pchGUID));
1254  /* allocate enough memory for GUID + ',' + name + ',' + mapping + \0 */
1255  needed = SDL_strlen(pchGUID) + 1 + SDL_strlen(mapping->name) + 1 + SDL_strlen(mapping->mapping) + 1;
1256  pMappingString = SDL_malloc(needed);
1257  if (!pMappingString) {
1258  SDL_OutOfMemory();
1259  return NULL;
1260  }
1261  SDL_snprintf(pMappingString, needed, "%s,%s,%s", pchGUID, mapping->name, mapping->mapping);
1262  }
1263  return pMappingString;
1264 }
#define SDL_JoystickGetGUIDString
static ControllerMapping_t * SDL_PrivateGetControllerMappingForGUID(SDL_JoystickGUID *guid, SDL_bool exact_match)
#define NULL
Definition: begin_code.h:164
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
#define SDL_strlen
#define SDL_snprintf
GLenum GLenum GLenum GLenum mapping
#define SDL_malloc

◆ 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 1213 of file SDL_gamecontroller.c.

References ControllerMapping_t::guid, ControllerMapping_t::mapping, ControllerMapping_t::name, ControllerMapping_t::next, NULL, SDL_JoystickGetGUIDString, SDL_malloc, SDL_memcmp, SDL_OutOfMemory, SDL_snprintf, and SDL_strlen.

1214 {
1216 
1217  for (mapping = s_pSupportedControllers; mapping; mapping = mapping->next) {
1218  if (SDL_memcmp(&mapping->guid, &s_zeroGUID, sizeof(mapping->guid)) == 0) {
1219  continue;
1220  }
1221  if (mapping_index == 0) {
1222  char *pMappingString;
1223  char pchGUID[33];
1224  size_t needed;
1225 
1226  SDL_JoystickGetGUIDString(mapping->guid, pchGUID, sizeof(pchGUID));
1227  /* allocate enough memory for GUID + ',' + name + ',' + mapping + \0 */
1228  needed = SDL_strlen(pchGUID) + 1 + SDL_strlen(mapping->name) + 1 + SDL_strlen(mapping->mapping) + 1;
1229  pMappingString = SDL_malloc(needed);
1230  if (!pMappingString) {
1231  SDL_OutOfMemory();
1232  return NULL;
1233  }
1234  SDL_snprintf(pMappingString, needed, "%s,%s,%s", pchGUID, mapping->name, mapping->mapping);
1235  return pMappingString;
1236  }
1237  --mapping_index;
1238  }
1239  return NULL;
1240 }
struct _ControllerMapping_t * next
#define SDL_JoystickGetGUIDString
SDL_JoystickGUID guid
static ControllerMapping_t * s_pSupportedControllers
#define SDL_memcmp
#define NULL
Definition: begin_code.h:164
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
static SDL_JoystickGUID s_zeroGUID
#define SDL_strlen
#define SDL_snprintf
GLenum GLenum GLenum GLenum mapping
#define SDL_malloc

◆ SDL_GameControllerName()

const char* SDL_GameControllerName ( SDL_GameController *  gamecontroller)

Return the name for this currently opened controller

Definition at line 1707 of file SDL_gamecontroller.c.

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

1708 {
1709  if (!gamecontroller)
1710  return NULL;
1711 
1712  if (SDL_strcmp(gamecontroller->name, "*") == 0) {
1713  return SDL_JoystickName(SDL_GameControllerGetJoystick(gamecontroller));
1714  } else {
1715  return gamecontroller->name;
1716  }
1717 }
#define SDL_JoystickName
#define NULL
Definition: begin_code.h:164
SDL_Joystick * SDL_GameControllerGetJoystick(SDL_GameController *gamecontroller)
#define 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 1383 of file SDL_gamecontroller.c.

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

1384 {
1385  ControllerMapping_t *pSupportedController = SDL_PrivateGetControllerMapping(device_index);
1386  if (pSupportedController) {
1387  if (SDL_strcmp(pSupportedController->name, "*") == 0) {
1388  return SDL_JoystickNameForIndex(device_index);
1389  } else {
1390  return pSupportedController->name;
1391  }
1392  }
1393  return NULL;
1394 }
#define SDL_JoystickNameForIndex
static ControllerMapping_t * SDL_PrivateGetControllerMapping(int device_index)
#define NULL
Definition: begin_code.h:164
#define SDL_strcmp

◆ SDL_GameControllerNumMappings()

int SDL_GameControllerNumMappings ( void  )

Get the number of mappings installed

Returns
the number of mappings

Definition at line 1195 of file SDL_gamecontroller.c.

References ControllerMapping_t::guid, ControllerMapping_t::next, and SDL_memcmp.

1196 {
1197  int num_mappings = 0;
1199 
1200  for (mapping = s_pSupportedControllers; mapping; mapping = mapping->next) {
1201  if (SDL_memcmp(&mapping->guid, &s_zeroGUID, sizeof(mapping->guid)) == 0) {
1202  continue;
1203  }
1204  ++num_mappings;
1205  }
1206  return num_mappings;
1207 }
struct _ControllerMapping_t * next
SDL_JoystickGUID guid
static ControllerMapping_t * s_pSupportedControllers
#define SDL_memcmp
static SDL_JoystickGUID s_zeroGUID
GLenum GLenum GLenum GLenum mapping

◆ 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 1518 of file SDL_gamecontroller.c.

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.

1519 {
1520  SDL_JoystickID instance_id;
1521  SDL_GameController *gamecontroller;
1522  SDL_GameController *gamecontrollerlist;
1523  ControllerMapping_t *pSupportedController = NULL;
1524 
1526 
1527  gamecontrollerlist = SDL_gamecontrollers;
1528  /* If the controller is already open, return it */
1529  instance_id = SDL_JoystickGetDeviceInstanceID(device_index);
1530  while (gamecontrollerlist) {
1531  if (instance_id == gamecontrollerlist->joystick->instance_id) {
1532  gamecontroller = gamecontrollerlist;
1533  ++gamecontroller->ref_count;
1535  return (gamecontroller);
1536  }
1537  gamecontrollerlist = gamecontrollerlist->next;
1538  }
1539 
1540  /* Find a controller mapping */
1541  pSupportedController = SDL_PrivateGetControllerMapping(device_index);
1542  if (!pSupportedController) {
1543  SDL_SetError("Couldn't find mapping for device (%d)", device_index);
1545  return NULL;
1546  }
1547 
1548  /* Create and initialize the controller */
1549  gamecontroller = (SDL_GameController *) SDL_calloc(1, sizeof(*gamecontroller));
1550  if (gamecontroller == NULL) {
1551  SDL_OutOfMemory();
1553  return NULL;
1554  }
1555 
1556  gamecontroller->joystick = SDL_JoystickOpen(device_index);
1557  if (!gamecontroller->joystick) {
1558  SDL_free(gamecontroller);
1560  return NULL;
1561  }
1562 
1563  if (gamecontroller->joystick->naxes) {
1564  gamecontroller->last_match_axis = (SDL_ExtendedGameControllerBind **)SDL_calloc(gamecontroller->joystick->naxes, sizeof(*gamecontroller->last_match_axis));
1565  if (!gamecontroller->last_match_axis) {
1566  SDL_OutOfMemory();
1567  SDL_JoystickClose(gamecontroller->joystick);
1568  SDL_free(gamecontroller);
1570  return NULL;
1571  }
1572  }
1573  if (gamecontroller->joystick->nhats) {
1574  gamecontroller->last_hat_mask = (Uint8 *)SDL_calloc(gamecontroller->joystick->nhats, sizeof(*gamecontroller->last_hat_mask));
1575  if (!gamecontroller->last_hat_mask) {
1576  SDL_OutOfMemory();
1577  SDL_JoystickClose(gamecontroller->joystick);
1578  SDL_free(gamecontroller->last_match_axis);
1579  SDL_free(gamecontroller);
1581  return NULL;
1582  }
1583  }
1584 
1585  SDL_PrivateLoadButtonMapping(gamecontroller, pSupportedController->name, pSupportedController->mapping);
1586 
1587  /* Add the controller to list */
1588  ++gamecontroller->ref_count;
1589  /* Link the controller in the list */
1590  gamecontroller->next = SDL_gamecontrollers;
1591  SDL_gamecontrollers = gamecontroller;
1592 
1594 
1595  return (gamecontroller);
1596 }
#define SDL_UnlockJoysticks
#define SDL_JoystickClose
#define SDL_JoystickOpen
Sint32 SDL_JoystickID
Definition: SDL_joystick.h:81
#define SDL_JoystickGetDeviceInstanceID
static SDL_GameController * SDL_gamecontrollers
uint8_t Uint8
Definition: SDL_stdinc.h:179
#define SDL_free
static ControllerMapping_t * SDL_PrivateGetControllerMapping(int device_index)
#define NULL
Definition: begin_code.h:164
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
#define SDL_SetError
#define SDL_calloc
static void SDL_PrivateLoadButtonMapping(SDL_GameController *gamecontroller, const char *pchName, const char *pchMapping)
#define SDL_LockJoysticks

◆ 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 1854 of file SDL_gamecontroller.c.

References SDL_GameControllerGetJoystick(), and SDL_JoystickRumble.

1855 {
1856  return SDL_JoystickRumble(SDL_GameControllerGetJoystick(gamecontroller), low_frequency_rumble, high_frequency_rumble, duration_ms);
1857 }
#define SDL_JoystickRumble
SDL_Joystick * SDL_GameControllerGetJoystick(SDL_GameController *gamecontroller)

◆ 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 1602 of file SDL_gamecontroller.c.

References SDL_JoystickUpdate.

1603 {
1604  /* Just for API completeness; the joystick API does all the work. */
1606 }
#define 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 1448 of file SDL_gamecontroller.c.

References SDL_FALSE, SDL_PrivateGetControllerMapping(), and SDL_TRUE.

Referenced by SDL_GameControllerEventWatcher(), and SDL_GameControllerInit().

1449 {
1450  ControllerMapping_t *pSupportedController = SDL_PrivateGetControllerMapping(device_index);
1451  if (pSupportedController) {
1452  return SDL_TRUE;
1453  }
1454  return SDL_FALSE;
1455 }
static ControllerMapping_t * SDL_PrivateGetControllerMapping(int device_index)