From 6d7da0887d1474adb2060c25ba6076ea04870ade Mon Sep 17 00:00:00 2001 From: Sam Lantinga Date: Tue, 27 Dec 2016 01:39:07 -0800 Subject: [PATCH] Split controller axes into positive and negative sides so each can be bound independently. Using this a D-Pad can be mapped to a thumbstick and vice versa. Also added support for inverted axes, improving trigger binding support --- include/SDL_joystick.h | 2 + src/joystick/SDL_gamecontroller.c | 658 +++++++++++++--------- src/joystick/windows/SDL_dinputjoystick.c | 8 +- src/joystick/windows/SDL_mmjoystick.c | 8 +- test/axis.bmp | Bin 3746 -> 10138 bytes test/controllermap.c | 250 ++++++-- test/testgamecontroller.c | 23 +- 7 files changed, 609 insertions(+), 340 deletions(-) diff --git a/include/SDL_joystick.h b/include/SDL_joystick.h index 7e63870cd..c32badd83 100644 --- a/include/SDL_joystick.h +++ b/include/SDL_joystick.h @@ -232,6 +232,8 @@ extern DECLSPEC void SDLCALL SDL_JoystickUpdate(void); */ extern DECLSPEC int SDLCALL SDL_JoystickEventState(int state); +#define SDL_JOYSTICK_AXIS_MAX 32767 +#define SDL_JOYSTICK_AXIS_MIN -32768 /** * Get the current state of an axis control on a joystick. * diff --git a/src/joystick/SDL_gamecontroller.c b/src/joystick/SDL_gamecontroller.c index 598d4643d..3fd1f11e8 100644 --- a/src/joystick/SDL_gamecontroller.c +++ b/src/joystick/SDL_gamecontroller.c @@ -32,53 +32,46 @@ #if !SDL_EVENTS_DISABLED #include "../events/SDL_events_c.h" #endif -#define ABS(_x) ((_x) < 0 ? -(_x) : (_x)) #define SDL_CONTROLLER_PLATFORM_FIELD "platform:" /* a list of currently opened game controllers */ static SDL_GameController *SDL_gamecontrollers = NULL; -/* keep track of the hat and mask value that transforms this hat movement into a button/axis press */ -struct _SDL_HatMapping +typedef struct { - int hat; - Uint8 mask; -}; + SDL_GameControllerBindType inputType; + union + { + int button; -/* We need 36 entries for Android (as of SDL v2.0.4) */ -#define k_nMaxReverseEntries 48 + struct { + int axis; + int axis_min; + int axis_max; + } axis; -/** - * We are encoding the "HAT" as 0xhm. where h == hat ID and m == mask - * MAX 4 hats supported - */ -#define k_nMaxHatEntries 0x3f + 1 + struct { + int hat; + int hat_mask; + } hat; -/* our in memory mapping db between joystick objects and controller mappings */ -struct _SDL_ControllerMapping -{ - SDL_JoystickGUID guid; - const char *name; + } input; - /* mapping of axis/button id to controller version */ - int axes[SDL_CONTROLLER_AXIS_MAX]; - int buttonasaxis[SDL_CONTROLLER_AXIS_MAX]; + SDL_GameControllerBindType outputType; + union + { + SDL_GameControllerButton button; - int buttons[SDL_CONTROLLER_BUTTON_MAX]; - int axesasbutton[SDL_CONTROLLER_BUTTON_MAX]; - struct _SDL_HatMapping hatasbutton[SDL_CONTROLLER_BUTTON_MAX]; + struct { + SDL_GameControllerAxis axis; + int axis_min; + int axis_max; + } axis; - /* reverse mapping, joystick indices to buttons */ - SDL_GameControllerAxis raxes[k_nMaxReverseEntries]; - SDL_GameControllerAxis rbuttonasaxis[k_nMaxReverseEntries]; - - SDL_GameControllerButton rbuttons[k_nMaxReverseEntries]; - SDL_GameControllerButton raxesasbutton[k_nMaxReverseEntries]; - SDL_GameControllerButton rhatasbutton[k_nMaxHatEntries]; - -}; + } output; +} SDL_ExtendedGameControllerBind; /* our hard coded list of mapping support */ typedef enum @@ -107,14 +100,20 @@ struct _SDL_GameController { SDL_Joystick *joystick; /* underlying joystick device */ int ref_count; - Uint8 hatState[4]; /* the current hat state for this controller */ - struct _SDL_ControllerMapping mapping; /* the mapping object for this controller */ + + SDL_JoystickGUID guid; + const char *name; + int num_bindings; + SDL_ExtendedGameControllerBind *bindings; + SDL_ExtendedGameControllerBind **last_match_axis; + Uint8 *last_hat_mask; + struct _SDL_GameController *next; /* pointer to next game controller we have allocated */ }; -int SDL_PrivateGameControllerAxis(SDL_GameController * gamecontroller, SDL_GameControllerAxis axis, Sint16 value); -int SDL_PrivateGameControllerButton(SDL_GameController * gamecontroller, SDL_GameControllerButton button, Uint8 state); +static int SDL_PrivateGameControllerAxis(SDL_GameController * gamecontroller, SDL_GameControllerAxis axis, Sint16 value); +static int SDL_PrivateGameControllerButton(SDL_GameController * gamecontroller, SDL_GameControllerButton button, Uint8 state); /* * If there is an existing add event in the queue, it needs to be modified @@ -145,6 +144,124 @@ static void UpdateEventsForDeviceRemoval() SDL_stack_free(events); } +static SDL_bool HasSameOutput(SDL_ExtendedGameControllerBind *a, SDL_ExtendedGameControllerBind *b) +{ + if (a->outputType != b->outputType) { + return SDL_FALSE; + } + + if (a->outputType == SDL_CONTROLLER_BINDTYPE_AXIS) { + return (a->output.axis.axis == b->output.axis.axis); + } else { + return (a->output.button == b->output.button); + } +} + +static void ResetOutput(SDL_GameController *gamecontroller, SDL_ExtendedGameControllerBind *bind) +{ + if (bind->outputType == SDL_CONTROLLER_BINDTYPE_AXIS) { + SDL_PrivateGameControllerAxis(gamecontroller, bind->output.axis.axis, 0); + } else { + SDL_PrivateGameControllerButton(gamecontroller, bind->output.button, SDL_RELEASED); + } +} + +static void HandleJoystickAxis(SDL_GameController *gamecontroller, int axis, int value) +{ + int i; + SDL_ExtendedGameControllerBind *last_match = gamecontroller->last_match_axis[axis]; + SDL_ExtendedGameControllerBind *match = NULL; + + for (i = 0; i < gamecontroller->num_bindings; ++i) { + SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i]; + if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS && + axis == binding->input.axis.axis) { + if (binding->input.axis.axis_min < binding->input.axis.axis_max) { + if (value >= binding->input.axis.axis_min && + value <= binding->input.axis.axis_max) { + match = binding; + break; + } + } else { + if (value >= binding->input.axis.axis_max && + value <= binding->input.axis.axis_min) { + match = binding; + break; + } + } + } + } + + if (last_match && (!match || !HasSameOutput(last_match, match))) { + /* Clear the last input that this axis generated */ + ResetOutput(gamecontroller, last_match); + } + + if (match) { + if (match->outputType == SDL_CONTROLLER_BINDTYPE_AXIS) { + if (match->input.axis.axis_min != match->output.axis.axis_min || match->input.axis.axis_max != match->output.axis.axis_max) { + float normalized_value = (float)(value - match->input.axis.axis_min) / (match->input.axis.axis_max - match->input.axis.axis_min); + value = match->output.axis.axis_min + (int)(normalized_value * (match->output.axis.axis_max - match->output.axis.axis_min)); + } + SDL_PrivateGameControllerAxis(gamecontroller, match->output.axis.axis, (Sint16)value); + } else { + Uint8 state; + int threshold = match->input.axis.axis_min + (match->input.axis.axis_max - match->input.axis.axis_min) / 2; + if (match->input.axis.axis_max < match->input.axis.axis_min) { + state = (value <= threshold) ? SDL_PRESSED : SDL_RELEASED; + } else { + state = (value >= threshold) ? SDL_PRESSED : SDL_RELEASED; + } + SDL_PrivateGameControllerButton(gamecontroller, match->output.button, state); + } + } + gamecontroller->last_match_axis[axis] = match; +} + +static void HandleJoystickButton(SDL_GameController *gamecontroller, int button, Uint8 state) +{ + int i; + + for (i = 0; i < gamecontroller->num_bindings; ++i) { + SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i]; + if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON && + button == binding->input.button) { + if (binding->outputType == SDL_CONTROLLER_BINDTYPE_AXIS) { + int value = state ? binding->output.axis.axis_max : binding->output.axis.axis_min; + SDL_PrivateGameControllerAxis(gamecontroller, binding->output.axis.axis, (Sint16)value); + } else { + SDL_PrivateGameControllerButton(gamecontroller, binding->output.button, state); + } + break; + } + } +} + +static void HandleJoystickHat(SDL_GameController *gamecontroller, int hat, Uint8 value) +{ + int i; + Uint8 last_mask = gamecontroller->last_hat_mask[hat]; + Uint8 changed_mask = (last_mask ^ value); + + for (i = 0; i < gamecontroller->num_bindings; ++i) { + SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i]; + if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT && hat == binding->input.hat.hat) { + if ((changed_mask & binding->input.hat.hat_mask) != 0) { + if (value & binding->input.hat.hat_mask) { + if (binding->outputType == SDL_CONTROLLER_BINDTYPE_AXIS) { + SDL_PrivateGameControllerAxis(gamecontroller, binding->output.axis.axis, (Sint16)binding->output.axis.axis_max); + } else { + SDL_PrivateGameControllerButton(gamecontroller, binding->output.button, SDL_PRESSED); + } + } else { + ResetOutput(gamecontroller, binding); + } + } + } + } + gamecontroller->last_hat_mask[hat] = value; +} + /* * Event filter to fire controller events from joystick ones */ @@ -153,32 +270,10 @@ static int SDL_GameControllerEventWatcher(void *userdata, SDL_Event * event) switch(event->type) { case SDL_JOYAXISMOTION: { - SDL_GameController *controllerlist; - - if (event->jaxis.axis >= k_nMaxReverseEntries) - { - SDL_SetError("SDL_GameControllerEventWatcher: Axis index %d too large, ignoring motion", (int)event->jaxis.axis); - break; - } - - controllerlist = SDL_gamecontrollers; + SDL_GameController *controllerlist = SDL_gamecontrollers; while (controllerlist) { if (controllerlist->joystick->instance_id == event->jaxis.which) { - if (controllerlist->mapping.raxes[event->jaxis.axis] >= 0) /* simple axis to axis, send it through */ { - SDL_GameControllerAxis axis = controllerlist->mapping.raxes[event->jaxis.axis]; - Sint16 value = event->jaxis.value; - switch (axis) { - case SDL_CONTROLLER_AXIS_TRIGGERLEFT: - case SDL_CONTROLLER_AXIS_TRIGGERRIGHT: - value = value / 2 + 16384; - break; - default: - break; - } - SDL_PrivateGameControllerAxis(controllerlist, axis, value); - } else if (controllerlist->mapping.raxesasbutton[event->jaxis.axis] >= 0) { /* simulate an axis as a button */ - SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.raxesasbutton[event->jaxis.axis], ABS(event->jaxis.value) > 32768/2 ? SDL_PRESSED : SDL_RELEASED); - } + HandleJoystickAxis(controllerlist, event->jaxis.axis, event->jaxis.value); break; } controllerlist = controllerlist->next; @@ -188,22 +283,10 @@ static int SDL_GameControllerEventWatcher(void *userdata, SDL_Event * event) case SDL_JOYBUTTONDOWN: case SDL_JOYBUTTONUP: { - SDL_GameController *controllerlist; - - if (event->jbutton.button >= k_nMaxReverseEntries) - { - SDL_SetError("SDL_GameControllerEventWatcher: Button index %d too large, ignoring update", (int)event->jbutton.button); - break; - } - - controllerlist = SDL_gamecontrollers; + SDL_GameController *controllerlist = SDL_gamecontrollers; while (controllerlist) { if (controllerlist->joystick->instance_id == event->jbutton.which) { - if (controllerlist->mapping.rbuttons[event->jbutton.button] >= 0) { /* simple button as button */ - SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rbuttons[event->jbutton.button], event->jbutton.state); - } else if (controllerlist->mapping.rbuttonasaxis[event->jbutton.button] >= 0) { /* an button pretending to be an axis */ - SDL_PrivateGameControllerAxis(controllerlist, controllerlist->mapping.rbuttonasaxis[event->jbutton.button], event->jbutton.state > 0 ? 32767 : 0); - } + HandleJoystickButton(controllerlist, event->jbutton.button, event->jbutton.state); break; } controllerlist = controllerlist->next; @@ -212,43 +295,10 @@ static int SDL_GameControllerEventWatcher(void *userdata, SDL_Event * event) break; case SDL_JOYHATMOTION: { - SDL_GameController *controllerlist; - - if (event->jhat.hat >= 4) break; - - controllerlist = SDL_gamecontrollers; + SDL_GameController *controllerlist = SDL_gamecontrollers; while (controllerlist) { if (controllerlist->joystick->instance_id == event->jhat.which) { - Uint8 bSame = controllerlist->hatState[event->jhat.hat] & event->jhat.value; - /* Get list of removed bits (button release) */ - Uint8 bChanged = controllerlist->hatState[event->jhat.hat] ^ bSame; - /* the hat idx in the high nibble */ - int bHighHat = event->jhat.hat << 4; - - if (bChanged & SDL_HAT_DOWN) - SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_DOWN], SDL_RELEASED); - if (bChanged & SDL_HAT_UP) - SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_UP], SDL_RELEASED); - if (bChanged & SDL_HAT_LEFT) - SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_LEFT], SDL_RELEASED); - if (bChanged & SDL_HAT_RIGHT) - SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_RIGHT], SDL_RELEASED); - - /* Get list of added bits (button press) */ - bChanged = event->jhat.value ^ bSame; - - if (bChanged & SDL_HAT_DOWN) - SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_DOWN], SDL_PRESSED); - if (bChanged & SDL_HAT_UP) - SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_UP], SDL_PRESSED); - if (bChanged & SDL_HAT_LEFT) - SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_LEFT], SDL_PRESSED); - if (bChanged & SDL_HAT_RIGHT) - SDL_PrivateGameControllerButton(controllerlist, controllerlist->mapping.rhatasbutton[bHighHat | SDL_HAT_RIGHT], SDL_PRESSED); - - /* update our state cache */ - controllerlist->hatState[event->jhat.hat] = event->jhat.value; - + HandleJoystickHat(controllerlist, event->jhat.hat, event->jhat.value); break; } controllerlist = controllerlist->next; @@ -321,8 +371,14 @@ static const char* map_StringForControllerAxis[] = { SDL_GameControllerAxis SDL_GameControllerGetAxisFromString(const char *pchString) { int entry; - if (!pchString || !pchString[0]) + + if (pchString && (*pchString == '+' || *pchString == '-')) { + ++pchString; + } + + if (!pchString || !pchString[0]) { return SDL_CONTROLLER_AXIS_INVALID; + } for (entry = 0; map_StringForControllerAxis[entry]; ++entry) { if (!SDL_strcasecmp(pchString, map_StringForControllerAxis[entry])) @@ -391,63 +447,95 @@ const char* SDL_GameControllerGetStringForButton(SDL_GameControllerButton axis) /* * given a controller button name and a joystick name update our mapping structure with it */ -static void SDL_PrivateGameControllerParseButton(const char *szGameButton, const char *szJoystickButton, struct _SDL_ControllerMapping *pMapping) +static void SDL_PrivateGameControllerParseElement(SDL_GameController *gamecontroller, const char *szGameButton, const char *szJoystickButton) { - int iSDLButton = 0; + SDL_ExtendedGameControllerBind bind; SDL_GameControllerButton button; SDL_GameControllerAxis axis; - button = SDL_GameControllerGetButtonFromString(szGameButton); + SDL_bool invert_input = SDL_FALSE; + char half_axis_input = 0; + char half_axis_output = 0; + + if (*szGameButton == '+' || *szGameButton == '-') { + half_axis_output = *szGameButton++; + } + axis = SDL_GameControllerGetAxisFromString(szGameButton); - iSDLButton = SDL_atoi(&szJoystickButton[1]); - - if (szJoystickButton[0] == 'a') { - if (iSDLButton >= k_nMaxReverseEntries) { - SDL_SetError("Axis index too large: %d", iSDLButton); - return; - } - if (axis != SDL_CONTROLLER_AXIS_INVALID) { - pMapping->axes[axis] = iSDLButton; - pMapping->raxes[iSDLButton] = axis; - } else if (button != SDL_CONTROLLER_BUTTON_INVALID) { - pMapping->axesasbutton[button] = iSDLButton; - pMapping->raxesasbutton[iSDLButton] = button; + button = SDL_GameControllerGetButtonFromString(szGameButton); + if (axis != SDL_CONTROLLER_AXIS_INVALID) { + bind.outputType = SDL_CONTROLLER_BINDTYPE_AXIS; + bind.output.axis.axis = axis; + if (axis == SDL_CONTROLLER_AXIS_TRIGGERLEFT || axis == SDL_CONTROLLER_AXIS_TRIGGERRIGHT) { + bind.output.axis.axis_min = 0; + bind.output.axis.axis_max = SDL_JOYSTICK_AXIS_MAX; } else { - SDL_assert(!"How did we get here?"); + if (half_axis_output == '+') { + bind.output.axis.axis_min = 0; + bind.output.axis.axis_max = SDL_JOYSTICK_AXIS_MAX; + } else if (half_axis_output == '-') { + bind.output.axis.axis_min = 0; + bind.output.axis.axis_max = SDL_JOYSTICK_AXIS_MIN; + } else { + bind.output.axis.axis_min = SDL_JOYSTICK_AXIS_MIN; + bind.output.axis.axis_max = SDL_JOYSTICK_AXIS_MAX; + } } + } else if (button != SDL_CONTROLLER_BUTTON_INVALID) { + bind.outputType = SDL_CONTROLLER_BINDTYPE_BUTTON; + bind.output.button = button; + } else { + SDL_SetError("Unexpected controller element %s", szGameButton); + return; + } - } else if (szJoystickButton[0] == 'b') { - if (iSDLButton >= k_nMaxReverseEntries) { - SDL_SetError("Button index too large: %d", iSDLButton); - return; - } - if (button != SDL_CONTROLLER_BUTTON_INVALID) { - pMapping->buttons[button] = iSDLButton; - pMapping->rbuttons[iSDLButton] = button; - } else if (axis != SDL_CONTROLLER_AXIS_INVALID) { - pMapping->buttonasaxis[axis] = iSDLButton; - pMapping->rbuttonasaxis[iSDLButton] = axis; + if (*szJoystickButton == '+' || *szJoystickButton == '-') { + half_axis_input = *szJoystickButton++; + } + if (szJoystickButton[SDL_strlen(szJoystickButton) - 1] == '~') { + invert_input = SDL_TRUE; + } + + if (szJoystickButton[0] == 'a' && SDL_isdigit(szJoystickButton[1])) { + bind.inputType = SDL_CONTROLLER_BINDTYPE_AXIS; + bind.input.axis.axis = SDL_atoi(&szJoystickButton[1]); + if (half_axis_input == '+') { + bind.input.axis.axis_min = 0; + bind.input.axis.axis_max = SDL_JOYSTICK_AXIS_MAX; + } else if (half_axis_input == '-') { + bind.input.axis.axis_min = 0; + bind.input.axis.axis_max = SDL_JOYSTICK_AXIS_MIN; } else { - SDL_assert(!"How did we get here?"); + bind.input.axis.axis_min = SDL_JOYSTICK_AXIS_MIN; + bind.input.axis.axis_max = SDL_JOYSTICK_AXIS_MAX; } - } else if (szJoystickButton[0] == 'h') { + if (invert_input) { + int tmp = bind.input.axis.axis_min; + bind.input.axis.axis_min = bind.input.axis.axis_max; + bind.input.axis.axis_max = tmp; + } + } else if (szJoystickButton[0] == 'b' && SDL_isdigit(szJoystickButton[1])) { + bind.inputType = SDL_CONTROLLER_BINDTYPE_BUTTON; + bind.input.button = SDL_atoi(&szJoystickButton[1]); + } else if (szJoystickButton[0] == 'h' && SDL_isdigit(szJoystickButton[1]) && + szJoystickButton[2] == '.' && SDL_isdigit(szJoystickButton[3])) { int hat = SDL_atoi(&szJoystickButton[1]); int mask = SDL_atoi(&szJoystickButton[3]); - if (hat >= 4) { - SDL_SetError("Hat index too large: %d", iSDLButton); - } - - if (button != SDL_CONTROLLER_BUTTON_INVALID) { - int ridx; - pMapping->hatasbutton[button].hat = hat; - pMapping->hatasbutton[button].mask = mask; - ridx = (hat << 4) | mask; - pMapping->rhatasbutton[ridx] = button; - } else if (axis != SDL_CONTROLLER_AXIS_INVALID) { - SDL_assert(!"Support hat as axis"); - } else { - SDL_assert(!"How did we get here?"); - } + bind.inputType = SDL_CONTROLLER_BINDTYPE_HAT; + bind.input.hat.hat = hat; + bind.input.hat.hat_mask = mask; + } else { + SDL_SetError("Unexpected joystick element: %s", szJoystickButton); + return; } + + ++gamecontroller->num_bindings; + gamecontroller->bindings = (SDL_ExtendedGameControllerBind *)SDL_realloc(gamecontroller->bindings, gamecontroller->num_bindings * sizeof(*gamecontroller->bindings)); + if (!gamecontroller->bindings) { + gamecontroller->num_bindings = 0; + SDL_OutOfMemory(); + return; + } + gamecontroller->bindings[gamecontroller->num_bindings - 1] = bind; } @@ -455,7 +543,7 @@ static void SDL_PrivateGameControllerParseButton(const char *szGameButton, const * given a controller mapping string update our mapping object */ static void -SDL_PrivateGameControllerParseControllerConfigString(struct _SDL_ControllerMapping *pMapping, const char *pchString) +SDL_PrivateGameControllerParseControllerConfigString(SDL_GameController *gamecontroller, const char *pchString) { char szGameButton[20]; char szJoystickButton[20]; @@ -463,8 +551,8 @@ SDL_PrivateGameControllerParseControllerConfigString(struct _SDL_ControllerMappi int i = 0; const char *pchPos = pchString; - SDL_memset(szGameButton, 0x0, sizeof(szGameButton)); - SDL_memset(szJoystickButton, 0x0, sizeof(szJoystickButton)); + SDL_zero(szGameButton); + SDL_zero(szJoystickButton); while (pchPos && *pchPos) { if (*pchPos == ':') { @@ -475,9 +563,9 @@ SDL_PrivateGameControllerParseControllerConfigString(struct _SDL_ControllerMappi } else if (*pchPos == ',') { i = 0; bGameButton = SDL_TRUE; - SDL_PrivateGameControllerParseButton(szGameButton, szJoystickButton, pMapping); - SDL_memset(szGameButton, 0x0, sizeof(szGameButton)); - SDL_memset(szJoystickButton, 0x0, sizeof(szJoystickButton)); + SDL_PrivateGameControllerParseElement(gamecontroller, szGameButton, szJoystickButton); + SDL_zero(szGameButton); + SDL_zero(szJoystickButton); } else if (bGameButton) { if (i >= sizeof(szGameButton)) { @@ -497,43 +585,37 @@ SDL_PrivateGameControllerParseControllerConfigString(struct _SDL_ControllerMappi pchPos++; } - SDL_PrivateGameControllerParseButton(szGameButton, szJoystickButton, pMapping); + SDL_PrivateGameControllerParseElement(gamecontroller, szGameButton, szJoystickButton); } /* * Make a new button mapping struct */ -static void SDL_PrivateLoadButtonMapping(struct _SDL_ControllerMapping *pMapping, SDL_JoystickGUID guid, const char *pchName, const char *pchMapping) +static void SDL_PrivateLoadButtonMapping(SDL_GameController *gamecontroller, SDL_JoystickGUID guid, const char *pchName, const char *pchMapping) { - int j; + int i; - pMapping->guid = guid; - pMapping->name = pchName; + gamecontroller->guid = guid; + gamecontroller->name = pchName; + gamecontroller->num_bindings = 0; + SDL_memset(gamecontroller->last_match_axis, 0, gamecontroller->joystick->naxes * sizeof(*gamecontroller->last_match_axis)); - /* set all the button mappings to non defaults */ - for (j = 0; j < SDL_CONTROLLER_AXIS_MAX; j++) { - pMapping->axes[j] = -1; - pMapping->buttonasaxis[j] = -1; + SDL_PrivateGameControllerParseControllerConfigString(gamecontroller, pchMapping); + + /* Set the zero point for triggers */ + for (i = 0; i < gamecontroller->num_bindings; ++i) { + SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i]; + if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS && + binding->outputType == SDL_CONTROLLER_BINDTYPE_AXIS && + (binding->output.axis.axis == SDL_CONTROLLER_AXIS_TRIGGERLEFT || + binding->output.axis.axis == SDL_CONTROLLER_AXIS_TRIGGERRIGHT)) { + if (binding->input.axis.axis < gamecontroller->joystick->naxes) { + gamecontroller->joystick->axes[binding->input.axis.axis].value = + gamecontroller->joystick->axes[binding->input.axis.axis].zero = (Sint16)binding->input.axis.axis_min; + } + } } - for (j = 0; j < SDL_CONTROLLER_BUTTON_MAX; j++) { - pMapping->buttons[j] = -1; - pMapping->axesasbutton[j] = -1; - pMapping->hatasbutton[j].hat = -1; - } - - for (j = 0; j < k_nMaxReverseEntries; j++) { - pMapping->raxes[j] = SDL_CONTROLLER_AXIS_INVALID; - pMapping->rbuttonasaxis[j] = SDL_CONTROLLER_AXIS_INVALID; - pMapping->rbuttons[j] = SDL_CONTROLLER_BUTTON_INVALID; - pMapping->raxesasbutton[j] = SDL_CONTROLLER_BUTTON_INVALID; - } - - for (j = 0; j < k_nMaxHatEntries; j++) { - pMapping->rhatasbutton[j] = SDL_CONTROLLER_BUTTON_INVALID; - } - - SDL_PrivateGameControllerParseControllerConfigString(pMapping, pchMapping); } @@ -628,14 +710,14 @@ static void SDL_PrivateGameControllerRefreshMapping(ControllerMapping_t *pContro { SDL_GameController *gamecontrollerlist = SDL_gamecontrollers; while (gamecontrollerlist) { - if (!SDL_memcmp(&gamecontrollerlist->mapping.guid, &pControllerMapping->guid, sizeof(pControllerMapping->guid))) { + if (!SDL_memcmp(&gamecontrollerlist->guid, &pControllerMapping->guid, sizeof(pControllerMapping->guid))) { SDL_Event event; event.type = SDL_CONTROLLERDEVICEREMAPPED; event.cdevice.which = gamecontrollerlist->joystick->instance_id; SDL_PushEvent(&event); /* Not really threadsafe. Should this lock access within SDL_GameControllerEventWatcher? */ - SDL_PrivateLoadButtonMapping(&gamecontrollerlist->mapping, pControllerMapping->guid, pControllerMapping->name, pControllerMapping->mapping); + SDL_PrivateLoadButtonMapping(gamecontrollerlist, pControllerMapping->guid, pControllerMapping->name, pControllerMapping->mapping); } gamecontrollerlist = gamecontrollerlist->next; @@ -972,7 +1054,7 @@ SDL_GameControllerMapping(SDL_GameController * gamecontroller) return NULL; } - return SDL_GameControllerMappingForGUID(gamecontroller->mapping.guid); + return SDL_GameControllerMappingForGUID(gamecontroller->guid); } static void @@ -1046,7 +1128,7 @@ SDL_GameControllerInit(void) const char * SDL_GameControllerNameForIndex(int device_index) { - ControllerMapping_t *pSupportedController = SDL_PrivateGetControllerMapping(device_index); + ControllerMapping_t *pSupportedController = SDL_PrivateGetControllerMapping(device_index); if (pSupportedController) { return pSupportedController->name; } @@ -1060,11 +1142,10 @@ SDL_GameControllerNameForIndex(int device_index) SDL_bool SDL_IsGameController(int device_index) { - ControllerMapping_t *pSupportedController = SDL_PrivateGetControllerMapping(device_index); + ControllerMapping_t *pSupportedController = SDL_PrivateGetControllerMapping(device_index); if (pSupportedController) { return SDL_TRUE; } - return SDL_FALSE; } @@ -1110,14 +1191,13 @@ SDL_GameControllerOpen(int device_index) } /* Create and initialize the joystick */ - gamecontroller = (SDL_GameController *) SDL_malloc((sizeof *gamecontroller)); + gamecontroller = (SDL_GameController *) SDL_calloc(1, sizeof(*gamecontroller)); if (gamecontroller == NULL) { SDL_OutOfMemory(); SDL_UnlockJoystickList(); return NULL; } - SDL_memset(gamecontroller, 0, (sizeof *gamecontroller)); gamecontroller->joystick = SDL_JoystickOpen(device_index); if (!gamecontroller->joystick) { SDL_free(gamecontroller); @@ -1125,21 +1205,10 @@ SDL_GameControllerOpen(int device_index) return NULL; } - SDL_PrivateLoadButtonMapping(&gamecontroller->mapping, pSupportedController->guid, pSupportedController->name, pSupportedController->mapping); + gamecontroller->last_match_axis = (SDL_ExtendedGameControllerBind **)SDL_calloc(gamecontroller->joystick->naxes, sizeof(*gamecontroller->last_match_axis)); + gamecontroller->last_hat_mask = (Uint8 *)SDL_calloc(gamecontroller->joystick->nhats, sizeof(*gamecontroller->last_hat_mask)); - /* The triggers are mapped from -32768 to 32767, where -32768 is the 'unpressed' value */ - { - int leftTriggerMapping = gamecontroller->mapping.axes[SDL_CONTROLLER_AXIS_TRIGGERLEFT]; - int rightTriggerMapping = gamecontroller->mapping.axes[SDL_CONTROLLER_AXIS_TRIGGERRIGHT]; - if (leftTriggerMapping >= 0) { - gamecontroller->joystick->axes[leftTriggerMapping].value = - gamecontroller->joystick->axes[leftTriggerMapping].zero = (Sint16)-32768; - } - if (rightTriggerMapping >= 0) { - gamecontroller->joystick->axes[rightTriggerMapping].value = - gamecontroller->joystick->axes[rightTriggerMapping].zero = (Sint16)-32768; - } - } + SDL_PrivateLoadButtonMapping(gamecontroller, pSupportedController->guid, pSupportedController->name, pSupportedController->mapping); /* Add joystick to list */ ++gamecontroller->ref_count; @@ -1162,65 +1231,102 @@ SDL_GameControllerUpdate(void) SDL_JoystickUpdate(); } - /* * Get the current state of an axis control on a controller */ Sint16 SDL_GameControllerGetAxis(SDL_GameController * gamecontroller, SDL_GameControllerAxis axis) { + int i; + if (!gamecontroller) return 0; - if (gamecontroller->mapping.axes[axis] >= 0) { - Sint16 value = (SDL_JoystickGetAxis(gamecontroller->joystick, gamecontroller->mapping.axes[axis])); - switch (axis) { - case SDL_CONTROLLER_AXIS_TRIGGERLEFT: - case SDL_CONTROLLER_AXIS_TRIGGERRIGHT: - /* Shift it to be 0 - 32767 */ - value = value / 2 + 16384; - default: - break; + for (i = 0; i < gamecontroller->num_bindings; ++i) { + SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i]; + if (binding->outputType == SDL_CONTROLLER_BINDTYPE_AXIS && binding->output.axis.axis == axis) { + int value = 0; + SDL_bool valid_input_range; + SDL_bool valid_output_range; + + if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) { + value = SDL_JoystickGetAxis(gamecontroller->joystick, binding->input.axis.axis); + if (binding->input.axis.axis_min < binding->input.axis.axis_max) { + valid_input_range = (value >= binding->input.axis.axis_min && value <= binding->input.axis.axis_max); + } else { + valid_input_range = (value >= binding->input.axis.axis_max && value <= binding->input.axis.axis_min); + } + if (valid_input_range) { + if (binding->input.axis.axis_min != binding->output.axis.axis_min || binding->input.axis.axis_max != binding->output.axis.axis_max) { + float normalized_value = (float)(value - binding->input.axis.axis_min) / (binding->input.axis.axis_max - binding->input.axis.axis_min); + value = binding->output.axis.axis_min + (int)(normalized_value * (binding->output.axis.axis_max - binding->output.axis.axis_min)); + } + } + } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) { + value = SDL_JoystickGetButton(gamecontroller->joystick, binding->input.button); + if (value == SDL_PRESSED) { + value = binding->output.axis.axis_max; + } + } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) { + int hat_mask = SDL_JoystickGetHat(gamecontroller->joystick, binding->input.hat.hat); + if (hat_mask & binding->input.hat.hat_mask) { + value = binding->output.axis.axis_max; + } + } + + if (binding->output.axis.axis_min < binding->output.axis.axis_max) { + valid_output_range = (value >= binding->output.axis.axis_min && value <= binding->output.axis.axis_max); + } else { + valid_output_range = (value >= binding->output.axis.axis_max && value <= binding->output.axis.axis_min); + } + // If the value is zero, there might be another binding that makes it non-zero + if (value != 0 && valid_output_range) { + return (Sint16)value; + } } - return value; - } else if (gamecontroller->mapping.buttonasaxis[axis] >= 0) { - Uint8 value; - value = SDL_JoystickGetButton(gamecontroller->joystick, gamecontroller->mapping.buttonasaxis[axis]); - if (value > 0) - return 32767; - return 0; } return 0; } - /* * Get the current state of a button on a controller */ Uint8 SDL_GameControllerGetButton(SDL_GameController * gamecontroller, SDL_GameControllerButton button) { + int i; + if (!gamecontroller) return 0; - if (gamecontroller->mapping.buttons[button] >= 0) { - return (SDL_JoystickGetButton(gamecontroller->joystick, gamecontroller->mapping.buttons[button])); - } else if (gamecontroller->mapping.axesasbutton[button] >= 0) { - Sint16 value; - value = SDL_JoystickGetAxis(gamecontroller->joystick, gamecontroller->mapping.axesasbutton[button]); - if (ABS(value) > 32768/2) - return 1; - return 0; - } else if (gamecontroller->mapping.hatasbutton[button].hat >= 0) { - Uint8 value; - value = SDL_JoystickGetHat(gamecontroller->joystick, gamecontroller->mapping.hatasbutton[button].hat); + for (i = 0; i < gamecontroller->num_bindings; ++i) { + SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i]; + if (binding->outputType == SDL_CONTROLLER_BINDTYPE_BUTTON && binding->output.button == button) { + if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) { + SDL_bool valid_input_range; - if (value & gamecontroller->mapping.hatasbutton[button].mask) - return 1; - return 0; + int value = SDL_JoystickGetAxis(gamecontroller->joystick, binding->input.axis.axis); + int threshold = binding->input.axis.axis_min + (binding->input.axis.axis_max - binding->input.axis.axis_min) / 2; + if (binding->input.axis.axis_min < binding->input.axis.axis_max) { + valid_input_range = (value >= binding->input.axis.axis_min && value <= binding->input.axis.axis_max); + if (valid_input_range) { + return (value >= threshold) ? SDL_PRESSED : SDL_RELEASED; + } + } else { + valid_input_range = (value >= binding->input.axis.axis_max && value <= binding->input.axis.axis_min); + if (valid_input_range) { + return (value <= threshold) ? SDL_PRESSED : SDL_RELEASED; + } + } + } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) { + return SDL_JoystickGetButton(gamecontroller->joystick, binding->input.button); + } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) { + int hat_mask = SDL_JoystickGetHat(gamecontroller->joystick, binding->input.hat.hat); + return (hat_mask & binding->input.hat.hat_mask) ? SDL_PRESSED : SDL_RELEASED; + } + } } - - return 0; + return SDL_RELEASED; } const char * @@ -1229,7 +1335,7 @@ SDL_GameControllerName(SDL_GameController * gamecontroller) if (!gamecontroller) return NULL; - return gamecontroller->mapping.name; + return gamecontroller->name; } Uint16 @@ -1302,20 +1408,29 @@ SDL_GameControllerFromInstanceID(SDL_JoystickID joyid) */ SDL_GameControllerButtonBind SDL_GameControllerGetBindForAxis(SDL_GameController * gamecontroller, SDL_GameControllerAxis axis) { + int i; SDL_GameControllerButtonBind bind; - SDL_memset(&bind, 0x0, sizeof(bind)); + SDL_zero(bind); if (!gamecontroller || axis == SDL_CONTROLLER_AXIS_INVALID) return bind; - if (gamecontroller->mapping.axes[axis] >= 0) { - bind.bindType = SDL_CONTROLLER_BINDTYPE_AXIS; - bind.value.button = gamecontroller->mapping.axes[axis]; - } else if (gamecontroller->mapping.buttonasaxis[axis] >= 0) { - bind.bindType = SDL_CONTROLLER_BINDTYPE_BUTTON; - bind.value.button = gamecontroller->mapping.buttonasaxis[axis]; + for (i = 0; i < gamecontroller->num_bindings; ++i) { + SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i]; + if (binding->outputType == SDL_CONTROLLER_BINDTYPE_AXIS && binding->output.axis.axis == axis) { + bind.bindType = binding->inputType; + if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) { + /* FIXME: There might be multiple axes bound now that we have axis ranges... */ + bind.value.axis = binding->input.axis.axis; + } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) { + bind.value.button = binding->input.button; + } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) { + bind.value.hat.hat = binding->input.hat.hat; + bind.value.hat.hat_mask = binding->input.hat.hat_mask; + } + break; + } } - return bind; } @@ -1325,24 +1440,28 @@ SDL_GameControllerButtonBind SDL_GameControllerGetBindForAxis(SDL_GameController */ SDL_GameControllerButtonBind SDL_GameControllerGetBindForButton(SDL_GameController * gamecontroller, SDL_GameControllerButton button) { + int i; SDL_GameControllerButtonBind bind; - SDL_memset(&bind, 0x0, sizeof(bind)); + SDL_zero(bind); if (!gamecontroller || button == SDL_CONTROLLER_BUTTON_INVALID) return bind; - if (gamecontroller->mapping.buttons[button] >= 0) { - bind.bindType = SDL_CONTROLLER_BINDTYPE_BUTTON; - bind.value.button = gamecontroller->mapping.buttons[button]; - } else if (gamecontroller->mapping.axesasbutton[button] >= 0) { - bind.bindType = SDL_CONTROLLER_BINDTYPE_AXIS; - bind.value.axis = gamecontroller->mapping.axesasbutton[button]; - } else if (gamecontroller->mapping.hatasbutton[button].hat >= 0) { - bind.bindType = SDL_CONTROLLER_BINDTYPE_HAT; - bind.value.hat.hat = gamecontroller->mapping.hatasbutton[button].hat; - bind.value.hat.hat_mask = gamecontroller->mapping.hatasbutton[button].mask; + for (i = 0; i < gamecontroller->num_bindings; ++i) { + SDL_ExtendedGameControllerBind *binding = &gamecontroller->bindings[i]; + if (binding->outputType == SDL_CONTROLLER_BINDTYPE_BUTTON && binding->output.button == button) { + bind.bindType = binding->inputType; + if (binding->inputType == SDL_CONTROLLER_BINDTYPE_AXIS) { + bind.value.axis = binding->input.axis.axis; + } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_BUTTON) { + bind.value.button = binding->input.button; + } else if (binding->inputType == SDL_CONTROLLER_BINDTYPE_HAT) { + bind.value.hat.hat = binding->input.hat.hat; + bind.value.hat.hat_mask = binding->input.hat.hat_mask; + } + break; + } } - return bind; } @@ -1381,6 +1500,9 @@ SDL_GameControllerClose(SDL_GameController * gamecontroller) gamecontrollerlist = gamecontrollerlist->next; } + SDL_free(gamecontroller->bindings); + SDL_free(gamecontroller->last_match_axis); + SDL_free(gamecontroller->last_hat_mask); SDL_free(gamecontroller); SDL_UnlockJoystickList(); @@ -1417,7 +1539,7 @@ SDL_GameControllerQuit(void) /* * Event filter to transform joystick events into appropriate game controller ones */ -int +static int SDL_PrivateGameControllerAxis(SDL_GameController * gamecontroller, SDL_GameControllerAxis axis, Sint16 value) { int posted; @@ -1441,7 +1563,7 @@ SDL_PrivateGameControllerAxis(SDL_GameController * gamecontroller, SDL_GameContr /* * Event filter to transform joystick events into appropriate game controller ones */ -int +static int SDL_PrivateGameControllerButton(SDL_GameController * gamecontroller, SDL_GameControllerButton button, Uint8 state) { int posted; diff --git a/src/joystick/windows/SDL_dinputjoystick.c b/src/joystick/windows/SDL_dinputjoystick.c index 92d540b72..e6e70667a 100644 --- a/src/joystick/windows/SDL_dinputjoystick.c +++ b/src/joystick/windows/SDL_dinputjoystick.c @@ -33,9 +33,7 @@ #endif #define INPUT_QSIZE 32 /* Buffer up to 32 input messages */ -#define AXIS_MIN -32768 /* minimum value for axis coordinate */ -#define AXIS_MAX 32767 /* maximum value for axis coordinate */ -#define JOY_AXIS_THRESHOLD (((AXIS_MAX)-(AXIS_MIN))/100) /* 1% motion */ +#define JOY_AXIS_THRESHOLD (((SDL_JOYSTICK_AXIS_MAX)-(SDL_JOYSTICK_AXIS_MIN))/100) /* 1% motion */ /* external variables referenced. */ extern HWND SDL_HelperWindow; @@ -481,8 +479,8 @@ EnumDevObjectsCallback(LPCDIDEVICEOBJECTINSTANCE dev, LPVOID pvRef) diprg.diph.dwHeaderSize = sizeof(diprg.diph); diprg.diph.dwObj = dev->dwType; diprg.diph.dwHow = DIPH_BYID; - diprg.lMin = AXIS_MIN; - diprg.lMax = AXIS_MAX; + diprg.lMin = SDL_JOYSTICK_AXIS_MIN; + diprg.lMax = SDL_JOYSTICK_AXIS_MAX; result = IDirectInputDevice8_SetProperty(joystick->hwdata->InputDevice, diff --git a/src/joystick/windows/SDL_mmjoystick.c b/src/joystick/windows/SDL_mmjoystick.c index 5fb8fe157..e88f31e31 100644 --- a/src/joystick/windows/SDL_mmjoystick.c +++ b/src/joystick/windows/SDL_mmjoystick.c @@ -41,10 +41,8 @@ #define MAX_JOYSTICKS 16 #define MAX_AXES 6 /* each joystick can have up to 6 axes */ #define MAX_BUTTONS 32 /* and 32 buttons */ -#define AXIS_MIN -32768 /* minimum value for axis coordinate */ -#define AXIS_MAX 32767 /* maximum value for axis coordinate */ /* limit axis to 256 possible positions to filter out noise */ -#define JOY_AXIS_THRESHOLD (((AXIS_MAX)-(AXIS_MIN))/256) +#define JOY_AXIS_THRESHOLD (((SDL_JOYSTICK_AXIS_MAX)-(SDL_JOYSTICK_AXIS_MIN))/256) #define JOY_BUTTON_FLAG(n) (1<hwdata->id = SYS_JoystickID[index]; for (i = 0; i < MAX_AXES; ++i) { if ((i < 2) || (SYS_Joystick[index].wCaps & caps_flags[i - 2])) { - joystick->hwdata->transaxis[i].offset = AXIS_MIN - axis_min[i]; + joystick->hwdata->transaxis[i].offset = SDL_JOYSTICK_AXIS_MIN - axis_min[i]; joystick->hwdata->transaxis[i].scale = - (float) (AXIS_MAX - AXIS_MIN) / (axis_max[i] - axis_min[i]); + (float) (SDL_JOYSTICK_AXIS_MAX - SDL_JOYSTICK_AXIS_MIN) / (axis_max[i] - axis_min[i]); } else { joystick->hwdata->transaxis[i].offset = 0; joystick->hwdata->transaxis[i].scale = 1.0; /* Just in case */ diff --git a/test/axis.bmp b/test/axis.bmp index c7addd3ed9372e59d11d874dace91bb64840e066..2b3a7c8af6aa0bbefe26885523d7eb4387841606 100644 GIT binary patch literal 10138 zcmeHKF;2uV5cC~T(ID}GD-g7ZCtO1V4PT+9L_(sYTx0k4ePezWeBoAZ$9^B!{^9~;HIBJ3;oFX^oO!hKaUHK*E&}y-w|H(J+c2i= zWd+eY?9=YY{(m5*%Ya=@@i@{;Ao6DGd+-liV?A&mvCIPo44CoCgn9sLwf}b zu*x&+N8}mC8Q7SAnYX#6ULzM6JWs^#XHagJ^)8G9Y)CK2fdK=|h*^$h9@1^Y#{1mo z18K<3t5zp^FYtH(DYMk`gjnQ&6*1~C%tw6&IkQ+Vh(T&I8?12em>$4hH;VuxzyOr-(+#82FZ8o*$bB~tz TTyt+)M&qkJSr72>Nc{*u97*TN literal 3746 zcmd6pWmH>R6NcZqP^GT4rL>d?1PK8Ov`ABTcc*U9LX?Dr1d9>^Az1N3-GI7KcXxMp zZ*T4nRG^oBUwePuv(`ClubKUvnb~L0d$v!%^m-_{xK)8UWaRkuu7sK;cH7!OBa6}- zm57PlKJ3APCC)#1RIXrdrAn1hxpHMxsZs@1t5!v|YSmD^dUe#OQ3Ew=)eZ`<`t|FhL4yWp*sviiEiKWgQ6n^N+!#%oG(pp*P0_4bGc<4B z94%V3K+Bdb(W+G|v~JxRZQ8U!+qP|CWo3nS?b@Mz`}XM2p#!X~t(&k3yLX3=j}Lr(ec|Wl2Y-Km z^ytw8Y&IJ`d-g=HUcJz}cW?CR(+7R~_C>#b{m{REe+(Ef00RdO#GpZgFnI7_3>h*6 zLx&E7PM~=j(QKK+=^k|G3GX`VFj>Wif<1l{wcubfu0TU-q#H2}+ zFnRK1OqntTQ>RYFv}w~Yefo3+1O#Blj2W0Yb0%iZnuXc3XJgKsIhZ?lF6Pafhxzm8 zW5I$2Sh#Q@7A;zYz`#HR1qEU8;>B39WC? z&`^j(B8bIegoTAcB9TBUl_ESm95R^C&Z0PftfiMg}r7Gm({*h3xEX-R23sF>5giV_^Ve{tA*s^5{ zwr<^uZQHhC`}XbFv112z?%au8yLMss?%gOZF2J9Z4mj~~a06DM%;^pFhWo7ccPg7beTY%gei4Hy>{%&HDdgRH{9L;mCAjF`b>5?w;OWzI{EZZT=@k zr_$*T&JOJx*RDqNvt~mp2X}X$p00LXeo4`&Br%6BmbIGDM{qT9k#l`o*KJ_q?C$UF zLi+_ol+WJ5rhX$fH*;;SL8XYxSXY!d&EBHDv$wAYwL*v>4)n%#*-AyYfHXf}AmH-_ z5r*vOHuY#-{a6*PAVKJqI?boZXD;URh-h#)Tn?8f4CQKec~`Y%vE3;Dh(x7Q=+yew z<7NhMc|3tgEDj@rA` zgX-9J^kY z6^BW~WimO@HG+x7LQyDJ#M$Fq-^I_hZP`Gi7+MQEml<4sXjr&R9uXNuWG^aGE|Z!w z6p-KrjXS!r%T`38P#HGXCQ}GcD3;12qhl0Gl}f2p#6-%&%@E(j(FN6EdV7?q$c{>5 zT9F3i2*lEe=opnoqb1U*)u!!;xU$Q9SqjC;o|sL%P&1;|#OmXTyvFNw z8YO|mBC**yz|zgr`FlZRq0L5lD&P!vLeHYhZDT=3zUmP1VVD86AA@9 zPGEq4%Qj=DbSKD9VMwGct1~uf4}VeH2{sn!g&`cG@=F32PVZ}D>8=X*v!|9{fUjBZ zT(hiDx90iTiR|go>A7h}jU;HaTkGcCRQr{lEc}JB!34ggJ%0Hpu~P~Tb^;%*23%rRb*J;^igbAdsk=LcOm>0 sdT7V`oUF{Wc%^v8aJH|H2jibhToHP@xFE-<6wRMFnC(=N|37W}8=w12r~m)} diff --git a/test/controllermap.c b/test/controllermap.c index 6e31d0290..41cddeb00 100644 --- a/test/controllermap.c +++ b/test/controllermap.c @@ -32,7 +32,22 @@ #define MARKER_BUTTON 1 #define MARKER_AXIS 2 -#define BINDING_COUNT (SDL_CONTROLLER_BUTTON_MAX + SDL_CONTROLLER_AXIS_MAX) +enum +{ + SDL_CONTROLLER_BINDING_AXIS_LEFTX_NEGATIVE, + SDL_CONTROLLER_BINDING_AXIS_LEFTX_POSITIVE, + SDL_CONTROLLER_BINDING_AXIS_LEFTY_NEGATIVE, + SDL_CONTROLLER_BINDING_AXIS_LEFTY_POSITIVE, + SDL_CONTROLLER_BINDING_AXIS_RIGHTX_NEGATIVE, + SDL_CONTROLLER_BINDING_AXIS_RIGHTX_POSITIVE, + SDL_CONTROLLER_BINDING_AXIS_RIGHTY_NEGATIVE, + SDL_CONTROLLER_BINDING_AXIS_RIGHTY_POSITIVE, + SDL_CONTROLLER_BINDING_AXIS_TRIGGERLEFT, + SDL_CONTROLLER_BINDING_AXIS_TRIGGERRIGHT, + SDL_CONTROLLER_BINDING_AXIS_MAX, +}; + +#define BINDING_COUNT (SDL_CONTROLLER_BUTTON_MAX + SDL_CONTROLLER_BINDING_AXIS_MAX) static struct { @@ -56,12 +71,16 @@ static struct { 154, 249, 0.0, MARKER_BUTTON }, /* SDL_CONTROLLER_BUTTON_DPAD_DOWN */ { 116, 217, 0.0, MARKER_BUTTON }, /* SDL_CONTROLLER_BUTTON_DPAD_LEFT */ { 186, 217, 0.0, MARKER_BUTTON }, /* SDL_CONTROLLER_BUTTON_DPAD_RIGHT */ - { 75, 154, 0.0, MARKER_AXIS }, /* SDL_CONTROLLER_AXIS_LEFTX */ - { 75, 154, 90.0, MARKER_AXIS }, /* SDL_CONTROLLER_AXIS_LEFTY */ - { 305, 230, 0.0, MARKER_AXIS }, /* SDL_CONTROLLER_AXIS_RIGHTX */ - { 305, 230, 90.0, MARKER_AXIS }, /* SDL_CONTROLLER_AXIS_RIGHTY */ - { 91, 0, 90.0, MARKER_AXIS }, /* SDL_CONTROLLER_AXIS_TRIGGERLEFT */ - { 375, 0, 90.0, MARKER_AXIS }, /* SDL_CONTROLLER_AXIS_TRIGGERRIGHT */ + { 74, 153, 270.0, MARKER_AXIS }, /* SDL_CONTROLLER_BINDING_AXIS_LEFTX_NEGATIVE */ + { 74, 153, 90.0, MARKER_AXIS }, /* SDL_CONTROLLER_BINDING_AXIS_LEFTX_POSITIVE */ + { 74, 153, 0.0, MARKER_AXIS }, /* SDL_CONTROLLER_BINDING_AXIS_LEFTY_NEGATIVE */ + { 74, 153, 180.0, MARKER_AXIS }, /* SDL_CONTROLLER_BINDING_AXIS_LEFTY_POSITIVE */ + { 306, 231, 270.0, MARKER_AXIS }, /* SDL_CONTROLLER_BINDING_AXIS_RIGHTX_NEGATIVE */ + { 306, 231, 90.0, MARKER_AXIS }, /* SDL_CONTROLLER_BINDING_AXIS_RIGHTX_POSITIVE */ + { 306, 231, 0.0, MARKER_AXIS }, /* SDL_CONTROLLER_BINDING_AXIS_RIGHTY_NEGATIVE */ + { 306, 231, 180.0, MARKER_AXIS }, /* SDL_CONTROLLER_BINDING_AXIS_RIGHTY_POSITIVE */ + { 91, -20, 180.0, MARKER_AXIS }, /* SDL_CONTROLLER_BINDING_AXIS_TRIGGERLEFT */ + { 375, -20, 180.0, MARKER_AXIS }, /* SDL_CONTROLLER_BINDING_AXIS_TRIGGERRIGHT */ }; static int s_arrBindingOrder[BINDING_COUNT] = { @@ -69,16 +88,20 @@ static int s_arrBindingOrder[BINDING_COUNT] = { SDL_CONTROLLER_BUTTON_B, SDL_CONTROLLER_BUTTON_Y, SDL_CONTROLLER_BUTTON_X, - SDL_CONTROLLER_BUTTON_MAX + SDL_CONTROLLER_AXIS_LEFTX, - SDL_CONTROLLER_BUTTON_MAX + SDL_CONTROLLER_AXIS_LEFTY, + SDL_CONTROLLER_BUTTON_MAX + SDL_CONTROLLER_BINDING_AXIS_LEFTX_NEGATIVE, + SDL_CONTROLLER_BUTTON_MAX + SDL_CONTROLLER_BINDING_AXIS_LEFTX_POSITIVE, + SDL_CONTROLLER_BUTTON_MAX + SDL_CONTROLLER_BINDING_AXIS_LEFTY_NEGATIVE, + SDL_CONTROLLER_BUTTON_MAX + SDL_CONTROLLER_BINDING_AXIS_LEFTY_POSITIVE, SDL_CONTROLLER_BUTTON_LEFTSTICK, - SDL_CONTROLLER_BUTTON_MAX + SDL_CONTROLLER_AXIS_RIGHTX, - SDL_CONTROLLER_BUTTON_MAX + SDL_CONTROLLER_AXIS_RIGHTY, + SDL_CONTROLLER_BUTTON_MAX + SDL_CONTROLLER_BINDING_AXIS_RIGHTX_NEGATIVE, + SDL_CONTROLLER_BUTTON_MAX + SDL_CONTROLLER_BINDING_AXIS_RIGHTX_POSITIVE, + SDL_CONTROLLER_BUTTON_MAX + SDL_CONTROLLER_BINDING_AXIS_RIGHTY_NEGATIVE, + SDL_CONTROLLER_BUTTON_MAX + SDL_CONTROLLER_BINDING_AXIS_RIGHTY_POSITIVE, SDL_CONTROLLER_BUTTON_RIGHTSTICK, SDL_CONTROLLER_BUTTON_LEFTSHOULDER, - SDL_CONTROLLER_BUTTON_MAX + SDL_CONTROLLER_AXIS_TRIGGERLEFT, + SDL_CONTROLLER_BUTTON_MAX + SDL_CONTROLLER_BINDING_AXIS_TRIGGERLEFT, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER, - SDL_CONTROLLER_BUTTON_MAX + SDL_CONTROLLER_AXIS_TRIGGERRIGHT, + SDL_CONTROLLER_BUTTON_MAX + SDL_CONTROLLER_BINDING_AXIS_TRIGGERRIGHT, SDL_CONTROLLER_BUTTON_DPAD_UP, SDL_CONTROLLER_BUTTON_DPAD_RIGHT, SDL_CONTROLLER_BUTTON_DPAD_DOWN, @@ -88,7 +111,40 @@ static int s_arrBindingOrder[BINDING_COUNT] = { SDL_CONTROLLER_BUTTON_START, }; -static SDL_GameControllerButtonBind s_arrBindings[BINDING_COUNT]; +typedef struct +{ + SDL_GameControllerBindType bindType; + union + { + int button; + + struct { + int axis; + int axis_min; + int axis_max; + } axis; + + struct { + int hat; + int hat_mask; + } hat; + + } value; + +} SDL_GameControllerExtendedBind; + +static SDL_GameControllerExtendedBind s_arrBindings[BINDING_COUNT]; + +typedef struct +{ + SDL_bool m_bMoving; + int m_nStartingValue; + int m_nFarthestValue; +} AxisState; + +static int s_nNumAxes; +static AxisState *s_arrAxisState; + static int s_iCurrentBinding; static Uint32 s_unPendingAdvanceTime; static SDL_bool s_bBindingComplete; @@ -110,23 +166,6 @@ LoadTexture(SDL_Renderer *renderer, const char *file, SDL_bool transparent) if (transparent) { if (temp->format->palette) { SDL_SetColorKey(temp, SDL_TRUE, *(Uint8 *) temp->pixels); - } else { - switch (temp->format->BitsPerPixel) { - case 15: - SDL_SetColorKey(temp, SDL_TRUE, - (*(Uint16 *) temp->pixels) & 0x00007FFF); - break; - case 16: - SDL_SetColorKey(temp, SDL_TRUE, *(Uint16 *) temp->pixels); - break; - case 24: - SDL_SetColorKey(temp, SDL_TRUE, - (*(Uint32 *) temp->pixels) & 0x00FFFFFF); - break; - case 32: - SDL_SetColorKey(temp, SDL_TRUE, *(Uint32 *) temp->pixels); - break; - } } } @@ -143,9 +182,22 @@ LoadTexture(SDL_Renderer *renderer, const char *file, SDL_bool transparent) return texture; } -void SetCurrentBinding(int iBinding) +static int +StandardizeAxisValue(int nValue) { - SDL_GameControllerButtonBind *pBinding; + if (nValue > SDL_JOYSTICK_AXIS_MAX/2) { + return SDL_JOYSTICK_AXIS_MAX; + } else if (nValue < SDL_JOYSTICK_AXIS_MIN/2) { + return SDL_JOYSTICK_AXIS_MIN; + } else { + return 0; + } +} + +static void +SetCurrentBinding(int iBinding) +{ + SDL_GameControllerExtendedBind *pBinding; if (iBinding < 0) { return; @@ -161,14 +213,15 @@ void SetCurrentBinding(int iBinding) pBinding = &s_arrBindings[s_arrBindingOrder[s_iCurrentBinding]]; SDL_zerop(pBinding); + SDL_memset(s_arrAxisState, 0, s_nNumAxes*sizeof(*s_arrAxisState)); + s_unPendingAdvanceTime = 0; } - static void -ConfigureBinding(const SDL_GameControllerButtonBind *pBinding) +ConfigureBinding(const SDL_GameControllerExtendedBind *pBinding) { - SDL_GameControllerButtonBind *pCurrent; + SDL_GameControllerExtendedBind *pCurrent; int iIndex; int iCurrentElement = s_arrBindingOrder[s_iCurrentBinding]; @@ -221,6 +274,24 @@ ConfigureBinding(const SDL_GameControllerButtonBind *pBinding) s_unPendingAdvanceTime = SDL_GetTicks(); } +static SDL_bool +BMergeAxisBindings(int iIndex) +{ + SDL_GameControllerExtendedBind *pBindingA = &s_arrBindings[iIndex]; + SDL_GameControllerExtendedBind *pBindingB = &s_arrBindings[iIndex+1]; + if (pBindingA->bindType == SDL_CONTROLLER_BINDTYPE_AXIS && + pBindingB->bindType == SDL_CONTROLLER_BINDTYPE_AXIS && + pBindingA->value.axis.axis == pBindingB->value.axis.axis) { + if (pBindingA->value.axis.axis_min == pBindingB->value.axis.axis_min) { + pBindingA->value.axis.axis_min = pBindingA->value.axis.axis_max; + pBindingA->value.axis.axis_max = pBindingB->value.axis.axis_max; + pBindingB->bindType = SDL_CONTROLLER_BINDTYPE_NONE; + return SDL_TRUE; + } + } + return SDL_FALSE; +} + static void WatchJoystick(SDL_Joystick * joystick) { @@ -279,6 +350,9 @@ WatchJoystick(SDL_Joystick * joystick) nJoystickID = SDL_JoystickInstanceID(joystick); + s_nNumAxes = SDL_JoystickNumAxes(joystick); + s_arrAxisState = SDL_calloc(s_nNumAxes, sizeof(*s_arrAxisState)); + /* Loop, getting joystick events! */ while (!done && !s_bBindingComplete) { int iElement = s_arrBindingOrder[s_iCurrentBinding]; @@ -326,26 +400,35 @@ WatchJoystick(SDL_Joystick * joystick) break; case SDL_JOYAXISMOTION: if (event.jaxis.which == nJoystickID) { - uint32_t unAxisMask = (1 << event.jaxis.axis); - SDL_bool bDeflected = (event.jaxis.value <= -20000 || event.jaxis.value >= 20000); - if (bDeflected && !(unDeflectedAxes & unAxisMask)) { - SDL_GameControllerButtonBind binding; + AxisState *pAxisState = &s_arrAxisState[event.jaxis.axis]; + int nValue = event.jaxis.value; + int nCurrentDistance, nFarthestDistance; + if (!pAxisState->m_bMoving) { + pAxisState->m_bMoving = SDL_TRUE; + pAxisState->m_nStartingValue = nValue; + pAxisState->m_nFarthestValue = nValue; + } + nCurrentDistance = SDL_abs(nValue - pAxisState->m_nStartingValue); + nFarthestDistance = SDL_abs(pAxisState->m_nFarthestValue - pAxisState->m_nStartingValue); + if (nCurrentDistance > nFarthestDistance) { + pAxisState->m_nFarthestValue = nValue; + } + if (nCurrentDistance < 10000 && nFarthestDistance > 20000) { + /* We've gone out and back, let's bind this axis */ + SDL_GameControllerExtendedBind binding; SDL_zero(binding); binding.bindType = SDL_CONTROLLER_BINDTYPE_AXIS; - binding.value.axis = event.jaxis.axis; + binding.value.axis.axis = event.jaxis.axis; + binding.value.axis.axis_min = StandardizeAxisValue(pAxisState->m_nStartingValue); + binding.value.axis.axis_max = StandardizeAxisValue(pAxisState->m_nFarthestValue); ConfigureBinding(&binding); } - if (bDeflected) { - unDeflectedAxes |= unAxisMask; - } else { - unDeflectedAxes &= ~unAxisMask; - } } break; case SDL_JOYHATMOTION: if (event.jhat.which == nJoystickID) { if (event.jhat.value != SDL_HAT_CENTERED) { - SDL_GameControllerButtonBind binding; + SDL_GameControllerExtendedBind binding; SDL_zero(binding); binding.bindType = SDL_CONTROLLER_BINDTYPE_HAT; binding.value.hat.hat = event.jhat.hat; @@ -358,7 +441,7 @@ WatchJoystick(SDL_Joystick * joystick) break; case SDL_JOYBUTTONDOWN: if (event.jbutton.which == nJoystickID) { - SDL_GameControllerButtonBind binding; + SDL_GameControllerExtendedBind binding; SDL_zero(binding); binding.bindType = SDL_CONTROLLER_BINDTYPE_BUTTON; binding.value.button = event.jbutton.button; @@ -430,7 +513,7 @@ WatchJoystick(SDL_Joystick * joystick) SDL_strlcat(mapping, ",", SDL_arraysize(mapping)); for (iIndex = 0; iIndex < SDL_arraysize(s_arrBindings); ++iIndex) { - SDL_GameControllerButtonBind *pBinding = &s_arrBindings[iIndex]; + SDL_GameControllerExtendedBind *pBinding = &s_arrBindings[iIndex]; if (pBinding->bindType == SDL_CONTROLLER_BINDTYPE_NONE) { continue; } @@ -439,8 +522,56 @@ WatchJoystick(SDL_Joystick * joystick) SDL_GameControllerButton eButton = (SDL_GameControllerButton)iIndex; SDL_strlcat(mapping, SDL_GameControllerGetStringForButton(eButton), SDL_arraysize(mapping)); } else { - SDL_GameControllerAxis eAxis = (SDL_GameControllerAxis)(iIndex - SDL_CONTROLLER_BUTTON_MAX); - SDL_strlcat(mapping, SDL_GameControllerGetStringForAxis(eAxis), SDL_arraysize(mapping)); + const char *pszAxisName; + switch (iIndex - SDL_CONTROLLER_BUTTON_MAX) { + case SDL_CONTROLLER_BINDING_AXIS_LEFTX_NEGATIVE: + if (!BMergeAxisBindings(iIndex)) { + SDL_strlcat(mapping, "-", SDL_arraysize(mapping)); + } + pszAxisName = SDL_GameControllerGetStringForAxis(SDL_CONTROLLER_AXIS_LEFTX); + break; + case SDL_CONTROLLER_BINDING_AXIS_LEFTX_POSITIVE: + SDL_strlcat(mapping, "+", SDL_arraysize(mapping)); + pszAxisName = SDL_GameControllerGetStringForAxis(SDL_CONTROLLER_AXIS_LEFTX); + break; + case SDL_CONTROLLER_BINDING_AXIS_LEFTY_NEGATIVE: + if (!BMergeAxisBindings(iIndex)) { + SDL_strlcat(mapping, "-", SDL_arraysize(mapping)); + } + pszAxisName = SDL_GameControllerGetStringForAxis(SDL_CONTROLLER_AXIS_LEFTY); + break; + case SDL_CONTROLLER_BINDING_AXIS_LEFTY_POSITIVE: + SDL_strlcat(mapping, "+", SDL_arraysize(mapping)); + pszAxisName = SDL_GameControllerGetStringForAxis(SDL_CONTROLLER_AXIS_LEFTY); + break; + case SDL_CONTROLLER_BINDING_AXIS_RIGHTX_NEGATIVE: + if (!BMergeAxisBindings(iIndex)) { + SDL_strlcat(mapping, "-", SDL_arraysize(mapping)); + } + pszAxisName = SDL_GameControllerGetStringForAxis(SDL_CONTROLLER_AXIS_RIGHTX); + break; + case SDL_CONTROLLER_BINDING_AXIS_RIGHTX_POSITIVE: + SDL_strlcat(mapping, "+", SDL_arraysize(mapping)); + pszAxisName = SDL_GameControllerGetStringForAxis(SDL_CONTROLLER_AXIS_RIGHTX); + break; + case SDL_CONTROLLER_BINDING_AXIS_RIGHTY_NEGATIVE: + if (!BMergeAxisBindings(iIndex)) { + SDL_strlcat(mapping, "-", SDL_arraysize(mapping)); + } + pszAxisName = SDL_GameControllerGetStringForAxis(SDL_CONTROLLER_AXIS_RIGHTY); + break; + case SDL_CONTROLLER_BINDING_AXIS_RIGHTY_POSITIVE: + SDL_strlcat(mapping, "+", SDL_arraysize(mapping)); + pszAxisName = SDL_GameControllerGetStringForAxis(SDL_CONTROLLER_AXIS_RIGHTY); + break; + case SDL_CONTROLLER_BINDING_AXIS_TRIGGERLEFT: + pszAxisName = SDL_GameControllerGetStringForAxis(SDL_CONTROLLER_AXIS_TRIGGERLEFT); + break; + case SDL_CONTROLLER_BINDING_AXIS_TRIGGERRIGHT: + pszAxisName = SDL_GameControllerGetStringForAxis(SDL_CONTROLLER_AXIS_TRIGGERRIGHT); + break; + } + SDL_strlcat(mapping, pszAxisName, SDL_arraysize(mapping)); } SDL_strlcat(mapping, ":", SDL_arraysize(mapping)); @@ -450,7 +581,19 @@ WatchJoystick(SDL_Joystick * joystick) SDL_snprintf(pszElement, sizeof(pszElement), "b%d", pBinding->value.button); break; case SDL_CONTROLLER_BINDTYPE_AXIS: - SDL_snprintf(pszElement, sizeof(pszElement), "a%d", pBinding->value.axis); + if (pBinding->value.axis.axis_min == 0 && pBinding->value.axis.axis_max == SDL_JOYSTICK_AXIS_MIN) { + /* The negative half axis */ + SDL_snprintf(pszElement, sizeof(pszElement), "-a%d", pBinding->value.axis.axis); + } else if (pBinding->value.axis.axis_min == 0 && pBinding->value.axis.axis_max == SDL_JOYSTICK_AXIS_MAX) { + /* The positive half axis */ + SDL_snprintf(pszElement, sizeof(pszElement), "+a%d", pBinding->value.axis.axis); + } else { + SDL_snprintf(pszElement, sizeof(pszElement), "a%d", pBinding->value.axis.axis); + if (pBinding->value.axis.axis_min > pBinding->value.axis.axis_max) { + /* Invert the axis */ + SDL_strlcat(pszElement, "~", SDL_arraysize(pszElement)); + } + } break; case SDL_CONTROLLER_BINDTYPE_HAT: SDL_snprintf(pszElement, sizeof(pszElement), "h%d.%d", pBinding->value.hat.hat, pBinding->value.hat.hat_mask); @@ -467,6 +610,9 @@ WatchJoystick(SDL_Joystick * joystick) /* Print to stdout as well so the user can cat the output somewhere */ printf("%s\n", mapping); } + + SDL_free(s_arrAxisState); + s_arrAxisState = NULL; SDL_DestroyRenderer(screen); SDL_DestroyWindow(window); diff --git a/test/testgamecontroller.c b/test/testgamecontroller.c index 373c84274..117e28026 100644 --- a/test/testgamecontroller.c +++ b/test/testgamecontroller.c @@ -53,12 +53,12 @@ static const struct { int x; int y; } button_positions[] = { /* This is indexed by SDL_GameControllerAxis. */ static const struct { int x; int y; double angle; } axis_positions[] = { - {75, 154, 0.0}, /* LEFTX */ - {75, 154, 90.0}, /* LEFTY */ - {305, 230, 0.0}, /* RIGHTX */ - {305, 230, 90.0}, /* RIGHTY */ - {91, 0, 90.0}, /* TRIGGERLEFT */ - {375, 0, 90.0}, /* TRIGGERRIGHT */ + {74, 153, 270.0}, /* LEFTX */ + {74, 153, 0.0}, /* LEFTY */ + {306, 231, 270.0}, /* RIGHTX */ + {306, 231, 0.0}, /* RIGHTY */ + {91, -20, 0.0}, /* TRIGGERLEFT */ + {375, -20, 0.0}, /* TRIGGERRIGHT */ }; SDL_Renderer *screen = NULL; @@ -80,10 +80,6 @@ LoadTexture(SDL_Renderer *renderer, const char *file, SDL_bool transparent) if (transparent) { if (temp->format->BytesPerPixel == 1) { SDL_SetColorKey(temp, SDL_TRUE, *(Uint8 *)temp->pixels); - } else { - SDL_assert(!temp->format->palette); - SDL_assert(temp->format->BitsPerPixel == 24); - SDL_SetColorKey(temp, SDL_TRUE, (*(Uint32 *)temp->pixels) & 0x00FFFFFF); } } @@ -112,6 +108,13 @@ loop(void *arg) while (SDL_PollEvent(&event)) { switch (event.type) { + case SDL_CONTROLLERAXISMOTION: + SDL_Log("Controller axis %s changed to %d\n", SDL_GameControllerGetStringForAxis(event.caxis.axis), event.caxis.value); + break; + case SDL_CONTROLLERBUTTONDOWN: + case SDL_CONTROLLERBUTTONUP: + SDL_Log("Controller button %s %s\n", SDL_GameControllerGetStringForButton(event.cbutton.button), event.cbutton.state ? "pressed" : "released"); + break; case SDL_KEYDOWN: if (event.key.keysym.sym != SDLK_ESCAPE) { break;