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().

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

References SDL_CONTROLLER_MAPPING_PRIORITY_API, and SDL_PrivateGameControllerAddMapping().

Referenced by SDL_GameControllerAddMappingsFromRW().

1039 {
1041 }
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 919 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.

920 {
921  const char *platform = SDL_GetPlatform();
922  int controllers = 0;
923  char *buf, *line, *line_end, *tmp, *comma, line_platform[64];
924  size_t db_size, platform_len;
925 
926  if (rw == NULL) {
927  return SDL_SetError("Invalid RWops");
928  }
929  db_size = (size_t)SDL_RWsize(rw);
930 
931  buf = (char *)SDL_malloc(db_size + 1);
932  if (buf == NULL) {
933  if (freerw) {
934  SDL_RWclose(rw);
935  }
936  return SDL_SetError("Could not allocate space to read DB into memory");
937  }
938 
939  if (SDL_RWread(rw, buf, db_size, 1) != 1) {
940  if (freerw) {
941  SDL_RWclose(rw);
942  }
943  SDL_free(buf);
944  return SDL_SetError("Could not read DB");
945  }
946 
947  if (freerw) {
948  SDL_RWclose(rw);
949  }
950 
951  buf[db_size] = '\0';
952  line = buf;
953 
954  while (line < buf + db_size) {
955  line_end = SDL_strchr(line, '\n');
956  if (line_end != NULL) {
957  *line_end = '\0';
958  } else {
959  line_end = buf + db_size;
960  }
961 
962  /* Extract and verify the platform */
964  if (tmp != NULL) {
966  comma = SDL_strchr(tmp, ',');
967  if (comma != NULL) {
968  platform_len = comma - tmp + 1;
969  if (platform_len + 1 < SDL_arraysize(line_platform)) {
970  SDL_strlcpy(line_platform, tmp, platform_len);
971  if (SDL_strncasecmp(line_platform, platform, platform_len) == 0 &&
972  SDL_GameControllerAddMapping(line) > 0) {
973  controllers++;
974  }
975  }
976  }
977  }
978 
979  line = line_end + 1;
980  }
981 
982  SDL_free(buf);
983  return controllers;
984 }
#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
int SDL_GameControllerAddMapping(const char *mappingString)
void SDL_free(void *mem)
#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 1637 of file SDL_gamecontroller.c.

References NULL, SDL_free(), SDL_gamecontrollers, SDL_JoystickClose, SDL_LockJoystickList(), and SDL_UnlockJoystickList().

Referenced by SDL_GameControllerQuit().

1638 {
1639  SDL_GameController *gamecontrollerlist, *gamecontrollerlistprev;
1640 
1641  if (!gamecontroller)
1642  return;
1643 
1645 
1646  /* First decrement ref count */
1647  if (--gamecontroller->ref_count > 0) {
1649  return;
1650  }
1651 
1652  SDL_JoystickClose(gamecontroller->joystick);
1653 
1654  gamecontrollerlist = SDL_gamecontrollers;
1655  gamecontrollerlistprev = NULL;
1656  while (gamecontrollerlist) {
1657  if (gamecontroller == gamecontrollerlist) {
1658  if (gamecontrollerlistprev) {
1659  /* unlink this entry */
1660  gamecontrollerlistprev->next = gamecontrollerlist->next;
1661  } else {
1662  SDL_gamecontrollers = gamecontroller->next;
1663  }
1664  break;
1665  }
1666  gamecontrollerlistprev = gamecontrollerlist;
1667  gamecontrollerlist = gamecontrollerlist->next;
1668  }
1669 
1670  SDL_free(gamecontroller->bindings);
1671  SDL_free(gamecontroller->last_match_axis);
1672  SDL_free(gamecontroller->last_hat_mask);
1673  SDL_free(gamecontroller);
1674 
1676 }
void SDL_UnlockJoystickList(void)
Definition: SDL_joystick.c:51
#define SDL_JoystickClose
void SDL_LockJoystickList(void)
Definition: SDL_joystick.c:43
static SDL_GameController * SDL_gamecontrollers
void SDL_free(void *mem)
#define NULL
Definition: begin_code.h:164

◆ 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 1790 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.

1791 {
1792 #if SDL_EVENTS_DISABLED
1793  return SDL_IGNORE;
1794 #else
1795  const Uint32 event_list[] = {
1798  };
1799  unsigned int i;
1800 
1801  switch (state) {
1802  case SDL_QUERY:
1803  state = SDL_IGNORE;
1804  for (i = 0; i < SDL_arraysize(event_list); ++i) {
1805  state = SDL_EventState(event_list[i], SDL_QUERY);
1806  if (state == SDL_ENABLE) {
1807  break;
1808  }
1809  }
1810  break;
1811  default:
1812  for (i = 0; i < SDL_arraysize(event_list); ++i) {
1813  SDL_EventState(event_list[i], state);
1814  }
1815  break;
1816  }
1817  return (state);
1818 #endif /* SDL_EVENTS_DISABLED */
1819 }
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 1555 of file SDL_gamecontroller.c.

References NULL, SDL_gamecontrollers, SDL_LockJoystickList(), and SDL_UnlockJoystickList().

1556 {
1557  SDL_GameController *gamecontroller;
1558 
1560  gamecontroller = SDL_gamecontrollers;
1561  while (gamecontroller) {
1562  if (gamecontroller->joystick->instance_id == joyid) {
1564  return gamecontroller;
1565  }
1566  gamecontroller = gamecontroller->next;
1567  }
1569  return NULL;
1570 }
void SDL_UnlockJoystickList(void)
Definition: SDL_joystick.c:51
void SDL_LockJoystickList(void)
Definition: SDL_joystick.c:43
static SDL_GameController * SDL_gamecontrollers
#define NULL
Definition: begin_code.h:164

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

References SDL_FALSE, and SDL_JoystickGetAttached.

1532 {
1533  if (!gamecontroller)
1534  return SDL_FALSE;
1535 
1536  return SDL_JoystickGetAttached(gamecontroller->joystick);
1537 }
#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 1405 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.

1406 {
1407  int i;
1408 
1409  if (!gamecontroller)
1410  return 0;
1411 
1412  for (i = 0; i < gamecontroller->num_bindings; ++i) {
1413  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1414  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_AXIS && binding->output.axis.axis == axis) {
1415  int value = 0;
1416  SDL_bool valid_input_range;
1417  SDL_bool valid_output_range;
1418 
1419  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1420  value = SDL_JoystickGetAxis(gamecontroller->joystick, binding->input.axis.axis);
1421  if (binding->input.axis.axis_min < binding->input.axis.axis_max) {
1422  valid_input_range = (value >= binding->input.axis.axis_min && value <= binding->input.axis.axis_max);
1423  } else {
1424  valid_input_range = (value >= binding->input.axis.axis_max && value <= binding->input.axis.axis_min);
1425  }
1426  if (valid_input_range) {
1427  if (binding->input.axis.axis_min != binding->output.axis.axis_min || binding->input.axis.axis_max != binding->output.axis.axis_max) {
1428  float normalized_value = (float)(value - binding->input.axis.axis_min) / (binding->input.axis.axis_max - binding->input.axis.axis_min);
1429  value = binding->output.axis.axis_min + (int)(normalized_value * (binding->output.axis.axis_max - binding->output.axis.axis_min));
1430  }
1431  }
1432  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1433  value = SDL_JoystickGetButton(gamecontroller->joystick, binding->input.button);
1434  if (value == SDL_PRESSED) {
1435  value = binding->output.axis.axis_max;
1436  }
1437  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1438  int hat_mask = SDL_JoystickGetHat(gamecontroller->joystick, binding->input.hat.hat);
1439  if (hat_mask & binding->input.hat.hat_mask) {
1440  value = binding->output.axis.axis_max;
1441  }
1442  }
1443 
1444  if (binding->output.axis.axis_min < binding->output.axis.axis_max) {
1445  valid_output_range = (value >= binding->output.axis.axis_min && value <= binding->output.axis.axis_max);
1446  } else {
1447  valid_output_range = (value >= binding->output.axis.axis_max && value <= binding->output.axis.axis_min);
1448  }
1449  /* If the value is zero, there might be another binding that makes it non-zero */
1450  if (value != 0 && valid_output_range) {
1451  return (Sint16)value;
1452  }
1453  }
1454  }
1455  return 0;
1456 }
union SDL_ExtendedGameControllerBind::@22 input
#define SDL_JoystickGetButton
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:139
#define SDL_JoystickGetAxis
#define SDL_PRESSED
Definition: SDL_events.h:50
union SDL_ExtendedGameControllerBind::@23 output
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 439 of file SDL_gamecontroller.c.

References map_StringForControllerAxis, SDL_CONTROLLER_AXIS_INVALID, and SDL_strcasecmp.

Referenced by SDL_PrivateGameControllerParseElement().

440 {
441  int entry;
442 
443  if (pchString && (*pchString == '+' || *pchString == '-')) {
444  ++pchString;
445  }
446 
447  if (!pchString || !pchString[0]) {
449  }
450 
451  for (entry = 0; map_StringForControllerAxis[entry]; ++entry) {
452  if (!SDL_strcasecmp(pchString, map_StringForControllerAxis[entry]))
453  return (SDL_GameControllerAxis) entry;
454  }
456 }
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 1576 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.

1577 {
1578  int i;
1580  SDL_zero(bind);
1581 
1582  if (!gamecontroller || axis == SDL_CONTROLLER_AXIS_INVALID)
1583  return bind;
1584 
1585  for (i = 0; i < gamecontroller->num_bindings; ++i) {
1586  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1587  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_AXIS && binding->output.axis.axis == axis) {
1588  bind.bindType = binding->inputType;
1589  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1590  /* FIXME: There might be multiple axes bound now that we have axis ranges... */
1591  bind.value.axis = binding->input.axis.axis;
1592  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1593  bind.value.button = binding->input.button;
1594  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1595  bind.value.hat.hat = binding->input.hat.hat;
1596  bind.value.hat.hat_mask = binding->input.hat.hat_mask;
1597  }
1598  break;
1599  }
1600  }
1601  return bind;
1602 }
union SDL_ExtendedGameControllerBind::@22 input
SDL_GameControllerBindType inputType
SDL_Texture * axis
SDL_GameControllerBindType bindType
SDL_GameControllerBindType outputType
#define SDL_zero(x)
Definition: SDL_stdinc.h:385
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
union SDL_ExtendedGameControllerBind::@23 output

◆ 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 1608 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.

1609 {
1610  int i;
1612  SDL_zero(bind);
1613 
1614  if (!gamecontroller || button == SDL_CONTROLLER_BUTTON_INVALID)
1615  return bind;
1616 
1617  for (i = 0; i < gamecontroller->num_bindings; ++i) {
1618  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1619  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_BUTTON && binding->output.button == button) {
1620  bind.bindType = binding->inputType;
1621  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1622  bind.value.axis = binding->input.axis.axis;
1623  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1624  bind.value.button = binding->input.button;
1625  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1626  bind.value.hat.hat = binding->input.hat.hat;
1627  bind.value.hat.hat_mask = binding->input.hat.hat_mask;
1628  }
1629  break;
1630  }
1631  }
1632  return bind;
1633 }
union SDL_ExtendedGameControllerBind::@22 input
SDL_Texture * button
SDL_GameControllerBindType inputType
SDL_GameControllerBindType bindType
SDL_GameControllerBindType outputType
#define SDL_zero(x)
Definition: SDL_stdinc.h:385
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
union SDL_ExtendedGameControllerBind::@23 output

◆ 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 1462 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.

1463 {
1464  int i;
1465 
1466  if (!gamecontroller)
1467  return 0;
1468 
1469  for (i = 0; i < gamecontroller->num_bindings; ++i) {
1470  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1471  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_BUTTON && binding->output.button == button) {
1472  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1473  SDL_bool valid_input_range;
1474 
1475  int value = SDL_JoystickGetAxis(gamecontroller->joystick, binding->input.axis.axis);
1476  int threshold = binding->input.axis.axis_min + (binding->input.axis.axis_max - binding->input.axis.axis_min) / 2;
1477  if (binding->input.axis.axis_min < binding->input.axis.axis_max) {
1478  valid_input_range = (value >= binding->input.axis.axis_min && value <= binding->input.axis.axis_max);
1479  if (valid_input_range) {
1480  return (value >= threshold) ? SDL_PRESSED : SDL_RELEASED;
1481  }
1482  } else {
1483  valid_input_range = (value >= binding->input.axis.axis_max && value <= binding->input.axis.axis_min);
1484  if (valid_input_range) {
1485  return (value <= threshold) ? SDL_PRESSED : SDL_RELEASED;
1486  }
1487  }
1488  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1489  return SDL_JoystickGetButton(gamecontroller->joystick, binding->input.button);
1490  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1491  int hat_mask = SDL_JoystickGetHat(gamecontroller->joystick, binding->input.hat.hat);
1492  return (hat_mask & binding->input.hat.hat_mask) ? SDL_PRESSED : SDL_RELEASED;
1493  }
1494  }
1495  }
1496  return SDL_RELEASED;
1497 }
union SDL_ExtendedGameControllerBind::@22 input
#define SDL_JoystickGetButton
SDL_Texture * button
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:139
#define SDL_JoystickGetAxis
#define SDL_PRESSED
Definition: SDL_events.h:50
union SDL_ExtendedGameControllerBind::@23 output
#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 491 of file SDL_gamecontroller.c.

References map_StringForControllerButton, SDL_CONTROLLER_BUTTON_INVALID, and SDL_strcasecmp.

Referenced by SDL_PrivateGameControllerParseElement().

492 {
493  int entry;
494  if (!pchString || !pchString[0])
496 
497  for (entry = 0; map_StringForControllerButton[entry]; ++entry) {
498  if (SDL_strcasecmp(pchString, map_StringForControllerButton[entry]) == 0)
499  return (SDL_GameControllerButton) entry;
500  }
502 }
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 1542 of file SDL_gamecontroller.c.

References NULL.

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

1543 {
1544  if (!gamecontroller)
1545  return NULL;
1546 
1547  return gamecontroller->joystick;
1548 }
#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 1515 of file SDL_gamecontroller.c.

References SDL_GameControllerGetJoystick(), and SDL_JoystickGetProduct.

1516 {
1517  return SDL_JoystickGetProduct(SDL_GameControllerGetJoystick(gamecontroller));
1518 }
#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 1521 of file SDL_gamecontroller.c.

References SDL_GameControllerGetJoystick(), and SDL_JoystickGetProductVersion.

1522 {
1524 }
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 461 of file SDL_gamecontroller.c.

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

462 {
465  }
466  return NULL;
467 }
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 507 of file SDL_gamecontroller.c.

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

508 {
511  }
512  return NULL;
513 }
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 1509 of file SDL_gamecontroller.c.

References SDL_GameControllerGetJoystick(), and SDL_JoystickGetVendor.

1510 {
1511  return SDL_JoystickGetVendor(SDL_GameControllerGetJoystick(gamecontroller));
1512 }
#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 1122 of file SDL_gamecontroller.c.

References NULL, and SDL_GameControllerMappingForGUID().

1123 {
1124  if (!gamecontroller) {
1125  return NULL;
1126  }
1127 
1128  return SDL_GameControllerMappingForGUID(gamecontroller->guid);
1129 }
#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 1098 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().

1099 {
1100  char *pMappingString = NULL;
1102  if (mapping) {
1103  char pchGUID[33];
1104  size_t needed;
1105  SDL_JoystickGetGUIDString(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  }
1115  return pMappingString;
1116 }
#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 1065 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.

1066 {
1068 
1069  for (mapping = s_pSupportedControllers; mapping; mapping = mapping->next) {
1070  if (SDL_memcmp(&mapping->guid, &s_zeroGUID, sizeof(mapping->guid)) == 0) {
1071  continue;
1072  }
1073  if (mapping_index == 0) {
1074  char *pMappingString;
1075  char pchGUID[33];
1076  size_t needed;
1077 
1078  SDL_JoystickGetGUIDString(mapping->guid, pchGUID, sizeof(pchGUID));
1079  /* allocate enough memory for GUID + ',' + name + ',' + mapping + \0 */
1080  needed = SDL_strlen(pchGUID) + 1 + SDL_strlen(mapping->name) + 1 + SDL_strlen(mapping->mapping) + 1;
1081  pMappingString = SDL_malloc(needed);
1082  if (!pMappingString) {
1083  SDL_OutOfMemory();
1084  return NULL;
1085  }
1086  SDL_snprintf(pMappingString, needed, "%s,%s,%s", pchGUID, mapping->name, mapping->mapping);
1087  return pMappingString;
1088  }
1089  --mapping_index;
1090  }
1091  return NULL;
1092 }
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 1500 of file SDL_gamecontroller.c.

References NULL.

1501 {
1502  if (!gamecontroller)
1503  return NULL;
1504 
1505  return gamecontroller->name;
1506 }
#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 1213 of file SDL_gamecontroller.c.

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

1214 {
1215  ControllerMapping_t *pSupportedController = SDL_PrivateGetControllerMapping(device_index);
1216  if (pSupportedController) {
1217  return pSupportedController->name;
1218  }
1219  return NULL;
1220 }
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 1047 of file SDL_gamecontroller.c.

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

1048 {
1049  int num_mappings = 0;
1051 
1052  for (mapping = s_pSupportedControllers; mapping; mapping = mapping->next) {
1053  if (SDL_memcmp(&mapping->guid, &s_zeroGUID, sizeof(mapping->guid)) == 0) {
1054  continue;
1055  }
1056  ++num_mappings;
1057  }
1058  return num_mappings;
1059 }
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 1308 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_LockJoystickList(), SDL_NumJoysticks, SDL_OutOfMemory, SDL_PrivateGetControllerMapping(), SDL_PrivateLoadButtonMapping(), SDL_SetError, SDL_SYS_GetInstanceIdOfDeviceIndex(), and SDL_UnlockJoystickList().

1309 {
1310  SDL_GameController *gamecontroller;
1311  SDL_GameController *gamecontrollerlist;
1312  ControllerMapping_t *pSupportedController = NULL;
1313 
1314  if ((device_index < 0) || (device_index >= SDL_NumJoysticks())) {
1315  SDL_SetError("There are %d joysticks available", SDL_NumJoysticks());
1316  return (NULL);
1317  }
1318 
1320 
1321  gamecontrollerlist = SDL_gamecontrollers;
1322  /* If the controller is already open, return it */
1323  while (gamecontrollerlist) {
1324  if (SDL_SYS_GetInstanceIdOfDeviceIndex(device_index) == gamecontrollerlist->joystick->instance_id) {
1325  gamecontroller = gamecontrollerlist;
1326  ++gamecontroller->ref_count;
1328  return (gamecontroller);
1329  }
1330  gamecontrollerlist = gamecontrollerlist->next;
1331  }
1332 
1333  /* Find a controller mapping */
1334  pSupportedController = SDL_PrivateGetControllerMapping(device_index);
1335  if (!pSupportedController) {
1336  SDL_SetError("Couldn't find mapping for device (%d)", device_index);
1338  return NULL;
1339  }
1340 
1341  /* Create and initialize the controller */
1342  gamecontroller = (SDL_GameController *) SDL_calloc(1, sizeof(*gamecontroller));
1343  if (gamecontroller == NULL) {
1344  SDL_OutOfMemory();
1346  return NULL;
1347  }
1348 
1349  gamecontroller->joystick = SDL_JoystickOpen(device_index);
1350  if (!gamecontroller->joystick) {
1351  SDL_free(gamecontroller);
1353  return NULL;
1354  }
1355 
1356  if (gamecontroller->joystick->naxes) {
1357  gamecontroller->last_match_axis = (SDL_ExtendedGameControllerBind **)SDL_calloc(gamecontroller->joystick->naxes, sizeof(*gamecontroller->last_match_axis));
1358  if (!gamecontroller->last_match_axis) {
1359  SDL_OutOfMemory();
1360  SDL_JoystickClose(gamecontroller->joystick);
1361  SDL_free(gamecontroller);
1363  return NULL;
1364  }
1365  }
1366  if (gamecontroller->joystick->nhats) {
1367  gamecontroller->last_hat_mask = (Uint8 *)SDL_calloc(gamecontroller->joystick->nhats, sizeof(*gamecontroller->last_hat_mask));
1368  if (!gamecontroller->last_hat_mask) {
1369  SDL_OutOfMemory();
1370  SDL_JoystickClose(gamecontroller->joystick);
1371  SDL_free(gamecontroller->last_match_axis);
1372  SDL_free(gamecontroller);
1374  return NULL;
1375  }
1376  }
1377 
1378  SDL_PrivateLoadButtonMapping(gamecontroller, pSupportedController->guid, pSupportedController->name, pSupportedController->mapping);
1379 
1380  /* Add the controller to list */
1381  ++gamecontroller->ref_count;
1382  /* Link the controller in the list */
1383  gamecontroller->next = SDL_gamecontrollers;
1384  SDL_gamecontrollers = gamecontroller;
1385 
1387 
1388  return (gamecontroller);
1389 }
void SDL_UnlockJoystickList(void)
Definition: SDL_joystick.c:51
#define SDL_JoystickClose
#define SDL_JoystickOpen
#define SDL_NumJoysticks
void SDL_LockJoystickList(void)
Definition: SDL_joystick.c:43
void * SDL_calloc(size_t nmemb, size_t size)
SDL_JoystickGUID guid
static SDL_GameController * SDL_gamecontrollers
uint8_t Uint8
Definition: SDL_stdinc.h:157
void SDL_free(void *mem)
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
SDL_JoystickID SDL_SYS_GetInstanceIdOfDeviceIndex(int device_index)
static void SDL_PrivateLoadButtonMapping(SDL_GameController *gamecontroller, SDL_JoystickGUID guid, const char *pchName, const char *pchMapping)

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

References SDL_JoystickUpdate.

1396 {
1397  /* Just for API completeness; the joystick API does all the work. */
1399 }
#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 1240 of file SDL_gamecontroller.c.

References SDL_FALSE, SDL_PrivateGetControllerMapping(), and SDL_TRUE.

Referenced by SDL_GameControllerEventWatcher(), and SDL_GameControllerInit().

1241 {
1242  ControllerMapping_t *pSupportedController = SDL_PrivateGetControllerMapping(device_index);
1243  if (pSupportedController) {
1244  return SDL_TRUE;
1245  }
1246  return SDL_FALSE;
1247 }
static ControllerMapping_t * SDL_PrivateGetControllerMapping(int device_index)