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)
 
SDL_GameController * SDL_GameControllerOpen (int joystick_index)
 
SDL_GameController * SDL_GameControllerFromInstanceID (SDL_JoystickID joyid)
 
const char * SDL_GameControllerName (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)
 
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 257 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 301 of file SDL_gamecontroller.h.

302 {
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 1065 of file SDL_gamecontroller.c.

References SDL_CONTROLLER_MAPPING_PRIORITY_API, and SDL_PrivateGameControllerAddMapping().

Referenced by SDL_GameControllerAddMappingsFromRW().

1066 {
1068 }
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 946 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.

947 {
948  const char *platform = SDL_GetPlatform();
949  int controllers = 0;
950  char *buf, *line, *line_end, *tmp, *comma, line_platform[64];
951  size_t db_size, platform_len;
952 
953  if (rw == NULL) {
954  return SDL_SetError("Invalid RWops");
955  }
956  db_size = (size_t)SDL_RWsize(rw);
957 
958  buf = (char *)SDL_malloc(db_size + 1);
959  if (buf == NULL) {
960  if (freerw) {
961  SDL_RWclose(rw);
962  }
963  return SDL_SetError("Could not allocate space to read DB into memory");
964  }
965 
966  if (SDL_RWread(rw, buf, db_size, 1) != 1) {
967  if (freerw) {
968  SDL_RWclose(rw);
969  }
970  SDL_free(buf);
971  return SDL_SetError("Could not read DB");
972  }
973 
974  if (freerw) {
975  SDL_RWclose(rw);
976  }
977 
978  buf[db_size] = '\0';
979  line = buf;
980 
981  while (line < buf + db_size) {
982  line_end = SDL_strchr(line, '\n');
983  if (line_end != NULL) {
984  *line_end = '\0';
985  } else {
986  line_end = buf + db_size;
987  }
988 
989  /* Extract and verify the platform */
991  if (tmp != NULL) {
993  comma = SDL_strchr(tmp, ',');
994  if (comma != NULL) {
995  platform_len = comma - tmp + 1;
996  if (platform_len + 1 < SDL_arraysize(line_platform)) {
997  SDL_strlcpy(line_platform, tmp, platform_len);
998  if (SDL_strncasecmp(line_platform, platform, platform_len) == 0 &&
999  SDL_GameControllerAddMapping(line) > 0) {
1000  controllers++;
1001  }
1002  }
1003  }
1004  }
1005 
1006  line = line_end + 1;
1007  }
1008 
1009  SDL_free(buf);
1010  return controllers;
1011 }
#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
#define SDL_strchr
unsigned int size_t
#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:93
#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 1687 of file SDL_gamecontroller.c.

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

Referenced by SDL_GameControllerQuit().

1688 {
1689  SDL_GameController *gamecontrollerlist, *gamecontrollerlistprev;
1690 
1691  if (!gamecontroller)
1692  return;
1693 
1695 
1696  /* First decrement ref count */
1697  if (--gamecontroller->ref_count > 0) {
1699  return;
1700  }
1701 
1702  SDL_JoystickClose(gamecontroller->joystick);
1703 
1704  gamecontrollerlist = SDL_gamecontrollers;
1705  gamecontrollerlistprev = NULL;
1706  while (gamecontrollerlist) {
1707  if (gamecontroller == gamecontrollerlist) {
1708  if (gamecontrollerlistprev) {
1709  /* unlink this entry */
1710  gamecontrollerlistprev->next = gamecontrollerlist->next;
1711  } else {
1712  SDL_gamecontrollers = gamecontroller->next;
1713  }
1714  break;
1715  }
1716  gamecontrollerlistprev = gamecontrollerlist;
1717  gamecontrollerlist = gamecontrollerlist->next;
1718  }
1719 
1720  SDL_free(gamecontroller->bindings);
1721  SDL_free(gamecontroller->last_match_axis);
1722  SDL_free(gamecontroller->last_hat_mask);
1723  SDL_free(gamecontroller);
1724 
1726 }
#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 1840 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.

1841 {
1842 #if SDL_EVENTS_DISABLED
1843  return SDL_IGNORE;
1844 #else
1845  const Uint32 event_list[] = {
1848  };
1849  unsigned int i;
1850 
1851  switch (state) {
1852  case SDL_QUERY:
1853  state = SDL_IGNORE;
1854  for (i = 0; i < SDL_arraysize(event_list); ++i) {
1855  state = SDL_EventState(event_list[i], SDL_QUERY);
1856  if (state == SDL_ENABLE) {
1857  break;
1858  }
1859  }
1860  break;
1861  default:
1862  for (i = 0; i < SDL_arraysize(event_list); ++i) {
1863  SDL_EventState(event_list[i], state);
1864  }
1865  break;
1866  }
1867  return (state);
1868 #endif /* SDL_EVENTS_DISABLED */
1869 }
struct xkb_state * state
#define SDL_ENABLE
Definition: SDL_events.h:722
uint32_t Uint32
Definition: SDL_stdinc.h:181
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
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:93
#define SDL_QUERY
Definition: SDL_events.h:719
#define SDL_IGNORE
Definition: SDL_events.h:720

◆ SDL_GameControllerFromInstanceID()

SDL_GameController* SDL_GameControllerFromInstanceID ( SDL_JoystickID  joyid)

Return the SDL_GameController associated with an instance id.

Definition at line 1605 of file SDL_gamecontroller.c.

References NULL, SDL_gamecontrollers, SDL_LockJoysticks, and SDL_UnlockJoysticks.

1606 {
1607  SDL_GameController *gamecontroller;
1608 
1610  gamecontroller = SDL_gamecontrollers;
1611  while (gamecontroller) {
1612  if (gamecontroller->joystick->instance_id == joyid) {
1614  return gamecontroller;
1615  }
1616  gamecontroller = gamecontroller->next;
1617  }
1619  return NULL;
1620 }
#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 1581 of file SDL_gamecontroller.c.

References SDL_FALSE, and SDL_JoystickGetAttached.

1582 {
1583  if (!gamecontroller)
1584  return SDL_FALSE;
1585 
1586  return SDL_JoystickGetAttached(gamecontroller->joystick);
1587 }
#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 1455 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.

1456 {
1457  int i;
1458 
1459  if (!gamecontroller)
1460  return 0;
1461 
1462  for (i = 0; i < gamecontroller->num_bindings; ++i) {
1463  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1464  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_AXIS && binding->output.axis.axis == axis) {
1465  int value = 0;
1466  SDL_bool valid_input_range;
1467  SDL_bool valid_output_range;
1468 
1469  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1470  value = SDL_JoystickGetAxis(gamecontroller->joystick, binding->input.axis.axis);
1471  if (binding->input.axis.axis_min < binding->input.axis.axis_max) {
1472  valid_input_range = (value >= binding->input.axis.axis_min && value <= binding->input.axis.axis_max);
1473  } else {
1474  valid_input_range = (value >= binding->input.axis.axis_max && value <= binding->input.axis.axis_min);
1475  }
1476  if (valid_input_range) {
1477  if (binding->input.axis.axis_min != binding->output.axis.axis_min || binding->input.axis.axis_max != binding->output.axis.axis_max) {
1478  float normalized_value = (float)(value - binding->input.axis.axis_min) / (binding->input.axis.axis_max - binding->input.axis.axis_min);
1479  value = binding->output.axis.axis_min + (int)(normalized_value * (binding->output.axis.axis_max - binding->output.axis.axis_min));
1480  }
1481  }
1482  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1483  value = SDL_JoystickGetButton(gamecontroller->joystick, binding->input.button);
1484  if (value == SDL_PRESSED) {
1485  value = binding->output.axis.axis_max;
1486  }
1487  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1488  int hat_mask = SDL_JoystickGetHat(gamecontroller->joystick, binding->input.hat.hat);
1489  if (hat_mask & binding->input.hat.hat_mask) {
1490  value = binding->output.axis.axis_max;
1491  }
1492  }
1493 
1494  if (binding->output.axis.axis_min < binding->output.axis.axis_max) {
1495  valid_output_range = (value >= binding->output.axis.axis_min && value <= binding->output.axis.axis_max);
1496  } else {
1497  valid_output_range = (value >= binding->output.axis.axis_max && value <= binding->output.axis.axis_min);
1498  }
1499  /* If the value is zero, there might be another binding that makes it non-zero */
1500  if (value != 0 && valid_output_range) {
1501  return (Sint16)value;
1502  }
1503  }
1504  }
1505  return 0;
1506 }
union SDL_ExtendedGameControllerBind::@24 output
#define SDL_JoystickGetButton
SDL_GameControllerBindType inputType
SDL_Texture * axis
#define SDL_JoystickGetHat
union SDL_ExtendedGameControllerBind::@23 input
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:139
#define SDL_JoystickGetAxis
#define SDL_PRESSED
Definition: SDL_events.h:50
int16_t Sint16
Definition: SDL_stdinc.h:163

◆ SDL_GameControllerGetAxisFromString()

SDL_GameControllerAxis SDL_GameControllerGetAxisFromString ( const char *  pchString)

turn this string into a axis mapping

Definition at line 444 of file SDL_gamecontroller.c.

References map_StringForControllerAxis, SDL_CONTROLLER_AXIS_INVALID, and SDL_strcasecmp.

Referenced by SDL_PrivateGameControllerParseElement().

445 {
446  int entry;
447 
448  if (pchString && (*pchString == '+' || *pchString == '-')) {
449  ++pchString;
450  }
451 
452  if (!pchString || !pchString[0]) {
454  }
455 
456  for (entry = 0; map_StringForControllerAxis[entry]; ++entry) {
457  if (!SDL_strcasecmp(pchString, map_StringForControllerAxis[entry]))
458  return (SDL_GameControllerAxis) entry;
459  }
461 }
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 1626 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.

1627 {
1628  int i;
1630  SDL_zero(bind);
1631 
1632  if (!gamecontroller || axis == SDL_CONTROLLER_AXIS_INVALID)
1633  return bind;
1634 
1635  for (i = 0; i < gamecontroller->num_bindings; ++i) {
1636  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1637  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_AXIS && binding->output.axis.axis == axis) {
1638  bind.bindType = binding->inputType;
1639  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1640  /* FIXME: There might be multiple axes bound now that we have axis ranges... */
1641  bind.value.axis = binding->input.axis.axis;
1642  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1643  bind.value.button = binding->input.button;
1644  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1645  bind.value.hat.hat = binding->input.hat.hat;
1646  bind.value.hat.hat_mask = binding->input.hat.hat_mask;
1647  }
1648  break;
1649  }
1650  }
1651  return bind;
1652 }
union SDL_ExtendedGameControllerBind::@24 output
SDL_GameControllerBindType inputType
SDL_Texture * axis
union SDL_ExtendedGameControllerBind::@23 input
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 1658 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.

1659 {
1660  int i;
1662  SDL_zero(bind);
1663 
1664  if (!gamecontroller || button == SDL_CONTROLLER_BUTTON_INVALID)
1665  return bind;
1666 
1667  for (i = 0; i < gamecontroller->num_bindings; ++i) {
1668  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1669  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_BUTTON && binding->output.button == button) {
1670  bind.bindType = binding->inputType;
1671  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1672  bind.value.axis = binding->input.axis.axis;
1673  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1674  bind.value.button = binding->input.button;
1675  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1676  bind.value.hat.hat = binding->input.hat.hat;
1677  bind.value.hat.hat_mask = binding->input.hat.hat_mask;
1678  }
1679  break;
1680  }
1681  }
1682  return bind;
1683 }
union SDL_ExtendedGameControllerBind::@24 output
SDL_Texture * button
SDL_GameControllerBindType inputType
union SDL_ExtendedGameControllerBind::@23 input
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 1512 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.

1513 {
1514  int i;
1515 
1516  if (!gamecontroller)
1517  return 0;
1518 
1519  for (i = 0; i < gamecontroller->num_bindings; ++i) {
1520  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1521  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_BUTTON && binding->output.button == button) {
1522  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1523  SDL_bool valid_input_range;
1524 
1525  int value = SDL_JoystickGetAxis(gamecontroller->joystick, binding->input.axis.axis);
1526  int threshold = binding->input.axis.axis_min + (binding->input.axis.axis_max - binding->input.axis.axis_min) / 2;
1527  if (binding->input.axis.axis_min < binding->input.axis.axis_max) {
1528  valid_input_range = (value >= binding->input.axis.axis_min && value <= binding->input.axis.axis_max);
1529  if (valid_input_range) {
1530  return (value >= threshold) ? SDL_PRESSED : SDL_RELEASED;
1531  }
1532  } else {
1533  valid_input_range = (value >= binding->input.axis.axis_max && value <= binding->input.axis.axis_min);
1534  if (valid_input_range) {
1535  return (value <= threshold) ? SDL_PRESSED : SDL_RELEASED;
1536  }
1537  }
1538  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1539  return SDL_JoystickGetButton(gamecontroller->joystick, binding->input.button);
1540  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1541  int hat_mask = SDL_JoystickGetHat(gamecontroller->joystick, binding->input.hat.hat);
1542  return (hat_mask & binding->input.hat.hat_mask) ? SDL_PRESSED : SDL_RELEASED;
1543  }
1544  }
1545  }
1546  return SDL_RELEASED;
1547 }
union SDL_ExtendedGameControllerBind::@24 output
#define SDL_JoystickGetButton
SDL_Texture * button
SDL_GameControllerBindType inputType
#define SDL_JoystickGetHat
union SDL_ExtendedGameControllerBind::@23 input
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:139
#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 496 of file SDL_gamecontroller.c.

References map_StringForControllerButton, SDL_CONTROLLER_BUTTON_INVALID, and SDL_strcasecmp.

Referenced by SDL_PrivateGameControllerParseElement().

497 {
498  int entry;
499  if (!pchString || !pchString[0])
501 
502  for (entry = 0; map_StringForControllerButton[entry]; ++entry) {
503  if (SDL_strcasecmp(pchString, map_StringForControllerButton[entry]) == 0)
504  return (SDL_GameControllerButton) entry;
505  }
507 }
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 1592 of file SDL_gamecontroller.c.

References NULL.

Referenced by SDL_GameControllerGetProduct(), SDL_GameControllerGetProductVersion(), and SDL_GameControllerGetVendor().

1593 {
1594  if (!gamecontroller)
1595  return NULL;
1596 
1597  return gamecontroller->joystick;
1598 }
#define NULL
Definition: begin_code.h:164

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

References SDL_GameControllerGetJoystick(), and SDL_JoystickGetProduct.

1566 {
1567  return SDL_JoystickGetProduct(SDL_GameControllerGetJoystick(gamecontroller));
1568 }
#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 1571 of file SDL_gamecontroller.c.

References SDL_GameControllerGetJoystick(), and SDL_JoystickGetProductVersion.

1572 {
1574 }
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 466 of file SDL_gamecontroller.c.

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

467 {
470  }
471  return NULL;
472 }
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 512 of file SDL_gamecontroller.c.

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

513 {
516  }
517  return NULL;
518 }
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 1559 of file SDL_gamecontroller.c.

References SDL_GameControllerGetJoystick(), and SDL_JoystickGetVendor.

1560 {
1561  return SDL_JoystickGetVendor(SDL_GameControllerGetJoystick(gamecontroller));
1562 }
#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 1149 of file SDL_gamecontroller.c.

References NULL, and SDL_GameControllerMappingForGUID().

1150 {
1151  if (!gamecontroller) {
1152  return NULL;
1153  }
1154 
1155  return SDL_GameControllerMappingForGUID(gamecontroller->guid);
1156 }
#define NULL
Definition: begin_code.h:164
char * SDL_GameControllerMappingForGUID(SDL_JoystickGUID guid)

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

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

Referenced by SDL_GameControllerMapping().

1126 {
1127  char *pMappingString = NULL;
1129  if (mapping) {
1130  char pchGUID[33];
1131  size_t needed;
1132  SDL_JoystickGetGUIDString(guid, pchGUID, sizeof(pchGUID));
1133  /* allocate enough memory for GUID + ',' + name + ',' + mapping + \0 */
1134  needed = SDL_strlen(pchGUID) + 1 + SDL_strlen(mapping->name) + 1 + SDL_strlen(mapping->mapping) + 1;
1135  pMappingString = SDL_malloc(needed);
1136  if (!pMappingString) {
1137  SDL_OutOfMemory();
1138  return NULL;
1139  }
1140  SDL_snprintf(pMappingString, needed, "%s,%s,%s", pchGUID, mapping->name, mapping->mapping);
1141  }
1142  return pMappingString;
1143 }
#define SDL_JoystickGetGUIDString
static ControllerMapping_t * SDL_PrivateGetControllerMappingForGUID(SDL_JoystickGUID *guid)
#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 1092 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.

1093 {
1095 
1096  for (mapping = s_pSupportedControllers; mapping; mapping = mapping->next) {
1097  if (SDL_memcmp(&mapping->guid, &s_zeroGUID, sizeof(mapping->guid)) == 0) {
1098  continue;
1099  }
1100  if (mapping_index == 0) {
1101  char *pMappingString;
1102  char pchGUID[33];
1103  size_t needed;
1104 
1105  SDL_JoystickGetGUIDString(mapping->guid, pchGUID, sizeof(pchGUID));
1106  /* allocate enough memory for GUID + ',' + name + ',' + mapping + \0 */
1107  needed = SDL_strlen(pchGUID) + 1 + SDL_strlen(mapping->name) + 1 + SDL_strlen(mapping->mapping) + 1;
1108  pMappingString = SDL_malloc(needed);
1109  if (!pMappingString) {
1110  SDL_OutOfMemory();
1111  return NULL;
1112  }
1113  SDL_snprintf(pMappingString, needed, "%s,%s,%s", pchGUID, mapping->name, mapping->mapping);
1114  return pMappingString;
1115  }
1116  --mapping_index;
1117  }
1118  return NULL;
1119 }
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 1550 of file SDL_gamecontroller.c.

References NULL.

1551 {
1552  if (!gamecontroller)
1553  return NULL;
1554 
1555  return gamecontroller->name;
1556 }
#define NULL
Definition: begin_code.h:164

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

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

1263 {
1264  ControllerMapping_t *pSupportedController = SDL_PrivateGetControllerMapping(device_index);
1265  if (pSupportedController) {
1266  return pSupportedController->name;
1267  }
1268  return NULL;
1269 }
static ControllerMapping_t * SDL_PrivateGetControllerMapping(int device_index)
#define NULL
Definition: begin_code.h:164

◆ SDL_GameControllerNumMappings()

int SDL_GameControllerNumMappings ( void  )

Get the number of mappings installed

Returns
the number of mappings

Definition at line 1074 of file SDL_gamecontroller.c.

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

1075 {
1076  int num_mappings = 0;
1078 
1079  for (mapping = s_pSupportedControllers; mapping; mapping = mapping->next) {
1080  if (SDL_memcmp(&mapping->guid, &s_zeroGUID, sizeof(mapping->guid)) == 0) {
1081  continue;
1082  }
1083  ++num_mappings;
1084  }
1085  return num_mappings;
1086 }
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 1357 of file SDL_gamecontroller.c.

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

1358 {
1359  SDL_GameController *gamecontroller;
1360  SDL_GameController *gamecontrollerlist;
1361  ControllerMapping_t *pSupportedController = NULL;
1362 
1364 
1365  if ((device_index < 0) || (device_index >= SDL_NumJoysticks())) {
1366  SDL_SetError("There are %d joysticks available", SDL_NumJoysticks());
1368  return (NULL);
1369  }
1370 
1371  gamecontrollerlist = SDL_gamecontrollers;
1372  /* If the controller is already open, return it */
1373  while (gamecontrollerlist) {
1374  if (SDL_SYS_GetInstanceIdOfDeviceIndex(device_index) == gamecontrollerlist->joystick->instance_id) {
1375  gamecontroller = gamecontrollerlist;
1376  ++gamecontroller->ref_count;
1378  return (gamecontroller);
1379  }
1380  gamecontrollerlist = gamecontrollerlist->next;
1381  }
1382 
1383  /* Find a controller mapping */
1384  pSupportedController = SDL_PrivateGetControllerMapping(device_index);
1385  if (!pSupportedController) {
1386  SDL_SetError("Couldn't find mapping for device (%d)", device_index);
1388  return NULL;
1389  }
1390 
1391  /* Create and initialize the controller */
1392  gamecontroller = (SDL_GameController *) SDL_calloc(1, sizeof(*gamecontroller));
1393  if (gamecontroller == NULL) {
1394  SDL_OutOfMemory();
1396  return NULL;
1397  }
1398 
1399  gamecontroller->joystick = SDL_JoystickOpen(device_index);
1400  if (!gamecontroller->joystick) {
1401  SDL_free(gamecontroller);
1403  return NULL;
1404  }
1405 
1406  if (gamecontroller->joystick->naxes) {
1407  gamecontroller->last_match_axis = (SDL_ExtendedGameControllerBind **)SDL_calloc(gamecontroller->joystick->naxes, sizeof(*gamecontroller->last_match_axis));
1408  if (!gamecontroller->last_match_axis) {
1409  SDL_OutOfMemory();
1410  SDL_JoystickClose(gamecontroller->joystick);
1411  SDL_free(gamecontroller);
1413  return NULL;
1414  }
1415  }
1416  if (gamecontroller->joystick->nhats) {
1417  gamecontroller->last_hat_mask = (Uint8 *)SDL_calloc(gamecontroller->joystick->nhats, sizeof(*gamecontroller->last_hat_mask));
1418  if (!gamecontroller->last_hat_mask) {
1419  SDL_OutOfMemory();
1420  SDL_JoystickClose(gamecontroller->joystick);
1421  SDL_free(gamecontroller->last_match_axis);
1422  SDL_free(gamecontroller);
1424  return NULL;
1425  }
1426  }
1427 
1428  SDL_PrivateLoadButtonMapping(gamecontroller, pSupportedController->guid, pSupportedController->name, pSupportedController->mapping);
1429 
1430  /* Add the controller to list */
1431  ++gamecontroller->ref_count;
1432  /* Link the controller in the list */
1433  gamecontroller->next = SDL_gamecontrollers;
1434  SDL_gamecontrollers = gamecontroller;
1435 
1437 
1438  return (gamecontroller);
1439 }
#define SDL_UnlockJoysticks
#define SDL_JoystickClose
#define SDL_JoystickOpen
#define SDL_NumJoysticks
SDL_JoystickGUID guid
static SDL_GameController * SDL_gamecontrollers
uint8_t Uint8
Definition: SDL_stdinc.h:157
#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
SDL_JoystickID SDL_SYS_GetInstanceIdOfDeviceIndex(int device_index)
static void SDL_PrivateLoadButtonMapping(SDL_GameController *gamecontroller, SDL_JoystickGUID guid, const char *pchName, const char *pchMapping)
#define SDL_LockJoysticks

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

References SDL_JoystickUpdate.

1446 {
1447  /* Just for API completeness; the joystick API does all the work. */
1449 }
#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 1289 of file SDL_gamecontroller.c.

References SDL_FALSE, SDL_PrivateGetControllerMapping(), and SDL_TRUE.

Referenced by SDL_GameControllerEventWatcher(), and SDL_GameControllerInit().

1290 {
1291  ControllerMapping_t *pSupportedController = SDL_PrivateGetControllerMapping(device_index);
1292  if (pSupportedController) {
1293  return SDL_TRUE;
1294  }
1295  return SDL_FALSE;
1296 }
static ControllerMapping_t * SDL_PrivateGetControllerMapping(int device_index)