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_timer.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_MINIMUM_GUIDE_BUTTON_DELAY_MS   250
 
#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_bool exact_match)
 
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, 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)
 
char * SDL_GameControllerMappingForDeviceIndex (int joystick_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)
 
int SDL_GameControllerGetPlayerIndex (SDL_GameController *gamecontroller)
 
Uint16 SDL_GameControllerGetVendor (SDL_GameController *gamecontroller)
 
Uint16 SDL_GameControllerGetProduct (SDL_GameController *gamecontroller)
 
Uint16 SDL_GameControllerGetProductVersion (SDL_GameController *gamecontroller)
 
SDL_bool SDL_GameControllerGetAttached (SDL_GameController *gamecontroller)
 
SDL_Joystick * SDL_GameControllerGetJoystick (SDL_GameController *gamecontroller)
 
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)
 
int SDL_GameControllerRumble (SDL_GameController *gamecontroller, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble, Uint32 duration_ms)
 
void SDL_GameControllerClose (SDL_GameController *gamecontroller)
 
void SDL_GameControllerQuit (void)
 
void SDL_GameControllerQuitMappings (void)
 
int SDL_GameControllerEventState (int state)
 
void SDL_GameControllerHandleDelayedGuideButton (SDL_Joystick *joystick)
 

Variables

static SDL_GameController * SDL_gamecontrollers = NULL
 
static SDL_JoystickGUID s_zeroGUID
 
static ControllerMapping_ts_pSupportedControllers = NULL
 
static ControllerMapping_ts_pDefaultMapping = NULL
 
static ControllerMapping_ts_pHIDAPIMapping = NULL
 
static ControllerMapping_ts_pXInputMapping = 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 45 of file SDL_gamecontroller.c.

Referenced by SDL_GameControllerAddMappingsFromRW().

◆ SDL_MINIMUM_GUIDE_BUTTON_DELAY_MS

#define SDL_MINIMUM_GUIDE_BUTTON_DELAY_MS   250

Definition at line 43 of file SDL_gamecontroller.c.

Referenced by SDL_PrivateGameControllerButton().

Enumeration Type Documentation

◆ SDL_ControllerMappingPriority

Enumerator
SDL_CONTROLLER_MAPPING_PRIORITY_DEFAULT 
SDL_CONTROLLER_MAPPING_PRIORITY_API 
SDL_CONTROLLER_MAPPING_PRIORITY_USER 

Definition at line 86 of file SDL_gamecontroller.c.

Function Documentation

◆ HandleJoystickAxis()

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

Definition at line 247 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().

248 {
249  int i;
250  SDL_ExtendedGameControllerBind *last_match = gamecontroller->last_match_axis[axis];
252 
253  for (i = 0; i < gamecontroller->num_bindings; ++i) {
254  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
255  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS &&
256  axis == binding->input.axis.axis) {
257  if (binding->input.axis.axis_min < binding->input.axis.axis_max) {
258  if (value >= binding->input.axis.axis_min &&
259  value <= binding->input.axis.axis_max) {
260  match = binding;
261  break;
262  }
263  } else {
264  if (value >= binding->input.axis.axis_max &&
265  value <= binding->input.axis.axis_min) {
266  match = binding;
267  break;
268  }
269  }
270  }
271  }
272 
273  if (last_match && (!match || !HasSameOutput(last_match, match))) {
274  /* Clear the last input that this axis generated */
275  ResetOutput(gamecontroller, last_match);
276  }
277 
278  if (match) {
280  if (match->input.axis.axis_min != match->output.axis.axis_min || match->input.axis.axis_max != match->output.axis.axis_max) {
281  float normalized_value = (float)(value - match->input.axis.axis_min) / (match->input.axis.axis_max - match->input.axis.axis_min);
282  value = match->output.axis.axis_min + (int)(normalized_value * (match->output.axis.axis_max - match->output.axis.axis_min));
283  }
284  SDL_PrivateGameControllerAxis(gamecontroller, match->output.axis.axis, (Sint16)value);
285  } else {
286  Uint8 state;
287  int threshold = match->input.axis.axis_min + (match->input.axis.axis_max - match->input.axis.axis_min) / 2;
288  if (match->input.axis.axis_max < match->input.axis.axis_min) {
289  state = (value <= threshold) ? SDL_PRESSED : SDL_RELEASED;
290  } else {
291  state = (value >= threshold) ? SDL_PRESSED : SDL_RELEASED;
292  }
293  SDL_PrivateGameControllerButton(gamecontroller, match->output.button, state);
294  }
295  }
296  gamecontroller->last_match_axis[axis] = match;
297 }
union SDL_ExtendedGameControllerBind::@24 output
static void ResetOutput(SDL_GameController *gamecontroller, SDL_ExtendedGameControllerBind *bind)
struct xkb_state * state
SDL_GameControllerBindType inputType
SDL_Texture * axis
union SDL_ExtendedGameControllerBind::@23 input
GLenum GLenum GLenum input
uint8_t Uint8
Definition: SDL_stdinc.h:179
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
#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:185

◆ HandleJoystickButton()

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

Definition at line 299 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().

300 {
301  int i;
302 
303  for (i = 0; i < gamecontroller->num_bindings; ++i) {
304  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
305  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON &&
306  button == binding->input.button) {
307  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
308  int value = state ? binding->output.axis.axis_max : binding->output.axis.axis_min;
309  SDL_PrivateGameControllerAxis(gamecontroller, binding->output.axis.axis, (Sint16)value);
310  } else {
311  SDL_PrivateGameControllerButton(gamecontroller, binding->output.button, state);
312  }
313  break;
314  }
315  }
316 }
union SDL_ExtendedGameControllerBind::@24 output
SDL_Texture * button
struct xkb_state * state
SDL_GameControllerBindType inputType
union SDL_ExtendedGameControllerBind::@23 input
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
static int SDL_PrivateGameControllerAxis(SDL_GameController *gamecontroller, SDL_GameControllerAxis axis, Sint16 value)
int16_t Sint16
Definition: SDL_stdinc.h:185

◆ HandleJoystickHat()

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

Definition at line 318 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().

319 {
320  int i;
321  Uint8 last_mask = gamecontroller->last_hat_mask[hat];
322  Uint8 changed_mask = (last_mask ^ value);
323 
324  for (i = 0; i < gamecontroller->num_bindings; ++i) {
325  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
326  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT && hat == binding->input.hat.hat) {
327  if ((changed_mask & binding->input.hat.hat_mask) != 0) {
328  if (value & binding->input.hat.hat_mask) {
329  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
330  SDL_PrivateGameControllerAxis(gamecontroller, binding->output.axis.axis, (Sint16)binding->output.axis.axis_max);
331  } else {
332  SDL_PrivateGameControllerButton(gamecontroller, binding->output.button, SDL_PRESSED);
333  }
334  } else {
335  ResetOutput(gamecontroller, binding);
336  }
337  }
338  }
339  }
340  gamecontroller->last_hat_mask[hat] = value;
341 }
union SDL_ExtendedGameControllerBind::@24 output
static void ResetOutput(SDL_GameController *gamecontroller, SDL_ExtendedGameControllerBind *bind)
SDL_GameControllerBindType inputType
union SDL_ExtendedGameControllerBind::@23 input
uint8_t Uint8
Definition: SDL_stdinc.h:179
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
static int SDL_PrivateGameControllerAxis(SDL_GameController *gamecontroller, SDL_GameControllerAxis axis, Sint16 value)
int16_t Sint16
Definition: SDL_stdinc.h:185

◆ HasSameOutput()

◆ ResetOutput()

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

Definition at line 238 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().

239 {
241  SDL_PrivateGameControllerAxis(gamecontroller, bind->output.axis.axis, 0);
242  } else {
244  }
245 }
union SDL_ExtendedGameControllerBind::@24 output
SDL_GameControllerBindType outputType
static int SDL_PrivateGameControllerButton(SDL_GameController *gamecontroller, SDL_GameControllerButton button, Uint8 state)
#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 1186 of file SDL_gamecontroller.c.

References SDL_CONTROLLER_MAPPING_PRIORITY_API, and SDL_PrivateGameControllerAddMapping().

Referenced by SDL_GameControllerAddMappingsFromRW().

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

◆ SDL_GameControllerAddMappingsFromRW()

int SDL_GameControllerAddMappingsFromRW ( SDL_RWops rw,
int  freerw 
)

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

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

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

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

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

Returns
number of mappings added, -1 on error

Definition at line 1064 of file SDL_gamecontroller.c.

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

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

◆ SDL_GameControllerClose()

void SDL_GameControllerClose ( SDL_GameController *  gamecontroller)

Close a controller previously opened with SDL_GameControllerOpen().

Definition at line 1860 of file SDL_gamecontroller.c.

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

Referenced by SDL_GameControllerQuit().

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

◆ SDL_GameControllerEventState()

int SDL_GameControllerEventState ( int  state)

Enable/disable controller event polling.

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

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

Definition at line 2031 of file SDL_gamecontroller.c.

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

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

◆ SDL_GameControllerEventWatcher()

static int SDL_GameControllerEventWatcher ( void userdata,
SDL_Event event 
)
static

Definition at line 346 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().

347 {
348  switch(event->type) {
349  case SDL_JOYAXISMOTION:
350  {
351  SDL_GameController *controllerlist = SDL_gamecontrollers;
352  while (controllerlist) {
353  if (controllerlist->joystick->instance_id == event->jaxis.which) {
354  HandleJoystickAxis(controllerlist, event->jaxis.axis, event->jaxis.value);
355  break;
356  }
357  controllerlist = controllerlist->next;
358  }
359  }
360  break;
361  case SDL_JOYBUTTONDOWN:
362  case SDL_JOYBUTTONUP:
363  {
364  SDL_GameController *controllerlist = SDL_gamecontrollers;
365  while (controllerlist) {
366  if (controllerlist->joystick->instance_id == event->jbutton.which) {
367  HandleJoystickButton(controllerlist, event->jbutton.button, event->jbutton.state);
368  break;
369  }
370  controllerlist = controllerlist->next;
371  }
372  }
373  break;
374  case SDL_JOYHATMOTION:
375  {
376  SDL_GameController *controllerlist = SDL_gamecontrollers;
377  while (controllerlist) {
378  if (controllerlist->joystick->instance_id == event->jhat.which) {
379  HandleJoystickHat(controllerlist, event->jhat.hat, event->jhat.value);
380  break;
381  }
382  controllerlist = controllerlist->next;
383  }
384  }
385  break;
386  case SDL_JOYDEVICEADDED:
387  {
388  if (SDL_IsGameController(event->jdevice.which)) {
389  SDL_Event deviceevent;
390  deviceevent.type = SDL_CONTROLLERDEVICEADDED;
391  deviceevent.cdevice.which = event->jdevice.which;
392  SDL_PushEvent(&deviceevent);
393  }
394  }
395  break;
397  {
398  SDL_GameController *controllerlist = SDL_gamecontrollers;
399  while (controllerlist) {
400  if (controllerlist->joystick->instance_id == event->jdevice.which) {
401  SDL_Event deviceevent;
402 
403  deviceevent.type = SDL_CONTROLLERDEVICEREMOVED;
404  deviceevent.cdevice.which = event->jdevice.which;
405  SDL_PushEvent(&deviceevent);
406 
408  break;
409  }
410  controllerlist = controllerlist->next;
411  }
412  }
413  break;
414  default:
415  break;
416  }
417 
418  return 1;
419 }
SDL_JoystickID which
Definition: SDL_events.h:356
SDL_JoyDeviceEvent jdevice
Definition: SDL_events.h:573
static void HandleJoystickHat(SDL_GameController *gamecontroller, int hat, Uint8 value)
SDL_ControllerDeviceEvent cdevice
Definition: SDL_events.h:576
SDL_JoyButtonEvent jbutton
Definition: SDL_events.h:572
static void UpdateEventsForDeviceRemoval()
SDL_JoystickID which
Definition: SDL_events.h:304
static SDL_GameController * SDL_gamecontrollers
SDL_JoyAxisEvent jaxis
Definition: SDL_events.h:569
#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:557
SDL_JoyHatEvent jhat
Definition: SDL_events.h:571
SDL_JoystickID which
Definition: SDL_events.h:336
static void HandleJoystickAxis(SDL_GameController *gamecontroller, int axis, int value)
Uint32 type
Definition: SDL_events.h:559

◆ SDL_GameControllerFromInstanceID()

SDL_GameController* SDL_GameControllerFromInstanceID ( SDL_JoystickID  joyid)

Return the SDL_GameController associated with an instance id.

Definition at line 1772 of file SDL_gamecontroller.c.

References NULL, SDL_gamecontrollers, SDL_LockJoysticks, and SDL_UnlockJoysticks.

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

◆ SDL_GameControllerGetAttached()

SDL_bool SDL_GameControllerGetAttached ( SDL_GameController *  gamecontroller)

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

Definition at line 1748 of file SDL_gamecontroller.c.

References SDL_FALSE, and SDL_JoystickGetAttached.

1749 {
1750  if (!gamecontroller)
1751  return SDL_FALSE;
1752 
1753  return SDL_JoystickGetAttached(gamecontroller->joystick);
1754 }
#define SDL_JoystickGetAttached

◆ SDL_GameControllerGetAxis()

Sint16 SDL_GameControllerGetAxis ( SDL_GameController *  gamecontroller,
SDL_GameControllerAxis  axis 
)

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

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

The axis indices start at index 0.

Definition at line 1612 of file SDL_gamecontroller.c.

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

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

◆ SDL_GameControllerGetAxisFromString()

SDL_GameControllerAxis SDL_GameControllerGetAxisFromString ( const char *  pchString)

turn this string into a axis mapping

Definition at line 461 of file SDL_gamecontroller.c.

References map_StringForControllerAxis, SDL_CONTROLLER_AXIS_INVALID, and SDL_strcasecmp.

Referenced by SDL_PrivateGameControllerParseElement().

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

◆ SDL_GameControllerGetBindForAxis()

SDL_GameControllerButtonBind SDL_GameControllerGetBindForAxis ( SDL_GameController *  gamecontroller,
SDL_GameControllerAxis  axis 
)

Get the SDL joystick layer binding for this controller button mapping

Definition at line 1793 of file SDL_gamecontroller.c.

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

1794 {
1795  int i;
1797  SDL_zero(bind);
1798 
1799  if (!gamecontroller || axis == SDL_CONTROLLER_AXIS_INVALID)
1800  return bind;
1801 
1802  for (i = 0; i < gamecontroller->num_bindings; ++i) {
1803  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1804  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_AXIS && binding->output.axis.axis == axis) {
1805  bind.bindType = binding->inputType;
1806  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1807  /* FIXME: There might be multiple axes bound now that we have axis ranges... */
1808  bind.value.axis = binding->input.axis.axis;
1809  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1810  bind.value.button = binding->input.button;
1811  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1812  bind.value.hat.hat = binding->input.hat.hat;
1813  bind.value.hat.hat_mask = binding->input.hat.hat_mask;
1814  }
1815  break;
1816  }
1817  }
1818  return bind;
1819 }
union SDL_ExtendedGameControllerBind::@24 output
SDL_GameControllerBindType inputType
SDL_Texture * axis
union SDL_ExtendedGameControllerBind::@23 input
SDL_GameControllerBindType bindType
SDL_GameControllerBindType outputType
#define SDL_zero(x)
Definition: SDL_stdinc.h:416
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
union SDL_GameControllerButtonBind::@0 value

◆ SDL_GameControllerGetBindForButton()

SDL_GameControllerButtonBind SDL_GameControllerGetBindForButton ( SDL_GameController *  gamecontroller,
SDL_GameControllerButton  button 
)

Get the SDL joystick layer binding for this controller button mapping

Definition at line 1825 of file SDL_gamecontroller.c.

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

1826 {
1827  int i;
1829  SDL_zero(bind);
1830 
1831  if (!gamecontroller || button == SDL_CONTROLLER_BUTTON_INVALID)
1832  return bind;
1833 
1834  for (i = 0; i < gamecontroller->num_bindings; ++i) {
1835  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
1836  if (binding->outputType == SDL_CONTROLLER_BINDTYPE_BUTTON && binding->output.button == button) {
1837  bind.bindType = binding->inputType;
1838  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) {
1839  bind.value.axis = binding->input.axis.axis;
1840  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) {
1841  bind.value.button = binding->input.button;
1842  } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) {
1843  bind.value.hat.hat = binding->input.hat.hat;
1844  bind.value.hat.hat_mask = binding->input.hat.hat_mask;
1845  }
1846  break;
1847  }
1848  }
1849  return bind;
1850 }
union SDL_ExtendedGameControllerBind::@24 output
SDL_Texture * button
SDL_GameControllerBindType inputType
union SDL_ExtendedGameControllerBind::@23 input
SDL_GameControllerBindType bindType
SDL_GameControllerBindType outputType
#define SDL_zero(x)
Definition: SDL_stdinc.h:416
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
union SDL_GameControllerButtonBind::@0 value

◆ SDL_GameControllerGetButton()

Uint8 SDL_GameControllerGetButton ( SDL_GameController *  gamecontroller,
SDL_GameControllerButton  button 
)

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

The button indices start at index 0.

Definition at line 1669 of file SDL_gamecontroller.c.

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

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

◆ SDL_GameControllerGetButtonFromString()

SDL_GameControllerButton SDL_GameControllerGetButtonFromString ( const char *  pchString)

turn this string into a button mapping

Definition at line 513 of file SDL_gamecontroller.c.

References map_StringForControllerButton, SDL_CONTROLLER_BUTTON_INVALID, and SDL_strcasecmp.

Referenced by SDL_PrivateGameControllerParseElement().

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

◆ SDL_GameControllerGetJoystick()

SDL_Joystick* SDL_GameControllerGetJoystick ( SDL_GameController *  gamecontroller)

Get the underlying joystick object used by a controller

Definition at line 1759 of file SDL_gamecontroller.c.

References NULL.

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

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

◆ SDL_GameControllerGetPlayerIndex()

int SDL_GameControllerGetPlayerIndex ( SDL_GameController *  gamecontroller)

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

For XInput controllers this returns the XInput user index.

Definition at line 1720 of file SDL_gamecontroller.c.

References SDL_GameControllerGetJoystick(), and SDL_JoystickGetPlayerIndex.

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

◆ SDL_GameControllerGetProduct()

Uint16 SDL_GameControllerGetProduct ( SDL_GameController *  gamecontroller)

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

Definition at line 1732 of file SDL_gamecontroller.c.

References SDL_GameControllerGetJoystick(), and SDL_JoystickGetProduct.

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

◆ SDL_GameControllerGetProductVersion()

Uint16 SDL_GameControllerGetProductVersion ( SDL_GameController *  gamecontroller)

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

Definition at line 1738 of file SDL_gamecontroller.c.

References SDL_GameControllerGetJoystick(), and SDL_JoystickGetProductVersion.

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

◆ SDL_GameControllerGetStringForAxis()

const char* SDL_GameControllerGetStringForAxis ( SDL_GameControllerAxis  axis)

turn this axis enum into a string mapping

Definition at line 483 of file SDL_gamecontroller.c.

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

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

◆ SDL_GameControllerGetStringForButton()

const char* SDL_GameControllerGetStringForButton ( SDL_GameControllerButton  button)

turn this button enum into a string mapping

Definition at line 529 of file SDL_gamecontroller.c.

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

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

◆ SDL_GameControllerGetVendor()

Uint16 SDL_GameControllerGetVendor ( SDL_GameController *  gamecontroller)

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

Definition at line 1726 of file SDL_gamecontroller.c.

References SDL_GameControllerGetJoystick(), and SDL_JoystickGetVendor.

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

◆ SDL_GameControllerHandleDelayedGuideButton()

void SDL_GameControllerHandleDelayedGuideButton ( SDL_Joystick *  joystick)

Definition at line 2063 of file SDL_gamecontroller.c.

References SDL_CONTROLLER_BUTTON_GUIDE, SDL_gamecontrollers, SDL_PrivateGameControllerButton(), and SDL_RELEASED.

Referenced by SDL_JoystickUpdate().

2064 {
2065  SDL_GameController *controllerlist = SDL_gamecontrollers;
2066  while (controllerlist) {
2067  if (controllerlist->joystick == joystick) {
2069  break;
2070  }
2071  controllerlist = controllerlist->next;
2072  }
2073 }
static SDL_GameController * SDL_gamecontrollers
static int SDL_PrivateGameControllerButton(SDL_GameController *gamecontroller, SDL_GameControllerButton button, Uint8 state)
#define SDL_RELEASED
Definition: SDL_events.h:49

◆ SDL_GameControllerIgnoreDevicesChanged()

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

Definition at line 182 of file SDL_gamecontroller.c.

References SDL_LoadVIDPIDListFromHint(), and SDLCALL.

Referenced by SDL_GameControllerInitMappings(), and SDL_GameControllerQuitMappings().

183 {
185 }
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 188 of file SDL_gamecontroller.c.

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

Referenced by SDL_GameControllerInitMappings(), and SDL_GameControllerQuitMappings().

189 {
191 }
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 1358 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().

1359 {
1360  int i;
1361 
1362  /* watch for joy events and fire controller ones if needed */
1364 
1365  /* Send added events for controllers currently attached */
1366  for (i = 0; i < SDL_NumJoysticks(); ++i) {
1367  if (SDL_IsGameController(i)) {
1368  SDL_Event deviceevent;
1369  deviceevent.type = SDL_CONTROLLERDEVICEADDED;
1370  deviceevent.cdevice.which = i;
1371  SDL_PushEvent(&deviceevent);
1372  }
1373  }
1374 
1375  return (0);
1376 }
static int SDL_GameControllerEventWatcher(void *userdata, SDL_Event *event)
SDL_ControllerDeviceEvent cdevice
Definition: SDL_events.h:576
#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:557
Uint32 type
Definition: SDL_events.h:559

◆ SDL_GameControllerInitMappings()

int SDL_GameControllerInitMappings ( void  )

Definition at line 1329 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().

1330 {
1331  char szControllerMapPath[1024];
1332  int i = 0;
1333  const char *pMappingString = NULL;
1334  pMappingString = s_ControllerMappings[i];
1335  while (pMappingString) {
1337 
1338  i++;
1339  pMappingString = s_ControllerMappings[i];
1340  }
1341 
1342  if (SDL_GetControllerMappingFilePath(szControllerMapPath, sizeof(szControllerMapPath))) {
1343  SDL_GameControllerAddMappingsFromFile(szControllerMapPath);
1344  }
1345 
1346  /* load in any user supplied config */
1348 
1353 
1354  return (0);
1355 }
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:463
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:450
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 1280 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().

1281 {
1282  const char *hint = SDL_GetHint(SDL_HINT_GAMECONTROLLERCONFIG);
1283  if (hint && hint[0]) {
1284  size_t nchHints = SDL_strlen(hint);
1285  char *pUserMappings = SDL_malloc(nchHints + 1);
1286  char *pTempMappings = pUserMappings;
1287  SDL_memcpy(pUserMappings, hint, nchHints);
1288  pUserMappings[nchHints] = '\0';
1289  while (pUserMappings) {
1290  char *pchNewLine = NULL;
1291 
1292  pchNewLine = SDL_strchr(pUserMappings, '\n');
1293  if (pchNewLine)
1294  *pchNewLine = '\0';
1295 
1297 
1298  if (pchNewLine) {
1299  pUserMappings = pchNewLine + 1;
1300  } else {
1301  pUserMappings = NULL;
1302  }
1303  }
1304  SDL_free(pTempMappings);
1305  }
1306 }
#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:437
#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 1270 of file SDL_gamecontroller.c.

References NULL, and SDL_GameControllerMappingForGUID().

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

◆ SDL_GameControllerMappingForDeviceIndex()

char* SDL_GameControllerMappingForDeviceIndex ( int  joystick_index)

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

Definition at line 1403 of file SDL_gamecontroller.c.

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

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

◆ SDL_GameControllerMappingForGUID()

char* SDL_GameControllerMappingForGUID ( SDL_JoystickGUID  guid)

Get a mapping string for a GUID

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

Definition at line 1246 of file SDL_gamecontroller.c.

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

Referenced by SDL_GameControllerMapping().

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

◆ SDL_GameControllerMappingForIndex()

char* SDL_GameControllerMappingForIndex ( int  mapping_index)

Get the mapping at a particular index.

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

Definition at line 1213 of file SDL_gamecontroller.c.

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

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

◆ SDL_GameControllerName()

const char* SDL_GameControllerName ( SDL_GameController *  gamecontroller)

Return the name for this currently opened controller

Definition at line 1707 of file SDL_gamecontroller.c.

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

1708 {
1709  if (!gamecontroller)
1710  return NULL;
1711 
1712  if (SDL_strcmp(gamecontroller->name, "*") == 0) {
1713  return SDL_JoystickName(SDL_GameControllerGetJoystick(gamecontroller));
1714  } else {
1715  return gamecontroller->name;
1716  }
1717 }
#define SDL_JoystickName
#define NULL
Definition: begin_code.h:164
SDL_Joystick * SDL_GameControllerGetJoystick(SDL_GameController *gamecontroller)
#define SDL_strcmp

◆ SDL_GameControllerNameForIndex()

const char* SDL_GameControllerNameForIndex ( int  joystick_index)

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

Definition at line 1383 of file SDL_gamecontroller.c.

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

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

◆ SDL_GameControllerNumMappings()

int SDL_GameControllerNumMappings ( void  )

Get the number of mappings installed

Returns
the number of mappings

Definition at line 1195 of file SDL_gamecontroller.c.

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

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

◆ SDL_GameControllerOpen()

SDL_GameController* SDL_GameControllerOpen ( int  joystick_index)

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

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

Definition at line 1518 of file SDL_gamecontroller.c.

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

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

◆ SDL_GameControllerQuit()

void SDL_GameControllerQuit ( void  )

Definition at line 1906 of file SDL_gamecontroller.c.

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

Referenced by SDL_QuitSubSystem().

1907 {
1909  while (SDL_gamecontrollers) {
1910  SDL_gamecontrollers->ref_count = 1;
1912  }
1914 }
#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 1917 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().

1918 {
1919  ControllerMapping_t *pControllerMap;
1920 
1921  while (s_pSupportedControllers) {
1922  pControllerMap = s_pSupportedControllers;
1924  SDL_free(pControllerMap->name);
1925  SDL_free(pControllerMap->mapping);
1926  SDL_free(pControllerMap);
1927  }
1928 
1930 
1935 
1939  }
1943  }
1944 }
#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:463
#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:450
static void SDL_GameControllerIgnoreDevicesChanged(void *userdata, const char *name, const char *oldValue, const char *hint)

◆ SDL_GameControllerRumble()

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

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

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

Definition at line 1854 of file SDL_gamecontroller.c.

References SDL_GameControllerGetJoystick(), and SDL_JoystickRumble.

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

◆ SDL_GameControllerUpdate()

void SDL_GameControllerUpdate ( void  )

Update the current state of the open game controllers.

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

Definition at line 1602 of file SDL_gamecontroller.c.

References SDL_JoystickUpdate.

1603 {
1604  /* Just for API completeness; the joystick API does all the work. */
1606 }
#define SDL_JoystickUpdate

◆ SDL_GetControllerMappingFilePath()

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

Definition at line 1313 of file SDL_gamecontroller.c.

References SDL_AndroidGetInternalStoragePath, SDL_FALSE, SDL_snprintf, and SDL_strlcpy.

Referenced by SDL_GameControllerInitMappings().

1314 {
1315 #ifdef CONTROLLER_MAPPING_FILE
1316 #define STRING(X) SDL_STRINGIFY_ARG(X)
1317  return SDL_strlcpy(path, STRING(CONTROLLER_MAPPING_FILE), size) < size;
1318 #elif defined(__ANDROID__)
1319  return SDL_snprintf(path, size, "%s/controller_map.txt", SDL_AndroidGetInternalStoragePath()) < size;
1320 #else
1321  return SDL_FALSE;
1322 #endif
1323 }
#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 1448 of file SDL_gamecontroller.c.

References SDL_FALSE, SDL_PrivateGetControllerMapping(), and SDL_TRUE.

Referenced by SDL_GameControllerEventWatcher(), and SDL_GameControllerInit().

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

◆ SDL_IsGameControllerNameAndGUID()

SDL_bool SDL_IsGameControllerNameAndGUID ( const char *  name,
SDL_JoystickGUID  guid 
)

Definition at line 1435 of file SDL_gamecontroller.c.

References SDL_FALSE, SDL_PrivateGetControllerMappingForNameAndGUID(), and SDL_TRUE.

Referenced by SDL_ShouldIgnoreJoystick().

1436 {
1438  if (pSupportedController) {
1439  return SDL_TRUE;
1440  }
1441  return SDL_FALSE;
1442 }
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 136 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().

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

References SDL_JoystickGUID::data, ControllerMapping_t::guid, ControllerMapping_t::mapping, ControllerMapping_t::name, ControllerMapping_t::next, NULL, ControllerMapping_t::priority, SDL_CONTROLLER_AXIS_LEFTX, SDL_CONTROLLER_AXIS_LEFTY, SDL_CONTROLLER_AXIS_RIGHTX, SDL_CONTROLLER_AXIS_RIGHTY, SDL_CONTROLLER_AXIS_TRIGGERLEFT, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, SDL_CONTROLLER_BUTTON_A, SDL_CONTROLLER_BUTTON_B, SDL_CONTROLLER_BUTTON_BACK, SDL_CONTROLLER_BUTTON_DPAD_DOWN, SDL_CONTROLLER_BUTTON_DPAD_LEFT, SDL_CONTROLLER_BUTTON_DPAD_RIGHT, SDL_CONTROLLER_BUTTON_DPAD_UP, SDL_CONTROLLER_BUTTON_GUIDE, SDL_CONTROLLER_BUTTON_LEFTSHOULDER, SDL_CONTROLLER_BUTTON_LEFTSTICK, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER, SDL_CONTROLLER_BUTTON_RIGHTSTICK, SDL_CONTROLLER_BUTTON_START, SDL_CONTROLLER_BUTTON_X, SDL_CONTROLLER_BUTTON_Y, SDL_CONTROLLER_MAPPING_PRIORITY_DEFAULT, SDL_FALSE, SDL_free, SDL_malloc, SDL_OutOfMemory, SDL_PrivateGameControllerRefreshMapping(), SDL_PrivateGetControllerMappingForGUID(), SDL_PrivateGetControllerMappingFromMappingString(), SDL_PrivateGetControllerNameFromMappingString(), SDL_SetError, SDL_snprintf, SDL_strlcat, SDL_strlcpy, SDL_SwapLE16, and SDL_TRUE.

Referenced by SDL_PrivateGameControllerAddMapping(), and SDL_PrivateGetControllerMappingForNameAndGUID().

823 {
824  char *pchName;
825  char *pchMapping;
826  ControllerMapping_t *pControllerMapping;
827 
828  pchName = SDL_PrivateGetControllerNameFromMappingString(mappingString);
829  if (!pchName) {
830  SDL_SetError("Couldn't parse name from %s", mappingString);
831  return NULL;
832  }
833 
834  pchMapping = SDL_PrivateGetControllerMappingFromMappingString(mappingString);
835  if (!pchMapping) {
836  SDL_free(pchName);
837  SDL_SetError("Couldn't parse %s", mappingString);
838  return NULL;
839  }
840 
841  pControllerMapping = SDL_PrivateGetControllerMappingForGUID(&jGUID, SDL_TRUE);
842  if (pControllerMapping) {
843  /* Only overwrite the mapping if the priority is the same or higher. */
844  if (pControllerMapping->priority <= priority) {
845  /* Update existing mapping */
846  SDL_free(pControllerMapping->name);
847  pControllerMapping->name = pchName;
848  SDL_free(pControllerMapping->mapping);
849  pControllerMapping->mapping = pchMapping;
850  pControllerMapping->priority = priority;
851  /* refresh open controllers */
852  SDL_PrivateGameControllerRefreshMapping(pControllerMapping);
853  } else {
854  SDL_free(pchName);
855  SDL_free(pchMapping);
856  }
857  *existing = SDL_TRUE;
858  } else {
859  pControllerMapping = SDL_malloc(sizeof(*pControllerMapping));
860  if (!pControllerMapping) {
861  SDL_free(pchName);
862  SDL_free(pchMapping);
863  SDL_OutOfMemory();
864  return NULL;
865  }
866  pControllerMapping->guid = jGUID;
867  pControllerMapping->name = pchName;
868  pControllerMapping->mapping = pchMapping;
869  pControllerMapping->next = NULL;
870  pControllerMapping->priority = priority;
871 
873  /* Add the mapping to the end of the list */
874  ControllerMapping_t *pCurrMapping, *pPrevMapping;
875 
876  for ( pPrevMapping = s_pSupportedControllers, pCurrMapping = pPrevMapping->next;
877  pCurrMapping;
878  pPrevMapping = pCurrMapping, pCurrMapping = pCurrMapping->next ) {
879  continue;
880  }
881  pPrevMapping->next = pControllerMapping;
882  } else {
883  s_pSupportedControllers = pControllerMapping;
884  }
885  *existing = SDL_FALSE;
886  }
887  return pControllerMapping;
888 }
SDL_ControllerMappingPriority priority
struct _ControllerMapping_t * next
SDL_JoystickGUID guid
static ControllerMapping_t * s_pSupportedControllers
#define SDL_free
static ControllerMapping_t * SDL_PrivateGetControllerMappingForGUID(SDL_JoystickGUID *guid, SDL_bool exact_match)
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 1135 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().

1136 {
1137  char *pchGUID;
1138  SDL_JoystickGUID jGUID;
1139  SDL_bool is_default_mapping = SDL_FALSE;
1140  SDL_bool is_hidapi_mapping = SDL_FALSE;
1141  SDL_bool is_xinput_mapping = SDL_FALSE;
1142  SDL_bool existing = SDL_FALSE;
1143  ControllerMapping_t *pControllerMapping;
1144 
1145  if (!mappingString) {
1146  return SDL_InvalidParamError("mappingString");
1147  }
1148 
1149  pchGUID = SDL_PrivateGetControllerGUIDFromMappingString(mappingString);
1150  if (!pchGUID) {
1151  return SDL_SetError("Couldn't parse GUID from %s", mappingString);
1152  }
1153  if (!SDL_strcasecmp(pchGUID, "default")) {
1154  is_default_mapping = SDL_TRUE;
1155  } else if (!SDL_strcasecmp(pchGUID, "hidapi")) {
1156  is_hidapi_mapping = SDL_TRUE;
1157  } else if (!SDL_strcasecmp(pchGUID, "xinput")) {
1158  is_xinput_mapping = SDL_TRUE;
1159  }
1160  jGUID = SDL_JoystickGetGUIDFromString(pchGUID);
1161  SDL_free(pchGUID);
1162 
1163  pControllerMapping = SDL_PrivateAddMappingForGUID(jGUID, mappingString, &existing, priority);
1164  if (!pControllerMapping) {
1165  return -1;
1166  }
1167 
1168  if (existing) {
1169  return 0;
1170  } else {
1171  if (is_default_mapping) {
1172  s_pDefaultMapping = pControllerMapping;
1173  } else if (is_hidapi_mapping) {
1174  s_pHIDAPIMapping = pControllerMapping;
1175  } else if (is_xinput_mapping) {
1176  s_pXInputMapping = pControllerMapping;
1177  }
1178  return 1;
1179  }
1180 }
static ControllerMapping_t * s_pDefaultMapping
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
#define SDL_strcasecmp
#define SDL_free
static ControllerMapping_t * s_pHIDAPIMapping
static char * SDL_PrivateGetControllerGUIDFromMappingString(const char *pMapping)
SDL_bool
Definition: SDL_stdinc.h:161
#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 1950 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().

1951 {
1952  int posted;
1953 
1954  /* translate the event, if desired */
1955  posted = 0;
1956 #if !SDL_EVENTS_DISABLED
1958  SDL_Event event;
1959  event.type = SDL_CONTROLLERAXISMOTION;
1960  event.caxis.which = gamecontroller->joystick->instance_id;
1961  event.caxis.axis = axis;
1962  event.caxis.value = value;
1963  posted = SDL_PushEvent(&event) == 1;
1964  }
1965 #endif /* !SDL_EVENTS_DISABLED */
1966  return (posted);
1967 }
#define SDL_ENABLE
Definition: SDL_events.h:756
SDL_Texture * axis
#define SDL_GetEventState(type)
Definition: SDL_events.h:769
struct _cl_event * event
#define SDL_PushEvent
GLsizei const GLfloat * value
General event structure.
Definition: SDL_events.h:557

◆ SDL_PrivateGameControllerButton()

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

Definition at line 1974 of file SDL_gamecontroller.c.

References button, SDL_CONTROLLER_BUTTON_GUIDE, SDL_CONTROLLER_BUTTON_INVALID, SDL_CONTROLLERBUTTONDOWN, SDL_CONTROLLERBUTTONUP, SDL_ENABLE, SDL_FALSE, SDL_GetEventState, SDL_GetTicks(), SDL_MINIMUM_GUIDE_BUTTON_DELAY_MS, SDL_PRESSED, SDL_PushEvent, SDL_RELEASED, SDL_TICKS_PASSED, SDL_TRUE, state, and SDL_Event::type.

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

1975 {
1976  int posted;
1977 #if !SDL_EVENTS_DISABLED
1978  SDL_Event event;
1979 
1981  return (0);
1982 
1983  switch (state) {
1984  case SDL_PRESSED:
1985  event.type = SDL_CONTROLLERBUTTONDOWN;
1986  break;
1987  case SDL_RELEASED:
1988  event.type = SDL_CONTROLLERBUTTONUP;
1989  break;
1990  default:
1991  /* Invalid state -- bail */
1992  return (0);
1993  }
1994 #endif /* !SDL_EVENTS_DISABLED */
1995 
1997  Uint32 now = SDL_GetTicks();
1998  if (state == SDL_PRESSED) {
1999  gamecontroller->guide_button_down = now;
2000 
2001  if (gamecontroller->joystick->delayed_guide_button) {
2002  /* Skip duplicate press */
2003  return (0);
2004  }
2005  } else {
2006  if (!SDL_TICKS_PASSED(now, gamecontroller->guide_button_down+SDL_MINIMUM_GUIDE_BUTTON_DELAY_MS) && !gamecontroller->joystick->force_recentering) {
2007  gamecontroller->joystick->delayed_guide_button = SDL_TRUE;
2008  return (0);
2009  }
2010  gamecontroller->joystick->delayed_guide_button = SDL_FALSE;
2011  }
2012  }
2013 
2014  /* translate the event, if desired */
2015  posted = 0;
2016 #if !SDL_EVENTS_DISABLED
2017  if (SDL_GetEventState(event.type) == SDL_ENABLE) {
2018  event.cbutton.which = gamecontroller->joystick->instance_id;
2019  event.cbutton.button = button;
2020  event.cbutton.state = state;
2021  posted = SDL_PushEvent(&event) == 1;
2022  }
2023 #endif /* !SDL_EVENTS_DISABLED */
2024  return (posted);
2025 }
SDL_Texture * button
struct xkb_state * state
#define SDL_ENABLE
Definition: SDL_events.h:756
#define SDL_GetEventState(type)
Definition: SDL_events.h:769
Uint32 SDL_GetTicks(void)
Get the number of milliseconds since the SDL library initialization.
struct _cl_event * event
#define SDL_PushEvent
uint32_t Uint32
Definition: SDL_stdinc.h:203
General event structure.
Definition: SDL_events.h:557
#define SDL_MINIMUM_GUIDE_BUTTON_DELAY_MS
#define SDL_PRESSED
Definition: SDL_events.h:50
#define SDL_TICKS_PASSED(A, B)
Compare SDL ticks values, and return true if A has passed B.
Definition: SDL_timer.h:56
#define SDL_RELEASED
Definition: SDL_events.h:49
Uint32 type
Definition: SDL_events.h:559

◆ SDL_PrivateGameControllerParseControllerConfigString()

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

Definition at line 636 of file SDL_gamecontroller.c.

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

Referenced by SDL_PrivateLoadButtonMapping().

637 {
638  char szGameButton[20];
639  char szJoystickButton[20];
640  SDL_bool bGameButton = SDL_TRUE;
641  int i = 0;
642  const char *pchPos = pchString;
643 
644  SDL_zero(szGameButton);
645  SDL_zero(szJoystickButton);
646 
647  while (pchPos && *pchPos) {
648  if (*pchPos == ':') {
649  i = 0;
650  bGameButton = SDL_FALSE;
651  } else if (*pchPos == ' ') {
652 
653  } else if (*pchPos == ',') {
654  i = 0;
655  bGameButton = SDL_TRUE;
656  SDL_PrivateGameControllerParseElement(gamecontroller, szGameButton, szJoystickButton);
657  SDL_zero(szGameButton);
658  SDL_zero(szJoystickButton);
659 
660  } else if (bGameButton) {
661  if (i >= sizeof(szGameButton)) {
662  SDL_SetError("Button name too large: %s", szGameButton);
663  return;
664  }
665  szGameButton[i] = *pchPos;
666  i++;
667  } else {
668  if (i >= sizeof(szJoystickButton)) {
669  SDL_SetError("Joystick button name too large: %s", szJoystickButton);
670  return;
671  }
672  szJoystickButton[i] = *pchPos;
673  i++;
674  }
675  pchPos++;
676  }
677 
678  SDL_PrivateGameControllerParseElement(gamecontroller, szGameButton, szJoystickButton);
679 
680 }
#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:161
#define SDL_SetError

◆ SDL_PrivateGameControllerParseElement()

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

Definition at line 540 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().

541 {
545  SDL_bool invert_input = SDL_FALSE;
546  char half_axis_input = 0;
547  char half_axis_output = 0;
548 
549  if (*szGameButton == '+' || *szGameButton == '-') {
550  half_axis_output = *szGameButton++;
551  }
552 
553  axis = SDL_GameControllerGetAxisFromString(szGameButton);
554  button = SDL_GameControllerGetButtonFromString(szGameButton);
555  if (axis != SDL_CONTROLLER_AXIS_INVALID) {
557  bind.output.axis.axis = axis;
559  bind.output.axis.axis_min = 0;
560  bind.output.axis.axis_max = SDL_JOYSTICK_AXIS_MAX;
561  } else {
562  if (half_axis_output == '+') {
563  bind.output.axis.axis_min = 0;
564  bind.output.axis.axis_max = SDL_JOYSTICK_AXIS_MAX;
565  } else if (half_axis_output == '-') {
566  bind.output.axis.axis_min = 0;
567  bind.output.axis.axis_max = SDL_JOYSTICK_AXIS_MIN;
568  } else {
569  bind.output.axis.axis_min = SDL_JOYSTICK_AXIS_MIN;
570  bind.output.axis.axis_max = SDL_JOYSTICK_AXIS_MAX;
571  }
572  }
573  } else if (button != SDL_CONTROLLER_BUTTON_INVALID) {
575  bind.output.button = button;
576  } else {
577  SDL_SetError("Unexpected controller element %s", szGameButton);
578  return;
579  }
580 
581  if (*szJoystickButton == '+' || *szJoystickButton == '-') {
582  half_axis_input = *szJoystickButton++;
583  }
584  if (szJoystickButton[SDL_strlen(szJoystickButton) - 1] == '~') {
585  invert_input = SDL_TRUE;
586  }
587 
588  if (szJoystickButton[0] == 'a' && SDL_isdigit(szJoystickButton[1])) {
590  bind.input.axis.axis = SDL_atoi(&szJoystickButton[1]);
591  if (half_axis_input == '+') {
592  bind.input.axis.axis_min = 0;
593  bind.input.axis.axis_max = SDL_JOYSTICK_AXIS_MAX;
594  } else if (half_axis_input == '-') {
595  bind.input.axis.axis_min = 0;
596  bind.input.axis.axis_max = SDL_JOYSTICK_AXIS_MIN;
597  } else {
598  bind.input.axis.axis_min = SDL_JOYSTICK_AXIS_MIN;
599  bind.input.axis.axis_max = SDL_JOYSTICK_AXIS_MAX;
600  }
601  if (invert_input) {
602  int tmp = bind.input.axis.axis_min;
603  bind.input.axis.axis_min = bind.input.axis.axis_max;
604  bind.input.axis.axis_max = tmp;
605  }
606  } else if (szJoystickButton[0] == 'b' && SDL_isdigit(szJoystickButton[1])) {
608  bind.input.button = SDL_atoi(&szJoystickButton[1]);
609  } else if (szJoystickButton[0] == 'h' && SDL_isdigit(szJoystickButton[1]) &&
610  szJoystickButton[2] == '.' && SDL_isdigit(szJoystickButton[3])) {
611  int hat = SDL_atoi(&szJoystickButton[1]);
612  int mask = SDL_atoi(&szJoystickButton[3]);
614  bind.input.hat.hat = hat;
615  bind.input.hat.hat_mask = mask;
616  } else {
617  SDL_SetError("Unexpected joystick element: %s", szJoystickButton);
618  return;
619  }
620 
621  ++gamecontroller->num_bindings;
622  gamecontroller->bindings = (SDL_ExtendedGameControllerBind *)SDL_realloc(gamecontroller->bindings, gamecontroller->num_bindings * sizeof(*gamecontroller->bindings));
623  if (!gamecontroller->bindings) {
624  gamecontroller->num_bindings = 0;
625  SDL_OutOfMemory();
626  return;
627  }
628  gamecontroller->bindings[gamecontroller->num_bindings - 1] = bind;
629 }
union SDL_ExtendedGameControllerBind::@24 output
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:302
union SDL_ExtendedGameControllerBind::@23 input
#define SDL_JOYSTICK_AXIS_MAX
Definition: SDL_joystick.h:301
#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:161
#define SDL_SetError
#define SDL_strlen
SDL_GameControllerAxis

◆ SDL_PrivateGameControllerRefreshMapping()

static void SDL_PrivateGameControllerRefreshMapping ( ControllerMapping_t pControllerMapping)
static

Definition at line 798 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().

799 {
800  SDL_GameController *gamecontrollerlist = SDL_gamecontrollers;
801  while (gamecontrollerlist) {
802  if (!SDL_memcmp(&gamecontrollerlist->joystick->guid, &pControllerMapping->guid, sizeof(pControllerMapping->guid))) {
803  /* Not really threadsafe. Should this lock access within SDL_GameControllerEventWatcher? */
804  SDL_PrivateLoadButtonMapping(gamecontrollerlist, pControllerMapping->name, pControllerMapping->mapping);
805 
806  {
808  event.type = SDL_CONTROLLERDEVICEREMAPPED;
809  event.cdevice.which = gamecontrollerlist->joystick->instance_id;
810  SDL_PushEvent(&event);
811  }
812  }
813 
814  gamecontrollerlist = gamecontrollerlist->next;
815  }
816 }
SDL_JoystickGUID guid
static SDL_GameController * SDL_gamecontrollers
struct _cl_event * event
#define SDL_PushEvent
#define SDL_memcmp
static void SDL_PrivateLoadButtonMapping(SDL_GameController *gamecontroller, const char *pchName, const char *pchMapping)
General event structure.
Definition: SDL_events.h:557

◆ SDL_PrivateGetControllerGUIDFromMappingString()

static char* SDL_PrivateGetControllerGUIDFromMappingString ( const char *  pMapping)
static

Definition at line 714 of file SDL_gamecontroller.c.

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

Referenced by SDL_PrivateGameControllerAddMapping().

715 {
716  const char *pFirstComma = SDL_strchr(pMapping, ',');
717  if (pFirstComma) {
718  char *pchGUID = SDL_malloc(pFirstComma - pMapping + 1);
719  if (!pchGUID) {
720  SDL_OutOfMemory();
721  return NULL;
722  }
723  SDL_memcpy(pchGUID, pMapping, pFirstComma - pMapping);
724  pchGUID[pFirstComma - pMapping] = '\0';
725 
726  /* Convert old style GUIDs to the new style in 2.0.5 */
727 #if __WIN32__
728  if (SDL_strlen(pchGUID) == 32 &&
729  SDL_memcmp(&pchGUID[20], "504944564944", 12) == 0) {
730  SDL_memcpy(&pchGUID[20], "000000000000", 12);
731  SDL_memcpy(&pchGUID[16], &pchGUID[4], 4);
732  SDL_memcpy(&pchGUID[8], &pchGUID[0], 4);
733  SDL_memcpy(&pchGUID[0], "03000000", 8);
734  }
735 #elif __MACOSX__
736  if (SDL_strlen(pchGUID) == 32 &&
737  SDL_memcmp(&pchGUID[4], "000000000000", 12) == 0 &&
738  SDL_memcmp(&pchGUID[20], "000000000000", 12) == 0) {
739  SDL_memcpy(&pchGUID[20], "000000000000", 12);
740  SDL_memcpy(&pchGUID[8], &pchGUID[0], 4);
741  SDL_memcpy(&pchGUID[0], "03000000", 8);
742  }
743 #endif
744  return pchGUID;
745  }
746  return NULL;
747 }
#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 1039 of file SDL_gamecontroller.c.

References NULL, SDL_JoystickGetDeviceGUID, SDL_JoystickNameForIndex, SDL_LockJoysticks, SDL_NumJoysticks, SDL_PrivateGetControllerMappingForNameAndGUID(), SDL_SetError, and SDL_UnlockJoysticks.

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

1040 {
1041  const char *name;
1042  SDL_JoystickGUID guid;
1044 
1046 
1047  if ((device_index < 0) || (device_index >= SDL_NumJoysticks())) {
1048  SDL_SetError("There are %d joysticks available", SDL_NumJoysticks());
1050  return (NULL);
1051  }
1052 
1053  name = SDL_JoystickNameForIndex(device_index);
1054  guid = SDL_JoystickGetDeviceGUID(device_index);
1055  mapping = SDL_PrivateGetControllerMappingForNameAndGUID(name, guid);
1057  return mapping;
1058 }
#define SDL_UnlockJoysticks
#define SDL_JoystickNameForIndex
static ControllerMapping_t * SDL_PrivateGetControllerMappingForNameAndGUID(const char *name, SDL_JoystickGUID guid)
#define SDL_NumJoysticks
GLuint const GLchar * name
#define SDL_JoystickGetDeviceGUID
#define NULL
Definition: begin_code.h:164
#define SDL_SetError
GLenum GLenum GLenum GLenum mapping
#define SDL_LockJoysticks

◆ SDL_PrivateGetControllerMappingForGUID()

static ControllerMapping_t* SDL_PrivateGetControllerMappingForGUID ( SDL_JoystickGUID guid,
SDL_bool  exact_match 
)
static

Definition at line 424 of file SDL_gamecontroller.c.

References ControllerMapping_t::guid, ControllerMapping_t::next, NULL, s_pHIDAPIMapping, s_pSupportedControllers, s_pXInputMapping, SDL_IsJoystickHIDAPI(), SDL_IsJoystickXInput(), and SDL_memcmp.

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

425 {
426  ControllerMapping_t *pSupportedController = s_pSupportedControllers;
427  while (pSupportedController) {
428  if (SDL_memcmp(guid, &pSupportedController->guid, sizeof(*guid)) == 0) {
429  return pSupportedController;
430  }
431  pSupportedController = pSupportedController->next;
432  }
433  if (!exact_match) {
434  if (SDL_IsJoystickHIDAPI(*guid)) {
435  /* This is a HIDAPI device */
436  return s_pHIDAPIMapping;
437  }
438 #if SDL_JOYSTICK_XINPUT
439  if (SDL_IsJoystickXInput(*guid)) {
440  /* This is an XInput device */
441  return s_pXInputMapping;
442  }
443 #endif
444  }
445  return NULL;
446 }
struct _ControllerMapping_t * next
SDL_JoystickGUID guid
static ControllerMapping_t * s_pSupportedControllers
#define SDL_memcmp
static ControllerMapping_t * s_pHIDAPIMapping
SDL_bool SDL_IsJoystickXInput(SDL_JoystickGUID guid)
SDL_bool SDL_IsJoystickHIDAPI(SDL_JoystickGUID guid)
#define NULL
Definition: begin_code.h:164
static ControllerMapping_t * s_pXInputMapping

◆ SDL_PrivateGetControllerMappingForNameAndGUID()

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

Definition at line 1006 of file SDL_gamecontroller.c.

References s_pDefaultMapping, s_pXInputMapping, SDL_CONTROLLER_MAPPING_PRIORITY_DEFAULT, SDL_FALSE, SDL_IsJoystickHIDAPI(), SDL_PrivateAddMappingForGUID(), SDL_PrivateGetControllerMappingForGUID(), and SDL_strstr.

Referenced by SDL_IsGameControllerNameAndGUID(), and SDL_PrivateGetControllerMapping().

1007 {
1009 
1011 #ifdef __LINUX__
1012  if (!mapping && name) {
1013  if (SDL_strstr(name, "Xbox 360 Wireless Receiver")) {
1014  /* The Linux driver xpad.c maps the wireless dpad to buttons */
1015  SDL_bool existing;
1016  mapping = SDL_PrivateAddMappingForGUID(guid,
1017 "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,",
1019  }
1020  }
1021 #endif /* __LINUX__ */
1022 
1023  if (!mapping && name) {
1024  if (SDL_strstr(name, "Xbox") || SDL_strstr(name, "X-Box") || SDL_strstr(name, "XBOX")) {
1025  mapping = s_pXInputMapping;
1026  }
1027  }
1028 #ifdef __ANDROID__
1029  if (!mapping && name && !SDL_IsJoystickHIDAPI(guid)) {
1030  mapping = SDL_CreateMappingForAndroidController(name, guid);
1031  }
1032 #endif
1033  if (!mapping) {
1034  mapping = s_pDefaultMapping;
1035  }
1036  return mapping;
1037 }
static ControllerMapping_t * s_pDefaultMapping
GLuint const GLchar * name
static ControllerMapping_t * SDL_PrivateGetControllerMappingForGUID(SDL_JoystickGUID *guid, SDL_bool exact_match)
SDL_bool SDL_IsJoystickHIDAPI(SDL_JoystickGUID guid)
SDL_bool
Definition: SDL_stdinc.h:161
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 780 of file SDL_gamecontroller.c.

References NULL, SDL_strchr, and SDL_strdup.

Referenced by SDL_PrivateAddMappingForGUID().

781 {
782  const char *pFirstComma, *pSecondComma;
783 
784  pFirstComma = SDL_strchr(pMapping, ',');
785  if (!pFirstComma)
786  return NULL;
787 
788  pSecondComma = SDL_strchr(pFirstComma + 1, ',');
789  if (!pSecondComma)
790  return NULL;
791 
792  return SDL_strdup(pSecondComma + 1); /* mapping is everything after the 3rd comma */
793 }
#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 753 of file SDL_gamecontroller.c.

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

Referenced by SDL_PrivateAddMappingForGUID().

754 {
755  const char *pFirstComma, *pSecondComma;
756  char *pchName;
757 
758  pFirstComma = SDL_strchr(pMapping, ',');
759  if (!pFirstComma)
760  return NULL;
761 
762  pSecondComma = SDL_strchr(pFirstComma + 1, ',');
763  if (!pSecondComma)
764  return NULL;
765 
766  pchName = SDL_malloc(pSecondComma - pFirstComma);
767  if (!pchName) {
768  SDL_OutOfMemory();
769  return NULL;
770  }
771  SDL_memcpy(pchName, pFirstComma + 1, pSecondComma - pFirstComma);
772  pchName[pSecondComma - pFirstComma - 1] = 0;
773  return pchName;
774 }
#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,
const char *  pchName,
const char *  pchMapping 
)
static

Definition at line 685 of file SDL_gamecontroller.c.

References SDL_ExtendedGameControllerBind::axis, 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().

686 {
687  int i;
688 
689  gamecontroller->name = pchName;
690  gamecontroller->num_bindings = 0;
691  SDL_memset(gamecontroller->last_match_axis, 0, gamecontroller->joystick->naxes * sizeof(*gamecontroller->last_match_axis));
692 
693  SDL_PrivateGameControllerParseControllerConfigString(gamecontroller, pchMapping);
694 
695  /* Set the zero point for triggers */
696  for (i = 0; i < gamecontroller->num_bindings; ++i) {
697  SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i];
698  if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS &&
700  (binding->output.axis.axis == SDL_CONTROLLER_AXIS_TRIGGERLEFT ||
701  binding->output.axis.axis == SDL_CONTROLLER_AXIS_TRIGGERRIGHT)) {
702  if (binding->input.axis.axis < gamecontroller->joystick->naxes) {
703  gamecontroller->joystick->axes[binding->input.axis.axis].value =
704  gamecontroller->joystick->axes[binding->input.axis.axis].zero = (Sint16)binding->input.axis.axis_min;
705  }
706  }
707  }
708 }
union SDL_ExtendedGameControllerBind::@24 output
SDL_GameControllerBindType inputType
union SDL_ExtendedGameControllerBind::@23 input
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
#define SDL_memset
int16_t Sint16
Definition: SDL_stdinc.h:185

◆ SDL_ShouldIgnoreGameController()

SDL_bool SDL_ShouldIgnoreGameController ( const char *  name,
SDL_JoystickGUID  guid 
)

Definition at line 1460 of file SDL_gamecontroller.c.

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

Referenced by SDL_ShouldIgnoreJoystick().

1461 {
1462  int i;
1463  Uint16 vendor;
1464  Uint16 product;
1465  Uint16 version;
1466  Uint32 vidpid;
1467 
1470  return SDL_FALSE;
1471  }
1472 
1473  SDL_GetJoystickGUIDInfo(guid, &vendor, &product, &version);
1474 
1475  if (SDL_GetHintBoolean("SDL_GAMECONTROLLER_ALLOW_STEAM_VIRTUAL_GAMEPAD", SDL_FALSE)) {
1476  /* 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 */
1477  SDL_bool bSteamVirtualGamepad = SDL_FALSE;
1478 #if defined(__LINUX__)
1479  bSteamVirtualGamepad = (vendor == 0x28DE && product == 0x11FF);
1480 #elif defined(__MACOSX__)
1481  bSteamVirtualGamepad = (vendor == 0x045E && product == 0x028E && version == 1);
1482 #elif defined(__WIN32__)
1483  /* We can't tell on Windows, but Steam will block others in input hooks */
1484  bSteamVirtualGamepad = SDL_TRUE;
1485 #endif
1486  if (bSteamVirtualGamepad) {
1487  return SDL_FALSE;
1488  }
1489  }
1490 
1491  vidpid = MAKE_VIDPID(vendor, product);
1492 
1494  for (i = 0; i < SDL_allowed_controllers.num_entries; ++i) {
1495  if (vidpid == SDL_allowed_controllers.entries[i]) {
1496  return SDL_FALSE;
1497  }
1498  }
1499  return SDL_TRUE;
1500  } else {
1501  for (i = 0; i < SDL_ignored_controllers.num_entries; ++i) {
1502  if (vidpid == SDL_ignored_controllers.entries[i]) {
1503  return SDL_TRUE;
1504  }
1505  }
1506  return SDL_FALSE;
1507  }
1508 }
#define MAKE_VIDPID(VID, PID)
static SDL_vidpid_list SDL_ignored_controllers
uint16_t Uint16
Definition: SDL_stdinc.h:191
#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
SDL_bool
Definition: SDL_stdinc.h:161
static SDL_vidpid_list SDL_allowed_controllers
void SDL_GetJoystickGUIDInfo(SDL_JoystickGUID guid, Uint16 *vendor, Uint16 *product, Uint16 *version)
uint32_t Uint32
Definition: SDL_stdinc.h:203

◆ UpdateEventsForDeviceRemoval()

static void UpdateEventsForDeviceRemoval ( )
static

Definition at line 201 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().

202 {
203  int i, num_events;
204  SDL_Event *events;
205 
207  if (num_events <= 0) {
208  return;
209  }
210 
211  events = SDL_stack_alloc(SDL_Event, num_events);
212  if (!events) {
213  return;
214  }
215 
217  for (i = 0; i < num_events; ++i) {
218  --events[i].cdevice.which;
219  }
220  SDL_PeepEvents(events, num_events, SDL_ADDEVENT, 0, 0);
221 
222  SDL_stack_free(events);
223 }
SDL_ControllerDeviceEvent cdevice
Definition: SDL_events.h:576
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:557
#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 448 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 491 of file SDL_gamecontroller.c.

Referenced by SDL_GameControllerGetButtonFromString(), and SDL_GameControllerGetStringForButton().

◆ s_pDefaultMapping

ControllerMapping_t* s_pDefaultMapping = NULL
static

Definition at line 104 of file SDL_gamecontroller.c.

Referenced by SDL_PrivateGetControllerMappingForNameAndGUID().

◆ s_pHIDAPIMapping

ControllerMapping_t* s_pHIDAPIMapping = NULL
static

Definition at line 105 of file SDL_gamecontroller.c.

Referenced by SDL_PrivateGetControllerMappingForGUID().

◆ s_pSupportedControllers

ControllerMapping_t* s_pSupportedControllers = NULL
static

◆ s_pXInputMapping

◆ s_zeroGUID

SDL_JoystickGUID s_zeroGUID
static

Definition at line 102 of file SDL_gamecontroller.c.

◆ SDL_allowed_controllers

SDL_vidpid_list SDL_allowed_controllers
static

Definition at line 132 of file SDL_gamecontroller.c.

◆ SDL_gamecontrollers

◆ SDL_ignored_controllers

SDL_vidpid_list SDL_ignored_controllers
static

Definition at line 133 of file SDL_gamecontroller.c.