SDL  2.0
SDL_gamecontroller.c File Reference
#include "../SDL_internal.h"
#include "SDL_events.h"
#include "SDL_assert.h"
#include "SDL_hints.h"
#include "SDL_sysjoystick.h"
#include "SDL_joystick_c.h"
#include "SDL_gamecontrollerdb.h"
#include "../events/SDL_events_c.h"
+ Include dependency graph for SDL_gamecontroller.c:

Go to the source code of this file.

Data Structures

struct  SDL_ExtendedGameControllerBind
 
struct  ControllerMapping_t
 
struct  SDL_GameController
 
struct  SDL_vidpid_list
 

Macros

#define SDL_CONTROLLER_PLATFORM_FIELD   "platform:"
 

Enumerations

enum  SDL_ControllerMappingPriority {
  SDL_CONTROLLER_MAPPING_PRIORITY_DEFAULT,
  SDL_CONTROLLER_MAPPING_PRIORITY_API,
  SDL_CONTROLLER_MAPPING_PRIORITY_USER
}
 

Functions

static void SDL_LoadVIDPIDListFromHint (const char *hint, SDL_vidpid_list *list)
 
static void SDL_GameControllerIgnoreDevicesChanged (void *userdata, const char *name, const char *oldValue, const char *hint)
 
static void SDL_GameControllerIgnoreDevicesExceptChanged (void *userdata, const char *name, const char *oldValue, const char *hint)
 
static int SDL_PrivateGameControllerAxis (SDL_GameController *gamecontroller, SDL_GameControllerAxis axis, Sint16 value)
 
static int SDL_PrivateGameControllerButton (SDL_GameController *gamecontroller, SDL_GameControllerButton button, Uint8 state)
 
static void UpdateEventsForDeviceRemoval ()
 
static SDL_bool HasSameOutput (SDL_ExtendedGameControllerBind *a, SDL_ExtendedGameControllerBind *b)
 
static void ResetOutput (SDL_GameController *gamecontroller, SDL_ExtendedGameControllerBind *bind)
 
static void HandleJoystickAxis (SDL_GameController *gamecontroller, int axis, int value)
 
static void HandleJoystickButton (SDL_GameController *gamecontroller, int button, Uint8 state)
 
static void HandleJoystickHat (SDL_GameController *gamecontroller, int hat, Uint8 value)
 
static int SDL_GameControllerEventWatcher (void *userdata, SDL_Event *event)
 
static ControllerMapping_tSDL_PrivateGetControllerMappingForGUID (SDL_JoystickGUID *guid)
 
SDL_GameControllerAxis SDL_GameControllerGetAxisFromString (const char *pchString)
 
const char * SDL_GameControllerGetStringForAxis (SDL_GameControllerAxis axis)
 
SDL_GameControllerButton SDL_GameControllerGetButtonFromString (const char *pchString)
 
const char * SDL_GameControllerGetStringForButton (SDL_GameControllerButton axis)
 
static void SDL_PrivateGameControllerParseElement (SDL_GameController *gamecontroller, const char *szGameButton, const char *szJoystickButton)
 
static void SDL_PrivateGameControllerParseControllerConfigString (SDL_GameController *gamecontroller, const char *pchString)
 
static void SDL_PrivateLoadButtonMapping (SDL_GameController *gamecontroller, SDL_JoystickGUID guid, const char *pchName, const char *pchMapping)
 
static char * SDL_PrivateGetControllerGUIDFromMappingString (const char *pMapping)
 
static char * SDL_PrivateGetControllerNameFromMappingString (const char *pMapping)
 
static char * SDL_PrivateGetControllerMappingFromMappingString (const char *pMapping)
 
static void SDL_PrivateGameControllerRefreshMapping (ControllerMapping_t *pControllerMapping)
 
static ControllerMapping_tSDL_PrivateAddMappingForGUID (SDL_JoystickGUID jGUID, const char *mappingString, SDL_bool *existing, SDL_ControllerMappingPriority priority)
 
static ControllerMapping_tSDL_PrivateGetControllerMappingForNameAndGUID (const char *name, SDL_JoystickGUID guid)
 
static ControllerMapping_tSDL_PrivateGetControllerMapping (int device_index)
 
int SDL_GameControllerAddMappingsFromRW (SDL_RWops *rw, int freerw)
 
static int SDL_PrivateGameControllerAddMapping (const char *mappingString, SDL_ControllerMappingPriority priority)
 
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)
 
static void SDL_GameControllerLoadHints ()
 
static SDL_bool SDL_GetControllerMappingFilePath (char *path, size_t size)
 
int SDL_GameControllerInitMappings (void)
 
int SDL_GameControllerInit (void)
 
const char * SDL_GameControllerNameForIndex (int device_index)
 
SDL_bool SDL_IsGameControllerNameAndGUID (const char *name, SDL_JoystickGUID guid)
 
SDL_bool SDL_IsGameController (int device_index)
 
SDL_bool SDL_ShouldIgnoreGameController (const char *name, SDL_JoystickGUID guid)
 
SDL_GameController * SDL_GameControllerOpen (int device_index)
 
void SDL_GameControllerUpdate (void)
 
Sint16 SDL_GameControllerGetAxis (SDL_GameController *gamecontroller, SDL_GameControllerAxis axis)
 
Uint8 SDL_GameControllerGetButton (SDL_GameController *gamecontroller, SDL_GameControllerButton button)
 
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)
 
SDL_GameController * SDL_GameControllerFromInstanceID (SDL_JoystickID joyid)
 
SDL_GameControllerButtonBind SDL_GameControllerGetBindForAxis (SDL_GameController *gamecontroller, SDL_GameControllerAxis axis)
 
SDL_GameControllerButtonBind SDL_GameControllerGetBindForButton (SDL_GameController *gamecontroller, SDL_GameControllerButton button)
 
void SDL_GameControllerClose (SDL_GameController *gamecontroller)
 
void SDL_GameControllerQuit (void)
 
void SDL_GameControllerQuitMappings (void)
 
int SDL_GameControllerEventState (int state)
 

Variables

static SDL_GameController * SDL_gamecontrollers = NULL
 
static SDL_JoystickGUID s_zeroGUID
 
static ControllerMapping_ts_pSupportedControllers = NULL
 
static ControllerMapping_ts_pXInputMapping = NULL
 
static ControllerMapping_ts_pEmscriptenMapping = NULL
 
static SDL_vidpid_list SDL_allowed_controllers
 
static SDL_vidpid_list SDL_ignored_controllers
 
static const char * map_StringForControllerAxis []
 
static const char * map_StringForControllerButton []
 

Macro Definition Documentation

◆ SDL_CONTROLLER_PLATFORM_FIELD

#define SDL_CONTROLLER_PLATFORM_FIELD   "platform:"

Definition at line 41 of file SDL_gamecontroller.c.

Referenced by SDL_GameControllerAddMappingsFromRW().

Enumeration Type Documentation

◆ SDL_ControllerMappingPriority

Enumerator
SDL_CONTROLLER_MAPPING_PRIORITY_DEFAULT 
SDL_CONTROLLER_MAPPING_PRIORITY_API 
SDL_CONTROLLER_MAPPING_PRIORITY_USER 

Definition at line 82 of file SDL_gamecontroller.c.

Function Documentation

◆ HandleJoystickAxis()

static void HandleJoystickAxis ( SDL_GameController *  gamecontroller,
int  axis,
int  value 
)
static

Definition at line 242 of file SDL_gamecontroller.c.

References SDL_ExtendedGameControllerBind::axis, axis, SDL_ExtendedGameControllerBind::button, HasSameOutput(), i, SDL_ExtendedGameControllerBind::input, SDL_ExtendedGameControllerBind::inputType, NULL, SDL_ExtendedGameControllerBind::output, SDL_ExtendedGameControllerBind::outputType, ResetOutput(), SDL_CONTROLLER_BINDTYPE_AXIS, SDL_PRESSED, SDL_PrivateGameControllerAxis(), SDL_PrivateGameControllerButton(), SDL_RELEASED, and state.

Referenced by SDL_GameControllerEventWatcher().

243 {
244  int i;
245  SDL_ExtendedGameControllerBind *last_match = gamecontroller->last_match_axis[axis];
247 
248  for (i = 0; i < gamecontroller->num_bindings; ++i) {
249  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
250  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS &&
251  axis == binding->input.axis.axis) {
252  if (binding->input.axis.axis_min < binding->input.axis.axis_max) {
253  if (value >= binding->input.axis.axis_min &&
254  value <= binding->input.axis.axis_max) {
255  match = binding;
256  break;
257  }
258  } else {
259  if (value >= binding->input.axis.axis_max &&
260  value <= binding->input.axis.axis_min) {
261  match = binding;
262  break;
263  }
264  }
265  }
266  }
267 
268  if (last_match && (!match || !HasSameOutput(last_match, match))) {
269  /* Clear the last input that this axis generated */
270  ResetOutput(gamecontroller, last_match);
271  }
272 
273  if (match) {
275  if (match->input.axis.axis_min != match->output.axis.axis_min || match->input.axis.axis_max != match->output.axis.axis_max) {
276  float normalized_value = (float)(value - match->input.axis.axis_min) / (match->input.axis.axis_max - match->input.axis.axis_min);
277  value = match->output.axis.axis_min + (int)(normalized_value * (match->output.axis.axis_max - match->output.axis.axis_min));
278  }
279  SDL_PrivateGameControllerAxis(gamecontroller, match->output.axis.axis, (Sint16)value);
280  } else {
281  Uint8 state;
282  int threshold = match->input.axis.axis_min + (match->input.axis.axis_max - match->input.axis.axis_min) / 2;
283  if (match->input.axis.axis_max < match->input.axis.axis_min) {
284  state = (value <= threshold) ? SDL_PRESSED : SDL_RELEASED;
285  } else {
286  state = (value >= threshold) ? SDL_PRESSED : SDL_RELEASED;
287  }
288  SDL_PrivateGameControllerButton(gamecontroller, match->output.button, state);
289  }
290  }
291  gamecontroller->last_match_axis[axis] = match;
292 }
union SDL_ExtendedGameControllerBind::@22 input
static void ResetOutput(SDL_GameController *gamecontroller, SDL_ExtendedGameControllerBind *bind)
struct xkb_state * state
SDL_GameControllerBindType inputType
SDL_Texture * axis
GLenum GLenum GLenum input
uint8_t Uint8
Definition: SDL_stdinc.h:157
SDL_GameControllerBindType outputType
static SDL_bool HasSameOutput(SDL_ExtendedGameControllerBind *a, SDL_ExtendedGameControllerBind *b)
GLsizei const GLfloat * value
static int SDL_PrivateGameControllerButton(SDL_GameController *gamecontroller, SDL_GameControllerButton button, Uint8 state)
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
#define NULL
Definition: begin_code.h:164
#define SDL_PRESSED
Definition: SDL_events.h:50
union SDL_ExtendedGameControllerBind::@23 output
#define SDL_RELEASED
Definition: SDL_events.h:49
static int SDL_PrivateGameControllerAxis(SDL_GameController *gamecontroller, SDL_GameControllerAxis axis, Sint16 value)
int16_t Sint16
Definition: SDL_stdinc.h:163

◆ HandleJoystickButton()

static void HandleJoystickButton ( SDL_GameController *  gamecontroller,
int  button,
Uint8  state 
)
static

Definition at line 294 of file SDL_gamecontroller.c.

References SDL_ExtendedGameControllerBind::axis, SDL_ExtendedGameControllerBind::button, i, SDL_ExtendedGameControllerBind::input, SDL_ExtendedGameControllerBind::inputType, SDL_ExtendedGameControllerBind::output, SDL_ExtendedGameControllerBind::outputType, SDL_CONTROLLER_BINDTYPE_AXIS, SDL_CONTROLLER_BINDTYPE_BUTTON, SDL_PrivateGameControllerAxis(), and SDL_PrivateGameControllerButton().

Referenced by SDL_GameControllerEventWatcher().

295 {
296  int i;
297 
298  for (i = 0; i < gamecontroller->num_bindings; ++i) {
299  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
300  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON &&
301  button == binding->input.button) {
302  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
303  int value = state ? binding->output.axis.axis_max : binding->output.axis.axis_min;
304  SDL_PrivateGameControllerAxis(gamecontroller, binding->output.axis.axis, (Sint16)value);
305  } else {
306  SDL_PrivateGameControllerButton(gamecontroller, binding->output.button, state);
307  }
308  break;
309  }
310  }
311 }
union SDL_ExtendedGameControllerBind::@22 input
SDL_Texture * button
struct xkb_state * state
SDL_GameControllerBindType inputType
SDL_GameControllerBindType outputType
GLsizei const GLfloat * value
static int SDL_PrivateGameControllerButton(SDL_GameController *gamecontroller, SDL_GameControllerButton button, Uint8 state)
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
union SDL_ExtendedGameControllerBind::@23 output
static int SDL_PrivateGameControllerAxis(SDL_GameController *gamecontroller, SDL_GameControllerAxis axis, Sint16 value)
int16_t Sint16
Definition: SDL_stdinc.h:163

◆ HandleJoystickHat()

static void HandleJoystickHat ( SDL_GameController *  gamecontroller,
int  hat,
Uint8  value 
)
static

Definition at line 313 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, ResetOutput(), SDL_CONTROLLER_BINDTYPE_AXIS, SDL_CONTROLLER_BINDTYPE_HAT, SDL_PRESSED, SDL_PrivateGameControllerAxis(), and SDL_PrivateGameControllerButton().

Referenced by SDL_GameControllerEventWatcher().

314 {
315  int i;
316  Uint8 last_mask = gamecontroller->last_hat_mask[hat];
317  Uint8 changed_mask = (last_mask ^ value);
318 
319  for (i = 0; i < gamecontroller->num_bindings; ++i) {
320  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
321  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT && hat == binding->input.hat.hat) {
322  if ((changed_mask & binding->input.hat.hat_mask) != 0) {
323  if (value & binding->input.hat.hat_mask) {
324  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
325  SDL_PrivateGameControllerAxis(gamecontroller, binding->output.axis.axis, (Sint16)binding->output.axis.axis_max);
326  } else {
327  SDL_PrivateGameControllerButton(gamecontroller, binding->output.button, SDL_PRESSED);
328  }
329  } else {
330  ResetOutput(gamecontroller, binding);
331  }
332  }
333  }
334  }
335  gamecontroller->last_hat_mask[hat] = value;
336 }
union SDL_ExtendedGameControllerBind::@22 input
static void ResetOutput(SDL_GameController *gamecontroller, SDL_ExtendedGameControllerBind *bind)
SDL_GameControllerBindType inputType
uint8_t Uint8
Definition: SDL_stdinc.h:157
SDL_GameControllerBindType outputType
GLsizei const GLfloat * value
static int SDL_PrivateGameControllerButton(SDL_GameController *gamecontroller, SDL_GameControllerButton button, Uint8 state)
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
#define SDL_PRESSED
Definition: SDL_events.h:50
union SDL_ExtendedGameControllerBind::@23 output
static int SDL_PrivateGameControllerAxis(SDL_GameController *gamecontroller, SDL_GameControllerAxis axis, Sint16 value)
int16_t Sint16
Definition: SDL_stdinc.h:163

◆ HasSameOutput()

◆ ResetOutput()

static void ResetOutput ( SDL_GameController *  gamecontroller,
SDL_ExtendedGameControllerBind bind 
)
static

Definition at line 233 of file SDL_gamecontroller.c.

References SDL_ExtendedGameControllerBind::axis, SDL_ExtendedGameControllerBind::button, SDL_ExtendedGameControllerBind::output, SDL_ExtendedGameControllerBind::outputType, SDL_CONTROLLER_BINDTYPE_AXIS, SDL_PrivateGameControllerAxis(), SDL_PrivateGameControllerButton(), and SDL_RELEASED.

Referenced by HandleJoystickAxis(), and HandleJoystickHat().

234 {
236  SDL_PrivateGameControllerAxis(gamecontroller, bind->output.axis.axis, 0);
237  } else {
239  }
240 }
SDL_GameControllerBindType outputType
static int SDL_PrivateGameControllerButton(SDL_GameController *gamecontroller, SDL_GameControllerButton button, Uint8 state)
union SDL_ExtendedGameControllerBind::@23 output
#define SDL_RELEASED
Definition: SDL_events.h:49
static int SDL_PrivateGameControllerAxis(SDL_GameController *gamecontroller, SDL_GameControllerAxis axis, Sint16 value)

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

References SDL_CONTROLLER_MAPPING_PRIORITY_API, and SDL_PrivateGameControllerAddMapping().

Referenced by SDL_GameControllerAddMappingsFromRW().

1050 {
1052 }
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 930 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.

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

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

Referenced by SDL_GameControllerQuit().

1671 {
1672  SDL_GameController *gamecontrollerlist, *gamecontrollerlistprev;
1673 
1674  if (!gamecontroller)
1675  return;
1676 
1678 
1679  /* First decrement ref count */
1680  if (--gamecontroller->ref_count > 0) {
1682  return;
1683  }
1684 
1685  SDL_JoystickClose(gamecontroller->joystick);
1686 
1687  gamecontrollerlist = SDL_gamecontrollers;
1688  gamecontrollerlistprev = NULL;
1689  while (gamecontrollerlist) {
1690  if (gamecontroller == gamecontrollerlist) {
1691  if (gamecontrollerlistprev) {
1692  /* unlink this entry */
1693  gamecontrollerlistprev->next = gamecontrollerlist->next;
1694  } else {
1695  SDL_gamecontrollers = gamecontroller->next;
1696  }
1697  break;
1698  }
1699  gamecontrollerlistprev = gamecontrollerlist;
1700  gamecontrollerlist = gamecontrollerlist->next;
1701  }
1702 
1703  SDL_free(gamecontroller->bindings);
1704  SDL_free(gamecontroller->last_match_axis);
1705  SDL_free(gamecontroller->last_hat_mask);
1706  SDL_free(gamecontroller);
1707 
1709 }
#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 1823 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.

1824 {
1825 #if SDL_EVENTS_DISABLED
1826  return SDL_IGNORE;
1827 #else
1828  const Uint32 event_list[] = {
1831  };
1832  unsigned int i;
1833 
1834  switch (state) {
1835  case SDL_QUERY:
1836  state = SDL_IGNORE;
1837  for (i = 0; i < SDL_arraysize(event_list); ++i) {
1838  state = SDL_EventState(event_list[i], SDL_QUERY);
1839  if (state == SDL_ENABLE) {
1840  break;
1841  }
1842  }
1843  break;
1844  default:
1845  for (i = 0; i < SDL_arraysize(event_list); ++i) {
1846  SDL_EventState(event_list[i], state);
1847  }
1848  break;
1849  }
1850  return (state);
1851 #endif /* SDL_EVENTS_DISABLED */
1852 }
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_GameControllerEventWatcher()

static int SDL_GameControllerEventWatcher ( void userdata,
SDL_Event event 
)
static

Definition at line 341 of file SDL_gamecontroller.c.

References SDL_JoyAxisEvent::axis, SDL_JoyButtonEvent::button, SDL_Event::cdevice, HandleJoystickAxis(), HandleJoystickButton(), HandleJoystickHat(), SDL_JoyHatEvent::hat, SDL_Event::jaxis, SDL_Event::jbutton, SDL_Event::jdevice, SDL_Event::jhat, SDL_CONTROLLERDEVICEADDED, SDL_CONTROLLERDEVICEREMOVED, SDL_gamecontrollers, SDL_IsGameController(), SDL_JOYAXISMOTION, SDL_JOYBUTTONDOWN, SDL_JOYBUTTONUP, SDL_JOYDEVICEADDED, SDL_JOYDEVICEREMOVED, SDL_JOYHATMOTION, SDL_PushEvent, SDL_JoyButtonEvent::state, SDL_Event::type, UpdateEventsForDeviceRemoval(), SDL_JoyAxisEvent::value, SDL_JoyHatEvent::value, SDL_JoyAxisEvent::which, SDL_JoyHatEvent::which, SDL_JoyButtonEvent::which, SDL_JoyDeviceEvent::which, and SDL_ControllerDeviceEvent::which.

Referenced by SDL_GameControllerInit(), and SDL_GameControllerQuitMappings().

342 {
343  switch(event->type) {
344  case SDL_JOYAXISMOTION:
345  {
346  SDL_GameController *controllerlist = SDL_gamecontrollers;
347  while (controllerlist) {
348  if (controllerlist->joystick->instance_id == event->jaxis.which) {
349  HandleJoystickAxis(controllerlist, event->jaxis.axis, event->jaxis.value);
350  break;
351  }
352  controllerlist = controllerlist->next;
353  }
354  }
355  break;
356  case SDL_JOYBUTTONDOWN:
357  case SDL_JOYBUTTONUP:
358  {
359  SDL_GameController *controllerlist = SDL_gamecontrollers;
360  while (controllerlist) {
361  if (controllerlist->joystick->instance_id == event->jbutton.which) {
362  HandleJoystickButton(controllerlist, event->jbutton.button, event->jbutton.state);
363  break;
364  }
365  controllerlist = controllerlist->next;
366  }
367  }
368  break;
369  case SDL_JOYHATMOTION:
370  {
371  SDL_GameController *controllerlist = SDL_gamecontrollers;
372  while (controllerlist) {
373  if (controllerlist->joystick->instance_id == event->jhat.which) {
374  HandleJoystickHat(controllerlist, event->jhat.hat, event->jhat.value);
375  break;
376  }
377  controllerlist = controllerlist->next;
378  }
379  }
380  break;
381  case SDL_JOYDEVICEADDED:
382  {
383  if (SDL_IsGameController(event->jdevice.which)) {
384  SDL_Event deviceevent;
385  deviceevent.type = SDL_CONTROLLERDEVICEADDED;
386  deviceevent.cdevice.which = event->jdevice.which;
387  SDL_PushEvent(&deviceevent);
388  }
389  }
390  break;
392  {
393  SDL_GameController *controllerlist = SDL_gamecontrollers;
394  while (controllerlist) {
395  if (controllerlist->joystick->instance_id == event->jdevice.which) {
396  SDL_Event deviceevent;
397 
398  deviceevent.type = SDL_CONTROLLERDEVICEREMOVED;
399  deviceevent.cdevice.which = event->jdevice.which;
400  SDL_PushEvent(&deviceevent);
401 
403  break;
404  }
405  controllerlist = controllerlist->next;
406  }
407  }
408  break;
409  default:
410  break;
411  }
412 
413  return 1;
414 }
SDL_JoystickID which
Definition: SDL_events.h:335
SDL_JoyDeviceEvent jdevice
Definition: SDL_events.h:540
static void HandleJoystickHat(SDL_GameController *gamecontroller, int hat, Uint8 value)
SDL_ControllerDeviceEvent cdevice
Definition: SDL_events.h:543
SDL_JoyButtonEvent jbutton
Definition: SDL_events.h:539
static void UpdateEventsForDeviceRemoval()
SDL_JoystickID which
Definition: SDL_events.h:283
static SDL_GameController * SDL_gamecontrollers
SDL_JoyAxisEvent jaxis
Definition: SDL_events.h:536
#define SDL_PushEvent
static void HandleJoystickButton(SDL_GameController *gamecontroller, int button, Uint8 state)
SDL_bool SDL_IsGameController(int device_index)
General event structure.
Definition: SDL_events.h:525
SDL_JoyHatEvent jhat
Definition: SDL_events.h:538
SDL_JoystickID which
Definition: SDL_events.h:315
static void HandleJoystickAxis(SDL_GameController *gamecontroller, int axis, int value)
Uint32 type
Definition: SDL_events.h:527

◆ SDL_GameControllerFromInstanceID()

SDL_GameController* SDL_GameControllerFromInstanceID ( SDL_JoystickID  joyid)

Return the SDL_GameController associated with an instance id.

Definition at line 1588 of file SDL_gamecontroller.c.

References NULL, SDL_gamecontrollers, SDL_LockJoysticks, and SDL_UnlockJoysticks.

1589 {
1590  SDL_GameController *gamecontroller;
1591 
1593  gamecontroller = SDL_gamecontrollers;
1594  while (gamecontroller) {
1595  if (gamecontroller->joystick->instance_id == joyid) {
1597  return gamecontroller;
1598  }
1599  gamecontroller = gamecontroller->next;
1600  }
1602  return NULL;
1603 }
#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 1564 of file SDL_gamecontroller.c.

References SDL_FALSE, and SDL_JoystickGetAttached.

1565 {
1566  if (!gamecontroller)
1567  return SDL_FALSE;
1568 
1569  return SDL_JoystickGetAttached(gamecontroller->joystick);
1570 }
#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 1438 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.

1439 {
1440  int i;
1441 
1442  if (!gamecontroller)
1443  return 0;
1444 
1445  for (i = 0; i < gamecontroller->num_bindings; ++i) {
1446  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1447  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_AXIS && binding->output.axis.axis == axis) {
1448  int value = 0;
1449  SDL_bool valid_input_range;
1450  SDL_bool valid_output_range;
1451 
1452  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1453  value = SDL_JoystickGetAxis(gamecontroller->joystick, binding->input.axis.axis);
1454  if (binding->input.axis.axis_min < binding->input.axis.axis_max) {
1455  valid_input_range = (value >= binding->input.axis.axis_min && value <= binding->input.axis.axis_max);
1456  } else {
1457  valid_input_range = (value >= binding->input.axis.axis_max && value <= binding->input.axis.axis_min);
1458  }
1459  if (valid_input_range) {
1460  if (binding->input.axis.axis_min != binding->output.axis.axis_min || binding->input.axis.axis_max != binding->output.axis.axis_max) {
1461  float normalized_value = (float)(value - binding->input.axis.axis_min) / (binding->input.axis.axis_max - binding->input.axis.axis_min);
1462  value = binding->output.axis.axis_min + (int)(normalized_value * (binding->output.axis.axis_max - binding->output.axis.axis_min));
1463  }
1464  }
1465  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1466  value = SDL_JoystickGetButton(gamecontroller->joystick, binding->input.button);
1467  if (value == SDL_PRESSED) {
1468  value = binding->output.axis.axis_max;
1469  }
1470  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1471  int hat_mask = SDL_JoystickGetHat(gamecontroller->joystick, binding->input.hat.hat);
1472  if (hat_mask & binding->input.hat.hat_mask) {
1473  value = binding->output.axis.axis_max;
1474  }
1475  }
1476 
1477  if (binding->output.axis.axis_min < binding->output.axis.axis_max) {
1478  valid_output_range = (value >= binding->output.axis.axis_min && value <= binding->output.axis.axis_max);
1479  } else {
1480  valid_output_range = (value >= binding->output.axis.axis_max && value <= binding->output.axis.axis_min);
1481  }
1482  /* If the value is zero, there might be another binding that makes it non-zero */
1483  if (value != 0 && valid_output_range) {
1484  return (Sint16)value;
1485  }
1486  }
1487  }
1488  return 0;
1489 }
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 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 1609 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.

1610 {
1611  int i;
1613  SDL_zero(bind);
1614 
1615  if (!gamecontroller || axis == SDL_CONTROLLER_AXIS_INVALID)
1616  return bind;
1617 
1618  for (i = 0; i < gamecontroller->num_bindings; ++i) {
1619  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1620  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_AXIS && binding->output.axis.axis == axis) {
1621  bind.bindType = binding->inputType;
1622  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1623  /* FIXME: There might be multiple axes bound now that we have axis ranges... */
1624  bind.value.axis = binding->input.axis.axis;
1625  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1626  bind.value.button = binding->input.button;
1627  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1628  bind.value.hat.hat = binding->input.hat.hat;
1629  bind.value.hat.hat_mask = binding->input.hat.hat_mask;
1630  }
1631  break;
1632  }
1633  }
1634  return bind;
1635 }
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: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
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 1641 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.

1642 {
1643  int i;
1645  SDL_zero(bind);
1646 
1647  if (!gamecontroller || button == SDL_CONTROLLER_BUTTON_INVALID)
1648  return bind;
1649 
1650  for (i = 0; i < gamecontroller->num_bindings; ++i) {
1651  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1652  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_BUTTON && binding->output.button == button) {
1653  bind.bindType = binding->inputType;
1654  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1655  bind.value.axis = binding->input.axis.axis;
1656  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1657  bind.value.button = binding->input.button;
1658  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1659  bind.value.hat.hat = binding->input.hat.hat;
1660  bind.value.hat.hat_mask = binding->input.hat.hat_mask;
1661  }
1662  break;
1663  }
1664  }
1665  return bind;
1666 }
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: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
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 1495 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.

1496 {
1497  int i;
1498 
1499  if (!gamecontroller)
1500  return 0;
1501 
1502  for (i = 0; i < gamecontroller->num_bindings; ++i) {
1503  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1504  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_BUTTON && binding->output.button == button) {
1505  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1506  SDL_bool valid_input_range;
1507 
1508  int value = SDL_JoystickGetAxis(gamecontroller->joystick, binding->input.axis.axis);
1509  int threshold = binding->input.axis.axis_min + (binding->input.axis.axis_max - binding->input.axis.axis_min) / 2;
1510  if (binding->input.axis.axis_min < binding->input.axis.axis_max) {
1511  valid_input_range = (value >= binding->input.axis.axis_min && value <= binding->input.axis.axis_max);
1512  if (valid_input_range) {
1513  return (value >= threshold) ? SDL_PRESSED : SDL_RELEASED;
1514  }
1515  } else {
1516  valid_input_range = (value >= binding->input.axis.axis_max && value <= binding->input.axis.axis_min);
1517  if (valid_input_range) {
1518  return (value <= threshold) ? SDL_PRESSED : SDL_RELEASED;
1519  }
1520  }
1521  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1522  return SDL_JoystickGetButton(gamecontroller->joystick, binding->input.button);
1523  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1524  int hat_mask = SDL_JoystickGetHat(gamecontroller->joystick, binding->input.hat.hat);
1525  return (hat_mask & binding->input.hat.hat_mask) ? SDL_PRESSED : SDL_RELEASED;
1526  }
1527  }
1528  }
1529  return SDL_RELEASED;
1530 }
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 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 1575 of file SDL_gamecontroller.c.

References NULL.

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

1576 {
1577  if (!gamecontroller)
1578  return NULL;
1579 
1580  return gamecontroller->joystick;
1581 }
#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 1548 of file SDL_gamecontroller.c.

References SDL_GameControllerGetJoystick(), and SDL_JoystickGetProduct.

1549 {
1550  return SDL_JoystickGetProduct(SDL_GameControllerGetJoystick(gamecontroller));
1551 }
#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 1554 of file SDL_gamecontroller.c.

References SDL_GameControllerGetJoystick(), and SDL_JoystickGetProductVersion.

1555 {
1557 }
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 1542 of file SDL_gamecontroller.c.

References SDL_GameControllerGetJoystick(), and SDL_JoystickGetVendor.

1543 {
1544  return SDL_JoystickGetVendor(SDL_GameControllerGetJoystick(gamecontroller));
1545 }
#define SDL_JoystickGetVendor
SDL_Joystick * SDL_GameControllerGetJoystick(SDL_GameController *gamecontroller)

◆ SDL_GameControllerIgnoreDevicesChanged()

static void SDL_GameControllerIgnoreDevicesChanged ( void userdata,
const char *  name,
const char *  oldValue,
const char *  hint 
)
static

Definition at line 177 of file SDL_gamecontroller.c.

References SDL_LoadVIDPIDListFromHint(), and SDLCALL.

Referenced by SDL_GameControllerInitMappings(), and SDL_GameControllerQuitMappings().

178 {
180 }
static SDL_vidpid_list SDL_ignored_controllers
static void SDL_LoadVIDPIDListFromHint(const char *hint, SDL_vidpid_list *list)

◆ SDL_GameControllerIgnoreDevicesExceptChanged()

static void SDL_GameControllerIgnoreDevicesExceptChanged ( void userdata,
const char *  name,
const char *  oldValue,
const char *  hint 
)
static

Definition at line 183 of file SDL_gamecontroller.c.

References axis, button, SDL_LoadVIDPIDListFromHint(), SDL_PrivateGameControllerAxis(), SDL_PrivateGameControllerButton(), and state.

Referenced by SDL_GameControllerInitMappings(), and SDL_GameControllerQuitMappings().

184 {
186 }
static SDL_vidpid_list SDL_allowed_controllers
static void SDL_LoadVIDPIDListFromHint(const char *hint, SDL_vidpid_list *list)

◆ SDL_GameControllerInit()

int SDL_GameControllerInit ( void  )

Definition at line 1221 of file SDL_gamecontroller.c.

References SDL_Event::cdevice, i, NULL, SDL_AddEventWatch, SDL_CONTROLLERDEVICEADDED, SDL_GameControllerEventWatcher(), SDL_IsGameController(), SDL_NumJoysticks, SDL_PushEvent, SDL_Event::type, and SDL_ControllerDeviceEvent::which.

Referenced by SDL_InitSubSystem().

1222 {
1223  int i;
1224 
1225  /* watch for joy events and fire controller ones if needed */
1227 
1228  /* Send added events for controllers currently attached */
1229  for (i = 0; i < SDL_NumJoysticks(); ++i) {
1230  if (SDL_IsGameController(i)) {
1231  SDL_Event deviceevent;
1232  deviceevent.type = SDL_CONTROLLERDEVICEADDED;
1233  deviceevent.cdevice.which = i;
1234  SDL_PushEvent(&deviceevent);
1235  }
1236  }
1237 
1238  return (0);
1239 }
static int SDL_GameControllerEventWatcher(void *userdata, SDL_Event *event)
SDL_ControllerDeviceEvent cdevice
Definition: SDL_events.h:543
#define SDL_NumJoysticks
#define SDL_PushEvent
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 SDL_IsGameController(int device_index)
#define NULL
Definition: begin_code.h:164
#define SDL_AddEventWatch
General event structure.
Definition: SDL_events.h:525
Uint32 type
Definition: SDL_events.h:527

◆ SDL_GameControllerInitMappings()

int SDL_GameControllerInitMappings ( void  )

Definition at line 1192 of file SDL_gamecontroller.c.

References i, NULL, s_ControllerMappings, SDL_AddHintCallback, SDL_CONTROLLER_MAPPING_PRIORITY_DEFAULT, SDL_GameControllerAddMappingsFromFile, SDL_GameControllerIgnoreDevicesChanged(), SDL_GameControllerIgnoreDevicesExceptChanged(), SDL_GameControllerLoadHints(), SDL_GetControllerMappingFilePath(), SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES, SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT, and SDL_PrivateGameControllerAddMapping().

Referenced by SDL_JoystickInit().

1193 {
1194  char szControllerMapPath[1024];
1195  int i = 0;
1196  const char *pMappingString = NULL;
1197  pMappingString = s_ControllerMappings[i];
1198  while (pMappingString) {
1200 
1201  i++;
1202  pMappingString = s_ControllerMappings[i];
1203  }
1204 
1205  if (SDL_GetControllerMappingFilePath(szControllerMapPath, sizeof(szControllerMapPath))) {
1206  SDL_GameControllerAddMappingsFromFile(szControllerMapPath);
1207  }
1208 
1209  /* load in any user supplied config */
1211 
1216 
1217  return (0);
1218 }
static SDL_bool SDL_GetControllerMappingFilePath(char *path, size_t size)
static void SDL_GameControllerLoadHints()
static int SDL_PrivateGameControllerAddMapping(const char *mappingString, SDL_ControllerMappingPriority priority)
#define SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT
Definition: SDL_hints.h:420
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 NULL
Definition: begin_code.h:164
static void SDL_GameControllerIgnoreDevicesExceptChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
static const char * s_ControllerMappings[]
#define SDL_AddHintCallback
#define SDL_GameControllerAddMappingsFromFile(file)
#define SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES
Definition: SDL_hints.h:407
static void SDL_GameControllerIgnoreDevicesChanged(void *userdata, const char *name, const char *oldValue, const char *hint)

◆ SDL_GameControllerLoadHints()

static void SDL_GameControllerLoadHints ( )
static

Definition at line 1143 of file SDL_gamecontroller.c.

References NULL, SDL_CONTROLLER_MAPPING_PRIORITY_USER, SDL_free, SDL_GetHint, SDL_HINT_GAMECONTROLLERCONFIG, SDL_malloc, SDL_memcpy, SDL_PrivateGameControllerAddMapping(), SDL_strchr, and SDL_strlen.

Referenced by SDL_GameControllerInitMappings().

1144 {
1145  const char *hint = SDL_GetHint(SDL_HINT_GAMECONTROLLERCONFIG);
1146  if (hint && hint[0]) {
1147  size_t nchHints = SDL_strlen(hint);
1148  char *pUserMappings = SDL_malloc(nchHints + 1);
1149  char *pTempMappings = pUserMappings;
1150  SDL_memcpy(pUserMappings, hint, nchHints);
1151  pUserMappings[nchHints] = '\0';
1152  while (pUserMappings) {
1153  char *pchNewLine = NULL;
1154 
1155  pchNewLine = SDL_strchr(pUserMappings, '\n');
1156  if (pchNewLine)
1157  *pchNewLine = '\0';
1158 
1160 
1161  if (pchNewLine) {
1162  pUserMappings = pchNewLine + 1;
1163  } else {
1164  pUserMappings = NULL;
1165  }
1166  }
1167  SDL_free(pTempMappings);
1168  }
1169 }
#define SDL_GetHint
#define SDL_strchr
static int SDL_PrivateGameControllerAddMapping(const char *mappingString, SDL_ControllerMappingPriority priority)
#define SDL_memcpy
#define SDL_free
#define NULL
Definition: begin_code.h:164
#define SDL_strlen
#define SDL_HINT_GAMECONTROLLERCONFIG
A variable that lets you manually hint extra gamecontroller db entries.
Definition: SDL_hints.h:394
#define SDL_malloc

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

References NULL, and SDL_GameControllerMappingForGUID().

1134 {
1135  if (!gamecontroller) {
1136  return NULL;
1137  }
1138 
1139  return SDL_GameControllerMappingForGUID(gamecontroller->guid);
1140 }
#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 1109 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().

1110 {
1111  char *pMappingString = NULL;
1113  if (mapping) {
1114  char pchGUID[33];
1115  size_t needed;
1116  SDL_JoystickGetGUIDString(guid, pchGUID, sizeof(pchGUID));
1117  /* allocate enough memory for GUID + ',' + name + ',' + mapping + \0 */
1118  needed = SDL_strlen(pchGUID) + 1 + SDL_strlen(mapping->name) + 1 + SDL_strlen(mapping->mapping) + 1;
1119  pMappingString = SDL_malloc(needed);
1120  if (!pMappingString) {
1121  SDL_OutOfMemory();
1122  return NULL;
1123  }
1124  SDL_snprintf(pMappingString, needed, "%s,%s,%s", pchGUID, mapping->name, mapping->mapping);
1125  }
1126  return pMappingString;
1127 }
#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 1076 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.

1077 {
1079 
1080  for (mapping = s_pSupportedControllers; mapping; mapping = mapping->next) {
1081  if (SDL_memcmp(&mapping->guid, &s_zeroGUID, sizeof(mapping->guid)) == 0) {
1082  continue;
1083  }
1084  if (mapping_index == 0) {
1085  char *pMappingString;
1086  char pchGUID[33];
1087  size_t needed;
1088 
1089  SDL_JoystickGetGUIDString(mapping->guid, pchGUID, sizeof(pchGUID));
1090  /* allocate enough memory for GUID + ',' + name + ',' + mapping + \0 */
1091  needed = SDL_strlen(pchGUID) + 1 + SDL_strlen(mapping->name) + 1 + SDL_strlen(mapping->mapping) + 1;
1092  pMappingString = SDL_malloc(needed);
1093  if (!pMappingString) {
1094  SDL_OutOfMemory();
1095  return NULL;
1096  }
1097  SDL_snprintf(pMappingString, needed, "%s,%s,%s", pchGUID, mapping->name, mapping->mapping);
1098  return pMappingString;
1099  }
1100  --mapping_index;
1101  }
1102  return NULL;
1103 }
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 1533 of file SDL_gamecontroller.c.

References NULL.

1534 {
1535  if (!gamecontroller)
1536  return NULL;
1537 
1538  return gamecontroller->name;
1539 }
#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 1246 of file SDL_gamecontroller.c.

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

1247 {
1248  ControllerMapping_t *pSupportedController = SDL_PrivateGetControllerMapping(device_index);
1249  if (pSupportedController) {
1250  return pSupportedController->name;
1251  }
1252  return NULL;
1253 }
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 1058 of file SDL_gamecontroller.c.

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

1059 {
1060  int num_mappings = 0;
1062 
1063  for (mapping = s_pSupportedControllers; mapping; mapping = mapping->next) {
1064  if (SDL_memcmp(&mapping->guid, &s_zeroGUID, sizeof(mapping->guid)) == 0) {
1065  continue;
1066  }
1067  ++num_mappings;
1068  }
1069  return num_mappings;
1070 }
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 1341 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.

1342 {
1343  SDL_GameController *gamecontroller;
1344  SDL_GameController *gamecontrollerlist;
1345  ControllerMapping_t *pSupportedController = NULL;
1346 
1347  if ((device_index < 0) || (device_index >= SDL_NumJoysticks())) {
1348  SDL_SetError("There are %d joysticks available", SDL_NumJoysticks());
1349  return (NULL);
1350  }
1351 
1353 
1354  gamecontrollerlist = SDL_gamecontrollers;
1355  /* If the controller is already open, return it */
1356  while (gamecontrollerlist) {
1357  if (SDL_SYS_GetInstanceIdOfDeviceIndex(device_index) == gamecontrollerlist->joystick->instance_id) {
1358  gamecontroller = gamecontrollerlist;
1359  ++gamecontroller->ref_count;
1361  return (gamecontroller);
1362  }
1363  gamecontrollerlist = gamecontrollerlist->next;
1364  }
1365 
1366  /* Find a controller mapping */
1367  pSupportedController = SDL_PrivateGetControllerMapping(device_index);
1368  if (!pSupportedController) {
1369  SDL_SetError("Couldn't find mapping for device (%d)", device_index);
1371  return NULL;
1372  }
1373 
1374  /* Create and initialize the controller */
1375  gamecontroller = (SDL_GameController *) SDL_calloc(1, sizeof(*gamecontroller));
1376  if (gamecontroller == NULL) {
1377  SDL_OutOfMemory();
1379  return NULL;
1380  }
1381 
1382  gamecontroller->joystick = SDL_JoystickOpen(device_index);
1383  if (!gamecontroller->joystick) {
1384  SDL_free(gamecontroller);
1386  return NULL;
1387  }
1388 
1389  if (gamecontroller->joystick->naxes) {
1390  gamecontroller->last_match_axis = (SDL_ExtendedGameControllerBind **)SDL_calloc(gamecontroller->joystick->naxes, sizeof(*gamecontroller->last_match_axis));
1391  if (!gamecontroller->last_match_axis) {
1392  SDL_OutOfMemory();
1393  SDL_JoystickClose(gamecontroller->joystick);
1394  SDL_free(gamecontroller);
1396  return NULL;
1397  }
1398  }
1399  if (gamecontroller->joystick->nhats) {
1400  gamecontroller->last_hat_mask = (Uint8 *)SDL_calloc(gamecontroller->joystick->nhats, sizeof(*gamecontroller->last_hat_mask));
1401  if (!gamecontroller->last_hat_mask) {
1402  SDL_OutOfMemory();
1403  SDL_JoystickClose(gamecontroller->joystick);
1404  SDL_free(gamecontroller->last_match_axis);
1405  SDL_free(gamecontroller);
1407  return NULL;
1408  }
1409  }
1410 
1411  SDL_PrivateLoadButtonMapping(gamecontroller, pSupportedController->guid, pSupportedController->name, pSupportedController->mapping);
1412 
1413  /* Add the controller to list */
1414  ++gamecontroller->ref_count;
1415  /* Link the controller in the list */
1416  gamecontroller->next = SDL_gamecontrollers;
1417  SDL_gamecontrollers = gamecontroller;
1418 
1420 
1421  return (gamecontroller);
1422 }
#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_GameControllerQuit()

void SDL_GameControllerQuit ( void  )

Definition at line 1716 of file SDL_gamecontroller.c.

References SDL_GameControllerClose(), SDL_gamecontrollers, SDL_LockJoysticks, and SDL_UnlockJoysticks.

Referenced by SDL_QuitSubSystem().

1717 {
1719  while (SDL_gamecontrollers) {
1720  SDL_gamecontrollers->ref_count = 1;
1722  }
1724 }
#define SDL_UnlockJoysticks
void SDL_GameControllerClose(SDL_GameController *gamecontroller)
static SDL_GameController * SDL_gamecontrollers
#define SDL_LockJoysticks

◆ SDL_GameControllerQuitMappings()

void SDL_GameControllerQuitMappings ( void  )

Definition at line 1727 of file SDL_gamecontroller.c.

References SDL_vidpid_list::entries, ControllerMapping_t::mapping, ControllerMapping_t::name, ControllerMapping_t::next, NULL, s_pSupportedControllers, SDL_DelEventWatch, SDL_DelHintCallback, SDL_free, SDL_GameControllerEventWatcher(), SDL_GameControllerIgnoreDevicesChanged(), SDL_GameControllerIgnoreDevicesExceptChanged(), SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES, SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT, and SDL_zero.

Referenced by SDL_JoystickQuit().

1728 {
1729  ControllerMapping_t *pControllerMap;
1730 
1731  while (s_pSupportedControllers) {
1732  pControllerMap = s_pSupportedControllers;
1734  SDL_free(pControllerMap->name);
1735  SDL_free(pControllerMap->mapping);
1736  SDL_free(pControllerMap);
1737  }
1738 
1740 
1745 
1749  }
1753  }
1754 }
#define SDL_DelEventWatch
static int SDL_GameControllerEventWatcher(void *userdata, SDL_Event *event)
struct _ControllerMapping_t * next
static SDL_vidpid_list SDL_ignored_controllers
static ControllerMapping_t * s_pSupportedControllers
#define SDL_free
#define SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT
Definition: SDL_hints.h:420
#define SDL_zero(x)
Definition: SDL_stdinc.h:416
#define NULL
Definition: begin_code.h:164
static void SDL_GameControllerIgnoreDevicesExceptChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
static SDL_vidpid_list SDL_allowed_controllers
#define SDL_DelHintCallback
#define SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES
Definition: SDL_hints.h:407
static void SDL_GameControllerIgnoreDevicesChanged(void *userdata, const char *name, const char *oldValue, const char *hint)

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

References SDL_JoystickUpdate.

1429 {
1430  /* Just for API completeness; the joystick API does all the work. */
1432 }
#define SDL_JoystickUpdate

◆ SDL_GetControllerMappingFilePath()

static SDL_bool SDL_GetControllerMappingFilePath ( char *  path,
size_t  size 
)
static

Definition at line 1176 of file SDL_gamecontroller.c.

References SDL_AndroidGetInternalStoragePath, SDL_FALSE, SDL_snprintf, and SDL_strlcpy.

Referenced by SDL_GameControllerInitMappings().

1177 {
1178 #ifdef CONTROLLER_MAPPING_FILE
1179 #define STRING(X) SDL_STRINGIFY_ARG(X)
1180  return SDL_strlcpy(path, STRING(CONTROLLER_MAPPING_FILE), size) < size;
1181 #elif defined(__ANDROID__)
1182  return SDL_snprintf(path, size, "%s/controller_map.txt", SDL_AndroidGetInternalStoragePath()) < size;
1183 #else
1184  return SDL_FALSE;
1185 #endif
1186 }
#define SDL_strlcpy
GLsizeiptr size
#define SDL_snprintf
GLsizei const GLchar *const * path
#define SDL_AndroidGetInternalStoragePath

◆ SDL_IsGameController()

SDL_bool SDL_IsGameController ( int  joystick_index)

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

Definition at line 1273 of file SDL_gamecontroller.c.

References SDL_FALSE, SDL_PrivateGetControllerMapping(), and SDL_TRUE.

Referenced by SDL_GameControllerEventWatcher(), and SDL_GameControllerInit().

1274 {
1275  ControllerMapping_t *pSupportedController = SDL_PrivateGetControllerMapping(device_index);
1276  if (pSupportedController) {
1277  return SDL_TRUE;
1278  }
1279  return SDL_FALSE;
1280 }
static ControllerMapping_t * SDL_PrivateGetControllerMapping(int device_index)

◆ SDL_IsGameControllerNameAndGUID()

SDL_bool SDL_IsGameControllerNameAndGUID ( const char *  name,
SDL_JoystickGUID  guid 
)

Definition at line 1260 of file SDL_gamecontroller.c.

References SDL_FALSE, SDL_PrivateGetControllerMappingForNameAndGUID(), and SDL_TRUE.

1261 {
1263  if (pSupportedController) {
1264  return SDL_TRUE;
1265  }
1266  return SDL_FALSE;
1267 }
static ControllerMapping_t * SDL_PrivateGetControllerMappingForNameAndGUID(const char *name, SDL_JoystickGUID guid)
GLuint const GLchar * name

◆ SDL_LoadVIDPIDListFromHint()

static void SDL_LoadVIDPIDListFromHint ( const char *  hint,
SDL_vidpid_list list 
)
static

Definition at line 131 of file SDL_gamecontroller.c.

References SDL_vidpid_list::entries, SDL_vidpid_list::max_entries, NULL, SDL_vidpid_list::num_entries, SDL_free, SDL_LoadFile, SDL_realloc, SDL_strstr, SDL_strtol, and SDLCALL.

Referenced by SDL_GameControllerIgnoreDevicesChanged(), and SDL_GameControllerIgnoreDevicesExceptChanged().

132 {
133  Uint32 entry;
134  char *spot;
135  char *file = NULL;
136 
137  list->num_entries = 0;
138 
139  if (hint && *hint == '@') {
140  spot = file = (char *)SDL_LoadFile(hint+1, NULL);
141  } else {
142  spot = (char *)hint;
143  }
144 
145  if (!spot) {
146  return;
147  }
148 
149  while ((spot = SDL_strstr(spot, "0x")) != NULL) {
150  entry = (Uint16)SDL_strtol(spot, &spot, 0);
151  entry <<= 16;
152  spot = SDL_strstr(spot, "0x");
153  if (!spot) {
154  break;
155  }
156  entry |= (Uint16)SDL_strtol(spot, &spot, 0);
157 
158  if (list->num_entries == list->max_entries) {
159  int max_entries = list->max_entries + 16;
160  Uint32 *entries = (Uint32 *)SDL_realloc(list->entries, max_entries*sizeof(*list->entries));
161  if (entries == NULL) {
162  /* Out of memory, go with what we have already */
163  break;
164  }
165  list->entries = entries;
166  list->max_entries = max_entries;
167  }
168  list->entries[list->num_entries++] = entry;
169  }
170 
171  if (file) {
172  SDL_free(file);
173  }
174 }
uint32_t Uint32
Definition: SDL_stdinc.h:181
#define SDL_realloc
#define SDL_free
#define SDL_strtol
#define NULL
Definition: begin_code.h:164
uint16_t Uint16
Definition: SDL_stdinc.h:169
#define SDL_LoadFile(file, datasize)
Definition: SDL_rwops.h:214
#define SDL_strstr

◆ SDL_PrivateAddMappingForGUID()

static ControllerMapping_t* SDL_PrivateAddMappingForGUID ( SDL_JoystickGUID  jGUID,
const char *  mappingString,
SDL_bool existing,
SDL_ControllerMappingPriority  priority 
)
static

Definition at line 804 of file SDL_gamecontroller.c.

References ControllerMapping_t::guid, ControllerMapping_t::mapping, ControllerMapping_t::name, ControllerMapping_t::next, NULL, ControllerMapping_t::priority, SDL_FALSE, SDL_free, SDL_malloc, SDL_OutOfMemory, SDL_PrivateGameControllerRefreshMapping(), SDL_PrivateGetControllerMappingForGUID(), SDL_PrivateGetControllerMappingFromMappingString(), SDL_PrivateGetControllerNameFromMappingString(), SDL_SetError, and SDL_TRUE.

Referenced by SDL_PrivateGameControllerAddMapping(), and SDL_PrivateGetControllerMappingForNameAndGUID().

805 {
806  char *pchName;
807  char *pchMapping;
808  ControllerMapping_t *pControllerMapping;
809 
810  pchName = SDL_PrivateGetControllerNameFromMappingString(mappingString);
811  if (!pchName) {
812  SDL_SetError("Couldn't parse name from %s", mappingString);
813  return NULL;
814  }
815 
816  pchMapping = SDL_PrivateGetControllerMappingFromMappingString(mappingString);
817  if (!pchMapping) {
818  SDL_free(pchName);
819  SDL_SetError("Couldn't parse %s", mappingString);
820  return NULL;
821  }
822 
823  pControllerMapping = SDL_PrivateGetControllerMappingForGUID(&jGUID);
824  if (pControllerMapping) {
825  /* Only overwrite the mapping if the priority is the same or higher. */
826  if (pControllerMapping->priority <= priority) {
827  /* Update existing mapping */
828  SDL_free(pControllerMapping->name);
829  pControllerMapping->name = pchName;
830  SDL_free(pControllerMapping->mapping);
831  pControllerMapping->mapping = pchMapping;
832  pControllerMapping->priority = priority;
833  /* refresh open controllers */
834  SDL_PrivateGameControllerRefreshMapping(pControllerMapping);
835  } else {
836  SDL_free(pchName);
837  SDL_free(pchMapping);
838  }
839  *existing = SDL_TRUE;
840  } else {
841  pControllerMapping = SDL_malloc(sizeof(*pControllerMapping));
842  if (!pControllerMapping) {
843  SDL_free(pchName);
844  SDL_free(pchMapping);
845  SDL_OutOfMemory();
846  return NULL;
847  }
848  pControllerMapping->guid = jGUID;
849  pControllerMapping->name = pchName;
850  pControllerMapping->mapping = pchMapping;
851  pControllerMapping->next = NULL;
852  pControllerMapping->priority = priority;
853 
855  /* Add the mapping to the end of the list */
856  ControllerMapping_t *pCurrMapping, *pPrevMapping;
857 
858  for ( pPrevMapping = s_pSupportedControllers, pCurrMapping = pPrevMapping->next;
859  pCurrMapping;
860  pPrevMapping = pCurrMapping, pCurrMapping = pCurrMapping->next ) {
861  continue;
862  }
863  pPrevMapping->next = pControllerMapping;
864  } else {
865  s_pSupportedControllers = pControllerMapping;
866  }
867  *existing = SDL_FALSE;
868  }
869  return pControllerMapping;
870 }
SDL_ControllerMappingPriority priority
struct _ControllerMapping_t * next
static ControllerMapping_t * SDL_PrivateGetControllerMappingForGUID(SDL_JoystickGUID *guid)
SDL_JoystickGUID guid
static ControllerMapping_t * s_pSupportedControllers
#define SDL_free
static char * SDL_PrivateGetControllerMappingFromMappingString(const char *pMapping)
static void SDL_PrivateGameControllerRefreshMapping(ControllerMapping_t *pControllerMapping)
#define NULL
Definition: begin_code.h:164
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
static char * SDL_PrivateGetControllerNameFromMappingString(const char *pMapping)
#define SDL_SetError
#define SDL_malloc

◆ SDL_PrivateGameControllerAddMapping()

static int SDL_PrivateGameControllerAddMapping ( const char *  mappingString,
SDL_ControllerMappingPriority  priority 
)
static

Definition at line 1001 of file SDL_gamecontroller.c.

References SDL_FALSE, SDL_free, SDL_InvalidParamError, SDL_JoystickGetGUIDFromString, SDL_PrivateAddMappingForGUID(), SDL_PrivateGetControllerGUIDFromMappingString(), SDL_SetError, SDL_strcasecmp, and SDL_TRUE.

Referenced by SDL_GameControllerAddMapping(), SDL_GameControllerInitMappings(), and SDL_GameControllerLoadHints().

1002 {
1003  char *pchGUID;
1004  SDL_JoystickGUID jGUID;
1005  SDL_bool is_xinput_mapping = SDL_FALSE;
1006  SDL_bool is_emscripten_mapping = SDL_FALSE;
1007  SDL_bool existing = SDL_FALSE;
1008  ControllerMapping_t *pControllerMapping;
1009 
1010  if (!mappingString) {
1011  return SDL_InvalidParamError("mappingString");
1012  }
1013 
1014  pchGUID = SDL_PrivateGetControllerGUIDFromMappingString(mappingString);
1015  if (!pchGUID) {
1016  return SDL_SetError("Couldn't parse GUID from %s", mappingString);
1017  }
1018  if (!SDL_strcasecmp(pchGUID, "xinput")) {
1019  is_xinput_mapping = SDL_TRUE;
1020  }
1021  if (!SDL_strcasecmp(pchGUID, "emscripten")) {
1022  is_emscripten_mapping = SDL_TRUE;
1023  }
1024  jGUID = SDL_JoystickGetGUIDFromString(pchGUID);
1025  SDL_free(pchGUID);
1026 
1027  pControllerMapping = SDL_PrivateAddMappingForGUID(jGUID, mappingString, &existing, priority);
1028  if (!pControllerMapping) {
1029  return -1;
1030  }
1031 
1032  if (existing) {
1033  return 0;
1034  } else {
1035  if (is_xinput_mapping) {
1036  s_pXInputMapping = pControllerMapping;
1037  }
1038  if (is_emscripten_mapping) {
1039  s_pEmscriptenMapping = pControllerMapping;
1040  }
1041  return 1;
1042  }
1043 }
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
#define SDL_strcasecmp
static ControllerMapping_t * s_pEmscriptenMapping
#define SDL_free
static char * SDL_PrivateGetControllerGUIDFromMappingString(const char *pMapping)
SDL_bool
Definition: SDL_stdinc.h:139
#define SDL_SetError
static ControllerMapping_t * s_pXInputMapping
static ControllerMapping_t * SDL_PrivateAddMappingForGUID(SDL_JoystickGUID jGUID, const char *mappingString, SDL_bool *existing, SDL_ControllerMappingPriority priority)
#define SDL_JoystickGetGUIDFromString

◆ SDL_PrivateGameControllerAxis()

static int SDL_PrivateGameControllerAxis ( SDL_GameController *  gamecontroller,
SDL_GameControllerAxis  axis,
Sint16  value 
)
static

Definition at line 1760 of file SDL_gamecontroller.c.

References axis, SDL_CONTROLLERAXISMOTION, SDL_ENABLE, SDL_GetEventState, and SDL_PushEvent.

Referenced by HandleJoystickAxis(), HandleJoystickButton(), HandleJoystickHat(), ResetOutput(), and SDL_GameControllerIgnoreDevicesExceptChanged().

1761 {
1762  int posted;
1763 
1764  /* translate the event, if desired */
1765  posted = 0;
1766 #if !SDL_EVENTS_DISABLED
1768  SDL_Event event;
1769  event.type = SDL_CONTROLLERAXISMOTION;
1770  event.caxis.which = gamecontroller->joystick->instance_id;
1771  event.caxis.axis = axis;
1772  event.caxis.value = value;
1773  posted = SDL_PushEvent(&event) == 1;
1774  }
1775 #endif /* !SDL_EVENTS_DISABLED */
1776  return (posted);
1777 }
#define SDL_ENABLE
Definition: SDL_events.h:722
SDL_Texture * axis
#define SDL_GetEventState(type)
Definition: SDL_events.h:735
struct _cl_event * event
#define SDL_PushEvent
GLsizei const GLfloat * value
General event structure.
Definition: SDL_events.h:525

◆ SDL_PrivateGameControllerButton()

static int SDL_PrivateGameControllerButton ( SDL_GameController *  gamecontroller,
SDL_GameControllerButton  button,
Uint8  state 
)
static

Definition at line 1784 of file SDL_gamecontroller.c.

References button, SDL_CONTROLLER_BUTTON_INVALID, SDL_CONTROLLERBUTTONDOWN, SDL_CONTROLLERBUTTONUP, SDL_ENABLE, SDL_GetEventState, SDL_PRESSED, SDL_PushEvent, SDL_RELEASED, state, and SDL_Event::type.

Referenced by HandleJoystickAxis(), HandleJoystickButton(), HandleJoystickHat(), ResetOutput(), and SDL_GameControllerIgnoreDevicesExceptChanged().

1785 {
1786  int posted;
1787 #if !SDL_EVENTS_DISABLED
1788  SDL_Event event;
1789 
1791  return (0);
1792 
1793  switch (state) {
1794  case SDL_PRESSED:
1795  event.type = SDL_CONTROLLERBUTTONDOWN;
1796  break;
1797  case SDL_RELEASED:
1798  event.type = SDL_CONTROLLERBUTTONUP;
1799  break;
1800  default:
1801  /* Invalid state -- bail */
1802  return (0);
1803  }
1804 #endif /* !SDL_EVENTS_DISABLED */
1805 
1806  /* translate the event, if desired */
1807  posted = 0;
1808 #if !SDL_EVENTS_DISABLED
1809  if (SDL_GetEventState(event.type) == SDL_ENABLE) {
1810  event.cbutton.which = gamecontroller->joystick->instance_id;
1811  event.cbutton.button = button;
1812  event.cbutton.state = state;
1813  posted = SDL_PushEvent(&event) == 1;
1814  }
1815 #endif /* !SDL_EVENTS_DISABLED */
1816  return (posted);
1817 }
SDL_Texture * button
struct xkb_state * state
#define SDL_ENABLE
Definition: SDL_events.h:722
#define SDL_GetEventState(type)
Definition: SDL_events.h:735
struct _cl_event * event
#define SDL_PushEvent
General event structure.
Definition: SDL_events.h:525
#define SDL_PRESSED
Definition: SDL_events.h:50
#define SDL_RELEASED
Definition: SDL_events.h:49
Uint32 type
Definition: SDL_events.h:527

◆ SDL_PrivateGameControllerParseControllerConfigString()

static void SDL_PrivateGameControllerParseControllerConfigString ( SDL_GameController *  gamecontroller,
const char *  pchString 
)
static

Definition at line 619 of file SDL_gamecontroller.c.

References i, SDL_FALSE, SDL_PrivateGameControllerParseElement(), SDL_SetError, SDL_TRUE, and SDL_zero.

Referenced by SDL_PrivateLoadButtonMapping().

620 {
621  char szGameButton[20];
622  char szJoystickButton[20];
623  SDL_bool bGameButton = SDL_TRUE;
624  int i = 0;
625  const char *pchPos = pchString;
626 
627  SDL_zero(szGameButton);
628  SDL_zero(szJoystickButton);
629 
630  while (pchPos && *pchPos) {
631  if (*pchPos == ':') {
632  i = 0;
633  bGameButton = SDL_FALSE;
634  } else if (*pchPos == ' ') {
635 
636  } else if (*pchPos == ',') {
637  i = 0;
638  bGameButton = SDL_TRUE;
639  SDL_PrivateGameControllerParseElement(gamecontroller, szGameButton, szJoystickButton);
640  SDL_zero(szGameButton);
641  SDL_zero(szJoystickButton);
642 
643  } else if (bGameButton) {
644  if (i >= sizeof(szGameButton)) {
645  SDL_SetError("Button name too large: %s", szGameButton);
646  return;
647  }
648  szGameButton[i] = *pchPos;
649  i++;
650  } else {
651  if (i >= sizeof(szJoystickButton)) {
652  SDL_SetError("Joystick button name too large: %s", szJoystickButton);
653  return;
654  }
655  szJoystickButton[i] = *pchPos;
656  i++;
657  }
658  pchPos++;
659  }
660 
661  SDL_PrivateGameControllerParseElement(gamecontroller, szGameButton, szJoystickButton);
662 
663 }
#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
static void SDL_PrivateGameControllerParseElement(SDL_GameController *gamecontroller, const char *szGameButton, const char *szJoystickButton)
SDL_bool
Definition: SDL_stdinc.h:139
#define SDL_SetError

◆ SDL_PrivateGameControllerParseElement()

static void SDL_PrivateGameControllerParseElement ( SDL_GameController *  gamecontroller,
const char *  szGameButton,
const char *  szJoystickButton 
)
static

Definition at line 523 of file SDL_gamecontroller.c.

References SDL_ExtendedGameControllerBind::axis, axis, SDL_ExtendedGameControllerBind::button, button, SDL_ExtendedGameControllerBind::hat, SDL_ExtendedGameControllerBind::input, SDL_ExtendedGameControllerBind::inputType, SDL_ExtendedGameControllerBind::output, SDL_ExtendedGameControllerBind::outputType, SDL_atoi, SDL_CONTROLLER_AXIS_INVALID, SDL_CONTROLLER_AXIS_TRIGGERLEFT, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, SDL_CONTROLLER_BINDTYPE_AXIS, SDL_CONTROLLER_BINDTYPE_BUTTON, SDL_CONTROLLER_BINDTYPE_HAT, SDL_CONTROLLER_BUTTON_INVALID, SDL_FALSE, SDL_GameControllerGetAxisFromString(), SDL_GameControllerGetButtonFromString(), SDL_isdigit, SDL_JOYSTICK_AXIS_MAX, SDL_JOYSTICK_AXIS_MIN, SDL_OutOfMemory, SDL_realloc, SDL_SetError, SDL_strlen, and SDL_TRUE.

Referenced by SDL_PrivateGameControllerParseControllerConfigString().

524 {
528  SDL_bool invert_input = SDL_FALSE;
529  char half_axis_input = 0;
530  char half_axis_output = 0;
531 
532  if (*szGameButton == '+' || *szGameButton == '-') {
533  half_axis_output = *szGameButton++;
534  }
535 
536  axis = SDL_GameControllerGetAxisFromString(szGameButton);
537  button = SDL_GameControllerGetButtonFromString(szGameButton);
538  if (axis != SDL_CONTROLLER_AXIS_INVALID) {
540  bind.output.axis.axis = axis;
542  bind.output.axis.axis_min = 0;
543  bind.output.axis.axis_max = SDL_JOYSTICK_AXIS_MAX;
544  } else {
545  if (half_axis_output == '+') {
546  bind.output.axis.axis_min = 0;
547  bind.output.axis.axis_max = SDL_JOYSTICK_AXIS_MAX;
548  } else if (half_axis_output == '-') {
549  bind.output.axis.axis_min = 0;
550  bind.output.axis.axis_max = SDL_JOYSTICK_AXIS_MIN;
551  } else {
552  bind.output.axis.axis_min = SDL_JOYSTICK_AXIS_MIN;
553  bind.output.axis.axis_max = SDL_JOYSTICK_AXIS_MAX;
554  }
555  }
556  } else if (button != SDL_CONTROLLER_BUTTON_INVALID) {
558  bind.output.button = button;
559  } else {
560  SDL_SetError("Unexpected controller element %s", szGameButton);
561  return;
562  }
563 
564  if (*szJoystickButton == '+' || *szJoystickButton == '-') {
565  half_axis_input = *szJoystickButton++;
566  }
567  if (szJoystickButton[SDL_strlen(szJoystickButton) - 1] == '~') {
568  invert_input = SDL_TRUE;
569  }
570 
571  if (szJoystickButton[0] == 'a' && SDL_isdigit(szJoystickButton[1])) {
573  bind.input.axis.axis = SDL_atoi(&szJoystickButton[1]);
574  if (half_axis_input == '+') {
575  bind.input.axis.axis_min = 0;
576  bind.input.axis.axis_max = SDL_JOYSTICK_AXIS_MAX;
577  } else if (half_axis_input == '-') {
578  bind.input.axis.axis_min = 0;
579  bind.input.axis.axis_max = SDL_JOYSTICK_AXIS_MIN;
580  } else {
581  bind.input.axis.axis_min = SDL_JOYSTICK_AXIS_MIN;
582  bind.input.axis.axis_max = SDL_JOYSTICK_AXIS_MAX;
583  }
584  if (invert_input) {
585  int tmp = bind.input.axis.axis_min;
586  bind.input.axis.axis_min = bind.input.axis.axis_max;
587  bind.input.axis.axis_max = tmp;
588  }
589  } else if (szJoystickButton[0] == 'b' && SDL_isdigit(szJoystickButton[1])) {
591  bind.input.button = SDL_atoi(&szJoystickButton[1]);
592  } else if (szJoystickButton[0] == 'h' && SDL_isdigit(szJoystickButton[1]) &&
593  szJoystickButton[2] == '.' && SDL_isdigit(szJoystickButton[3])) {
594  int hat = SDL_atoi(&szJoystickButton[1]);
595  int mask = SDL_atoi(&szJoystickButton[3]);
597  bind.input.hat.hat = hat;
598  bind.input.hat.hat_mask = mask;
599  } else {
600  SDL_SetError("Unexpected joystick element: %s", szJoystickButton);
601  return;
602  }
603 
604  ++gamecontroller->num_bindings;
605  gamecontroller->bindings = (SDL_ExtendedGameControllerBind *)SDL_realloc(gamecontroller->bindings, gamecontroller->num_bindings * sizeof(*gamecontroller->bindings));
606  if (!gamecontroller->bindings) {
607  gamecontroller->num_bindings = 0;
608  SDL_OutOfMemory();
609  return;
610  }
611  gamecontroller->bindings[gamecontroller->num_bindings - 1] = bind;
612 }
union SDL_ExtendedGameControllerBind::@22 input
SDL_GameControllerButton SDL_GameControllerGetButtonFromString(const char *pchString)
SDL_Texture * button
SDL_GameControllerAxis SDL_GameControllerGetAxisFromString(const char *pchString)
SDL_GameControllerBindType inputType
SDL_Texture * axis
SDL_GameControllerButton
#define SDL_realloc
#define SDL_JOYSTICK_AXIS_MIN
Definition: SDL_joystick.h:289
#define SDL_JOYSTICK_AXIS_MAX
Definition: SDL_joystick.h:288
#define SDL_isdigit
GLenum GLint GLuint mask
SDL_GameControllerBindType outputType
#define SDL_atoi
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_bool
Definition: SDL_stdinc.h:139
#define SDL_SetError
#define SDL_strlen
union SDL_ExtendedGameControllerBind::@23 output
SDL_GameControllerAxis

◆ SDL_PrivateGameControllerRefreshMapping()

static void SDL_PrivateGameControllerRefreshMapping ( ControllerMapping_t pControllerMapping)
static

Definition at line 782 of file SDL_gamecontroller.c.

References ControllerMapping_t::guid, ControllerMapping_t::mapping, ControllerMapping_t::name, SDL_CONTROLLERDEVICEREMAPPED, SDL_gamecontrollers, SDL_memcmp, SDL_PrivateLoadButtonMapping(), and SDL_PushEvent.

Referenced by SDL_PrivateAddMappingForGUID().

783 {
784  SDL_GameController *gamecontrollerlist = SDL_gamecontrollers;
785  while (gamecontrollerlist) {
786  if (!SDL_memcmp(&gamecontrollerlist->guid, &pControllerMapping->guid, sizeof(pControllerMapping->guid))) {
788  event.type = SDL_CONTROLLERDEVICEREMAPPED;
789  event.cdevice.which = gamecontrollerlist->joystick->instance_id;
790  SDL_PushEvent(&event);
791 
792  /* Not really threadsafe. Should this lock access within SDL_GameControllerEventWatcher? */
793  SDL_PrivateLoadButtonMapping(gamecontrollerlist, pControllerMapping->guid, pControllerMapping->name, pControllerMapping->mapping);
794  }
795 
796  gamecontrollerlist = gamecontrollerlist->next;
797  }
798 }
SDL_JoystickGUID guid
static SDL_GameController * SDL_gamecontrollers
struct _cl_event * event
#define SDL_PushEvent
#define SDL_memcmp
General event structure.
Definition: SDL_events.h:525
static void SDL_PrivateLoadButtonMapping(SDL_GameController *gamecontroller, SDL_JoystickGUID guid, const char *pchName, const char *pchMapping)

◆ SDL_PrivateGetControllerGUIDFromMappingString()

static char* SDL_PrivateGetControllerGUIDFromMappingString ( const char *  pMapping)
static

Definition at line 698 of file SDL_gamecontroller.c.

References NULL, SDL_malloc, SDL_memcmp, SDL_memcpy, SDL_OutOfMemory, SDL_strchr, and SDL_strlen.

Referenced by SDL_PrivateGameControllerAddMapping().

699 {
700  const char *pFirstComma = SDL_strchr(pMapping, ',');
701  if (pFirstComma) {
702  char *pchGUID = SDL_malloc(pFirstComma - pMapping + 1);
703  if (!pchGUID) {
704  SDL_OutOfMemory();
705  return NULL;
706  }
707  SDL_memcpy(pchGUID, pMapping, pFirstComma - pMapping);
708  pchGUID[pFirstComma - pMapping] = '\0';
709 
710  /* Convert old style GUIDs to the new style in 2.0.5 */
711 #if __WIN32__
712  if (SDL_strlen(pchGUID) == 32 &&
713  SDL_memcmp(&pchGUID[20], "504944564944", 12) == 0) {
714  SDL_memcpy(&pchGUID[20], "000000000000", 12);
715  SDL_memcpy(&pchGUID[16], &pchGUID[4], 4);
716  SDL_memcpy(&pchGUID[8], &pchGUID[0], 4);
717  SDL_memcpy(&pchGUID[0], "03000000", 8);
718  }
719 #elif __MACOSX__
720  if (SDL_strlen(pchGUID) == 32 &&
721  SDL_memcmp(&pchGUID[4], "000000000000", 12) == 0 &&
722  SDL_memcmp(&pchGUID[20], "000000000000", 12) == 0) {
723  SDL_memcpy(&pchGUID[20], "000000000000", 12);
724  SDL_memcpy(&pchGUID[8], &pchGUID[0], 4);
725  SDL_memcpy(&pchGUID[0], "03000000", 8);
726  }
727 #endif
728  return pchGUID;
729  }
730  return NULL;
731 }
#define SDL_strchr
#define SDL_memcpy
#define SDL_memcmp
#define NULL
Definition: begin_code.h:164
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
#define SDL_strlen
#define SDL_malloc

◆ SDL_PrivateGetControllerMapping()

static ControllerMapping_t* SDL_PrivateGetControllerMapping ( int  device_index)
static

Definition at line 907 of file SDL_gamecontroller.c.

References recDevice::guid, recDevice::name, s_pXInputMapping, SDL_JoystickGetDeviceGUID, SDL_JoystickNameForIndex, SDL_LockJoysticks, SDL_PrivateGetControllerMappingForNameAndGUID(), and SDL_UnlockJoysticks.

Referenced by SDL_GameControllerNameForIndex(), SDL_GameControllerOpen(), and SDL_IsGameController().

908 {
909  const char *name;
910  SDL_JoystickGUID guid;
912 
914  name = SDL_JoystickNameForIndex(device_index);
915  guid = SDL_JoystickGetDeviceGUID(device_index);
916  mapping = SDL_PrivateGetControllerMappingForNameAndGUID(name, guid);
917 #if SDL_JOYSTICK_XINPUT
918  if (!mapping && SDL_SYS_IsXInputGamepad_DeviceIndex(device_index)) {
919  mapping = s_pXInputMapping;
920  }
921 #endif
923  return mapping;
924 }
#define SDL_UnlockJoysticks
#define SDL_JoystickNameForIndex
static ControllerMapping_t * SDL_PrivateGetControllerMappingForNameAndGUID(const char *name, SDL_JoystickGUID guid)
GLuint const GLchar * name
#define SDL_JoystickGetDeviceGUID
static ControllerMapping_t * s_pXInputMapping
GLenum GLenum GLenum GLenum mapping
#define SDL_LockJoysticks

◆ SDL_PrivateGetControllerMappingForGUID()

static ControllerMapping_t* SDL_PrivateGetControllerMappingForGUID ( SDL_JoystickGUID guid)
static

Definition at line 419 of file SDL_gamecontroller.c.

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

Referenced by SDL_GameControllerMappingForGUID(), SDL_PrivateAddMappingForGUID(), and SDL_PrivateGetControllerMappingForNameAndGUID().

420 {
421  ControllerMapping_t *pSupportedController = s_pSupportedControllers;
422  while (pSupportedController) {
423  if (SDL_memcmp(guid, &pSupportedController->guid, sizeof(*guid)) == 0) {
424  return pSupportedController;
425  }
426  pSupportedController = pSupportedController->next;
427  }
428  return NULL;
429 }
struct _ControllerMapping_t * next
SDL_JoystickGUID guid
static ControllerMapping_t * s_pSupportedControllers
#define SDL_memcmp
#define NULL
Definition: begin_code.h:164

◆ SDL_PrivateGetControllerMappingForNameAndGUID()

static ControllerMapping_t* SDL_PrivateGetControllerMappingForNameAndGUID ( const char *  name,
SDL_JoystickGUID  guid 
)
static

Definition at line 875 of file SDL_gamecontroller.c.

References s_pEmscriptenMapping, s_pXInputMapping, SDL_CONTROLLER_MAPPING_PRIORITY_DEFAULT, SDL_PrivateAddMappingForGUID(), SDL_PrivateGetControllerMappingForGUID(), SDL_strstr, and void.

Referenced by SDL_IsGameControllerNameAndGUID(), and SDL_PrivateGetControllerMapping().

876 {
878 
880 #if defined(SDL_JOYSTICK_EMSCRIPTEN)
881  if (!mapping && s_pEmscriptenMapping) {
882  mapping = s_pEmscriptenMapping;
883  }
884 #else
885  (void) s_pEmscriptenMapping; /* pacify ARMCC */
886 #endif
887 #ifdef __LINUX__
888  if (!mapping && name) {
889  if (SDL_strstr(name, "Xbox 360 Wireless Receiver")) {
890  /* The Linux driver xpad.c maps the wireless dpad to buttons */
891  SDL_bool existing;
892  mapping = SDL_PrivateAddMappingForGUID(guid,
893 "none,X360 Wireless Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b11,dpright:b12,dpup:b13,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
895  }
896  }
897 #endif /* __LINUX__ */
898 
899  if (!mapping && name) {
900  if (SDL_strstr(name, "Xbox") || SDL_strstr(name, "X-Box") || SDL_strstr(name, "XBOX")) {
901  mapping = s_pXInputMapping;
902  }
903  }
904  return mapping;
905 }
static ControllerMapping_t * s_pEmscriptenMapping
GLuint const GLchar * name
static ControllerMapping_t * SDL_PrivateGetControllerMappingForGUID(SDL_JoystickGUID *guid)
SDL_bool
Definition: SDL_stdinc.h:139
SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char const char SDL_SCANF_FORMAT_STRING const char return SDL_ThreadFunction const char void return Uint32 return Uint32 void
static ControllerMapping_t * s_pXInputMapping
GLenum GLenum GLenum GLenum mapping
static ControllerMapping_t * SDL_PrivateAddMappingForGUID(SDL_JoystickGUID jGUID, const char *mappingString, SDL_bool *existing, SDL_ControllerMappingPriority priority)
#define SDL_strstr

◆ SDL_PrivateGetControllerMappingFromMappingString()

static char* SDL_PrivateGetControllerMappingFromMappingString ( const char *  pMapping)
static

Definition at line 764 of file SDL_gamecontroller.c.

References NULL, SDL_strchr, and SDL_strdup.

Referenced by SDL_PrivateAddMappingForGUID().

765 {
766  const char *pFirstComma, *pSecondComma;
767 
768  pFirstComma = SDL_strchr(pMapping, ',');
769  if (!pFirstComma)
770  return NULL;
771 
772  pSecondComma = SDL_strchr(pFirstComma + 1, ',');
773  if (!pSecondComma)
774  return NULL;
775 
776  return SDL_strdup(pSecondComma + 1); /* mapping is everything after the 3rd comma */
777 }
#define SDL_strchr
#define NULL
Definition: begin_code.h:164
#define SDL_strdup

◆ SDL_PrivateGetControllerNameFromMappingString()

static char* SDL_PrivateGetControllerNameFromMappingString ( const char *  pMapping)
static

Definition at line 737 of file SDL_gamecontroller.c.

References NULL, SDL_malloc, SDL_memcpy, SDL_OutOfMemory, and SDL_strchr.

Referenced by SDL_PrivateAddMappingForGUID().

738 {
739  const char *pFirstComma, *pSecondComma;
740  char *pchName;
741 
742  pFirstComma = SDL_strchr(pMapping, ',');
743  if (!pFirstComma)
744  return NULL;
745 
746  pSecondComma = SDL_strchr(pFirstComma + 1, ',');
747  if (!pSecondComma)
748  return NULL;
749 
750  pchName = SDL_malloc(pSecondComma - pFirstComma);
751  if (!pchName) {
752  SDL_OutOfMemory();
753  return NULL;
754  }
755  SDL_memcpy(pchName, pFirstComma + 1, pSecondComma - pFirstComma);
756  pchName[pSecondComma - pFirstComma - 1] = 0;
757  return pchName;
758 }
#define SDL_strchr
#define SDL_memcpy
#define NULL
Definition: begin_code.h:164
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
#define SDL_malloc

◆ SDL_PrivateLoadButtonMapping()

static void SDL_PrivateLoadButtonMapping ( SDL_GameController *  gamecontroller,
SDL_JoystickGUID  guid,
const char *  pchName,
const char *  pchMapping 
)
static

Definition at line 668 of file SDL_gamecontroller.c.

References SDL_ExtendedGameControllerBind::axis, recDevice::guid, i, SDL_ExtendedGameControllerBind::input, SDL_ExtendedGameControllerBind::inputType, SDL_ExtendedGameControllerBind::output, SDL_ExtendedGameControllerBind::outputType, SDL_CONTROLLER_AXIS_TRIGGERLEFT, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, SDL_CONTROLLER_BINDTYPE_AXIS, SDL_memset, and SDL_PrivateGameControllerParseControllerConfigString().

Referenced by SDL_GameControllerOpen(), and SDL_PrivateGameControllerRefreshMapping().

669 {
670  int i;
671 
672  gamecontroller->guid = guid;
673  gamecontroller->name = pchName;
674  gamecontroller->num_bindings = 0;
675  SDL_memset(gamecontroller->last_match_axis, 0, gamecontroller->joystick->naxes * sizeof(*gamecontroller->last_match_axis));
676 
677  SDL_PrivateGameControllerParseControllerConfigString(gamecontroller, pchMapping);
678 
679  /* Set the zero point for triggers */
680  for (i = 0; i < gamecontroller->num_bindings; ++i) {
681  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
682  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS &&
684  (binding->output.axis.axis == SDL_CONTROLLER_AXIS_TRIGGERLEFT ||
685  binding->output.axis.axis == SDL_CONTROLLER_AXIS_TRIGGERRIGHT)) {
686  if (binding->input.axis.axis < gamecontroller->joystick->naxes) {
687  gamecontroller->joystick->axes[binding->input.axis.axis].value =
688  gamecontroller->joystick->axes[binding->input.axis.axis].zero = (Sint16)binding->input.axis.axis_min;
689  }
690  }
691  }
692 }
union SDL_ExtendedGameControllerBind::@22 input
SDL_GameControllerBindType inputType
static void SDL_PrivateGameControllerParseControllerConfigString(SDL_GameController *gamecontroller, const char *pchString)
SDL_GameControllerBindType outputType
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_ExtendedGameControllerBind::@23 output
#define SDL_memset
int16_t Sint16
Definition: SDL_stdinc.h:163

◆ SDL_ShouldIgnoreGameController()

SDL_bool SDL_ShouldIgnoreGameController ( const char *  name,
SDL_JoystickGUID  guid 
)

Definition at line 1285 of file SDL_gamecontroller.c.

References SDL_vidpid_list::entries, i, MAKE_VIDPID, NULL, SDL_vidpid_list::num_entries, recDevice::product, SDL_FALSE, SDL_GetHintBoolean, SDL_GetJoystickGUIDInfo(), SDL_strncmp, and SDL_TRUE.

1286 {
1287  int i;
1288  Uint16 vendor;
1289  Uint16 product;
1290  Uint32 vidpid;
1291 
1294  return SDL_FALSE;
1295  }
1296 
1297  SDL_GetJoystickGUIDInfo(guid, &vendor, &product, NULL);
1298  vidpid = MAKE_VIDPID(vendor, product);
1299 
1300  if (SDL_GetHintBoolean("SDL_GAMECONTROLLER_ALLOW_STEAM_VIRTUAL_GAMEPAD", SDL_FALSE)) {
1301  /* We shouldn't ignore Steam's virtual gamepad since it's using the hints to filter out the real controllers so it can remap input for the virtual controller */
1302  SDL_bool bSteamVirtualGamepad = SDL_FALSE;
1303 #if defined(__LINUX__)
1304  bSteamVirtualGamepad = (vendor == 0x28DE && product == 0x11FF);
1305 #elif defined(__MACOSX__)
1306  bSteamVirtualGamepad = (SDL_strncmp(name, "GamePad-", 8) == 0);
1307 #elif defined(__WIN32__)
1308  /* We can't tell on Windows, but Steam will block others in input hooks */
1309  bSteamVirtualGamepad = SDL_TRUE;
1310 #endif
1311  if (bSteamVirtualGamepad) {
1312  return SDL_FALSE;
1313  }
1314  }
1315 
1317  for (i = 0; i < SDL_allowed_controllers.num_entries; ++i) {
1318  if (vidpid == SDL_allowed_controllers.entries[i]) {
1319  return SDL_FALSE;
1320  }
1321  }
1322  return SDL_TRUE;
1323  } else {
1324  for (i = 0; i < SDL_ignored_controllers.num_entries; ++i) {
1325  if (vidpid == SDL_ignored_controllers.entries[i]) {
1326  return SDL_TRUE;
1327  }
1328  }
1329  return SDL_FALSE;
1330  }
1331 }
#define MAKE_VIDPID(VID, PID)
static SDL_vidpid_list SDL_ignored_controllers
uint32_t Uint32
Definition: SDL_stdinc.h:181
#define SDL_strncmp
GLuint const GLchar * name
#define SDL_GetHintBoolean
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 NULL
Definition: begin_code.h:164
SDL_bool
Definition: SDL_stdinc.h:139
static SDL_vidpid_list SDL_allowed_controllers
void SDL_GetJoystickGUIDInfo(SDL_JoystickGUID guid, Uint16 *vendor, Uint16 *product, Uint16 *version)
Definition: SDL_joystick.c:933
uint16_t Uint16
Definition: SDL_stdinc.h:169

◆ UpdateEventsForDeviceRemoval()

static void UpdateEventsForDeviceRemoval ( )
static

Definition at line 196 of file SDL_gamecontroller.c.

References SDL_Event::cdevice, events, i, NULL, SDL_ADDEVENT, SDL_CONTROLLERDEVICEADDED, SDL_GETEVENT, SDL_PEEKEVENT, SDL_PeepEvents, SDL_stack_alloc, SDL_stack_free, and SDL_ControllerDeviceEvent::which.

Referenced by SDL_GameControllerEventWatcher().

197 {
198  int i, num_events;
199  SDL_Event *events;
200 
202  if (num_events <= 0) {
203  return;
204  }
205 
206  events = SDL_stack_alloc(SDL_Event, num_events);
207  if (!events) {
208  return;
209  }
210 
212  for (i = 0; i < num_events; ++i) {
213  --events[i].cdevice.which;
214  }
215  SDL_PeepEvents(events, num_events, SDL_ADDEVENT, 0, 0);
216 
217  SDL_stack_free(events);
218 }
SDL_ControllerDeviceEvent cdevice
Definition: SDL_events.h:543
static SDL_Event events[EVENT_BUF_SIZE]
Definition: testgesture.c:35
#define SDL_PeepEvents
#define SDL_stack_alloc(type, count)
Definition: SDL_stdinc.h:354
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 NULL
Definition: begin_code.h:164
General event structure.
Definition: SDL_events.h:525
#define SDL_stack_free(data)
Definition: SDL_stdinc.h:355

Variable Documentation

◆ map_StringForControllerAxis

const char* map_StringForControllerAxis[]
static
Initial value:
= {
"leftx",
"lefty",
"rightx",
"righty",
"lefttrigger",
"righttrigger",
}
#define NULL
Definition: begin_code.h:164

Definition at line 431 of file SDL_gamecontroller.c.

Referenced by SDL_GameControllerGetAxisFromString(), and SDL_GameControllerGetStringForAxis().

◆ map_StringForControllerButton

const char* map_StringForControllerButton[]
static
Initial value:
= {
"a",
"b",
"x",
"y",
"back",
"guide",
"start",
"leftstick",
"rightstick",
"leftshoulder",
"rightshoulder",
"dpup",
"dpdown",
"dpleft",
"dpright",
}
#define NULL
Definition: begin_code.h:164

Definition at line 474 of file SDL_gamecontroller.c.

Referenced by SDL_GameControllerGetButtonFromString(), and SDL_GameControllerGetStringForButton().

◆ s_pEmscriptenMapping

ControllerMapping_t* s_pEmscriptenMapping = NULL
static

Definition at line 101 of file SDL_gamecontroller.c.

Referenced by SDL_PrivateGetControllerMappingForNameAndGUID().

◆ s_pSupportedControllers

ControllerMapping_t* s_pSupportedControllers = NULL
static

◆ s_pXInputMapping

◆ s_zeroGUID

SDL_JoystickGUID s_zeroGUID
static

Definition at line 98 of file SDL_gamecontroller.c.

◆ SDL_allowed_controllers

SDL_vidpid_list SDL_allowed_controllers
static

Definition at line 127 of file SDL_gamecontroller.c.

◆ SDL_gamecontrollers

◆ SDL_ignored_controllers

SDL_vidpid_list SDL_ignored_controllers
static

Definition at line 128 of file SDL_gamecontroller.c.