mirrors/SDL
1
0
Fork 0
mirror of https://github.com/libsdl-org/SDL.git synced 2025-10-04 00:46:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use C99 bool internally in SDL

Browse Source
This commit is contained in:
Sam Lantinga
2024-08-22 09:21:26 -07:00
parent 6501e90018
commit 8f546bb3c9
450 changed files with 6046 additions and 6033 deletions
Download Patch File Download Diff File Expand all files Collapse all files

238
src/joystick/SDL_gamepad.c
View File

@@ -55,7 +55,7 @@
#define SDL_GAMEPAD_SDKLE_FIELD "sdk<=:"
#define SDL_GAMEPAD_SDKLE_FIELD_SIZE SDL_strlen(SDL_GAMEPAD_SDKLE_FIELD)
static SDL_bool SDL_gamepads_initialized;
static bool SDL_gamepads_initialized;
static SDL_Gamepad *SDL_gamepads SDL_GUARDED_BY(SDL_joystick_lock) = NULL;
// The face button style of a gamepad
@@ -141,25 +141,25 @@ static SDL_vidpid_list SDL_allowed_gamepads = {
SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT, 0, 0, NULL,
NULL, 0, 0, NULL,
0, NULL,
SDL_FALSE
false
};
static SDL_vidpid_list SDL_ignored_gamepads = {
SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES, 0, 0, NULL,
NULL, 0, 0, NULL,
0, NULL,
SDL_FALSE
false
};
static GamepadMapping_t *SDL_PrivateAddMappingForGUID(SDL_GUID jGUID, const char *mappingString, SDL_bool *existing, SDL_GamepadMappingPriority priority);
static GamepadMapping_t *SDL_PrivateAddMappingForGUID(SDL_GUID jGUID, const char *mappingString, bool *existing, SDL_GamepadMappingPriority priority);
static void SDL_PrivateLoadButtonMapping(SDL_Gamepad *gamepad, GamepadMapping_t *pGamepadMapping);
static GamepadMapping_t *SDL_PrivateGetGamepadMapping(SDL_JoystickID instance_id, SDL_bool create_mapping);
static GamepadMapping_t *SDL_PrivateGetGamepadMapping(SDL_JoystickID instance_id, bool create_mapping);
static int SDL_SendGamepadAxis(Uint64 timestamp, SDL_Gamepad *gamepad, SDL_GamepadAxis axis, Sint16 value);
static int SDL_SendGamepadButton(Uint64 timestamp, SDL_Gamepad *gamepad, SDL_GamepadButton button, Uint8 state);
static SDL_bool HasSameOutput(SDL_GamepadBinding *a, SDL_GamepadBinding *b)
static bool HasSameOutput(SDL_GamepadBinding *a, SDL_GamepadBinding *b)
{
if (a->output_type != b->output_type) {
return SDL_FALSE;
return false;
}
if (a->output_type == SDL_GAMEPAD_BINDTYPE_AXIS) {
@@ -422,7 +422,7 @@ static SDL_bool SDLCALL SDL_GamepadEventWatcher(void *userdata, SDL_Event *event
break;
}
return SDL_TRUE;
return true;
}
/* SDL defines sensor orientation relative to the device natural
@@ -501,7 +501,7 @@ static void PushMappingChangeTracking(void)
return;
}
for (i = 0; i < num_joysticks; ++i) {
tracker->joystick_mappings[i] = SDL_PrivateGetGamepadMapping(tracker->joysticks[i], SDL_FALSE);
tracker->joystick_mappings[i] = SDL_PrivateGetGamepadMapping(tracker->joysticks[i], false);
}
}
@@ -524,7 +524,7 @@ static void AddMappingChangeTracking(GamepadMapping_t *mapping)
}
}
static SDL_bool HasMappingChangeTracking(MappingChangeTracker *tracker, GamepadMapping_t *mapping)
static bool HasMappingChangeTracking(MappingChangeTracker *tracker, GamepadMapping_t *mapping)
{
int i;
@@ -532,10 +532,10 @@ static SDL_bool HasMappingChangeTracking(MappingChangeTracker *tracker, GamepadM
for (i = 0; i < tracker->num_changed_mappings; ++i) {
if (tracker->changed_mappings[i] == mapping) {
return SDL_TRUE;
return true;
}
}
return SDL_FALSE;
return false;
}
static void PopMappingChangeTracking(void)
@@ -559,16 +559,16 @@ static void PopMappingChangeTracking(void)
// Looking up the new mapping might create one and associate it with the gamepad (and generate events)
SDL_JoystickID joystick = tracker->joysticks[i];
SDL_Gamepad *gamepad = SDL_GetGamepadFromID(joystick);
GamepadMapping_t *new_mapping = SDL_PrivateGetGamepadMapping(joystick, SDL_FALSE);
GamepadMapping_t *new_mapping = SDL_PrivateGetGamepadMapping(joystick, false);
GamepadMapping_t *old_mapping = gamepad ? gamepad->mapping : tracker->joystick_mappings[i];
if (new_mapping && !old_mapping) {
SDL_RemoveFromHashTable(s_gamepadInstanceIDs, (void *)(uintptr_t)joystick);
SDL_InsertIntoHashTable(s_gamepadInstanceIDs, (void *)(uintptr_t)joystick, (const void *)SDL_TRUE);
SDL_InsertIntoHashTable(s_gamepadInstanceIDs, (void *)(uintptr_t)joystick, (const void *)true);
SDL_PrivateGamepadAdded(joystick);
} else if (old_mapping && !new_mapping) {
SDL_RemoveFromHashTable(s_gamepadInstanceIDs, (void *)(uintptr_t)joystick);
SDL_InsertIntoHashTable(s_gamepadInstanceIDs, (void *)(uintptr_t)joystick, (const void *)SDL_FALSE);
SDL_InsertIntoHashTable(s_gamepadInstanceIDs, (void *)(uintptr_t)joystick, (const void *)false);
SDL_PrivateGamepadRemoved(joystick);
} else if (old_mapping != new_mapping || HasMappingChangeTracking(tracker, new_mapping)) {
if (gamepad) {
@@ -595,7 +595,7 @@ static GamepadMapping_t *SDL_CreateMappingForAndroidGamepad(SDL_GUID guid)
(1 << SDL_GAMEPAD_BUTTON_EAST) |
(1 << SDL_GAMEPAD_BUTTON_WEST) |
(1 << SDL_GAMEPAD_BUTTON_NORTH));
SDL_bool existing;
bool existing;
char mapping_string[1024];
int button_mask;
int axis_mask;
@@ -693,7 +693,7 @@ static GamepadMapping_t *SDL_CreateMappingForAndroidGamepad(SDL_GUID guid)
*/
static GamepadMapping_t *SDL_CreateMappingForHIDAPIGamepad(SDL_GUID guid)
{
SDL_bool existing;
bool existing;
char mapping_string[1024];
Uint16 vendor;
Uint16 product;
@@ -746,7 +746,7 @@ static GamepadMapping_t *SDL_CreateMappingForHIDAPIGamepad(SDL_GUID guid)
case k_eWiiExtensionControllerType_Nunchuk:
{
// FIXME: Should we map this to the left or right side?
const SDL_bool map_nunchuck_left_side = SDL_TRUE;
const bool map_nunchuck_left_side = true;
if (map_nunchuck_left_side) {
SDL_strlcat(mapping_string, "a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,lefttrigger:a4,leftx:a0,lefty:a1,start:b6,x:b2,y:b3,", sizeof(mapping_string));
@@ -755,7 +755,7 @@ static GamepadMapping_t *SDL_CreateMappingForHIDAPIGamepad(SDL_GUID guid)
}
} break;
default:
if (SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_VERTICAL_JOY_CONS, SDL_FALSE)) {
if (SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_VERTICAL_JOY_CONS, false)) {
// Vertical mode
if (guid.data[15] == k_eSwitchDeviceInfoControllerType_JoyConLeft) {
SDL_strlcat(mapping_string, "back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,misc1:b11,paddle2:b13,paddle4:b15,", sizeof(mapping_string));
@@ -838,7 +838,7 @@ static GamepadMapping_t *SDL_CreateMappingForHIDAPIGamepad(SDL_GUID guid)
*/
static GamepadMapping_t *SDL_CreateMappingForRAWINPUTGamepad(SDL_GUID guid)
{
SDL_bool existing;
bool existing;
char mapping_string[1024];
SDL_strlcpy(mapping_string, "none,*,", sizeof(mapping_string));
@@ -852,7 +852,7 @@ static GamepadMapping_t *SDL_CreateMappingForRAWINPUTGamepad(SDL_GUID guid)
*/
static GamepadMapping_t *SDL_CreateMappingForWGIGamepad(SDL_GUID guid)
{
SDL_bool existing;
bool existing;
char mapping_string[1024];
if (guid.data[15] != SDL_JOYSTICK_TYPE_GAMEPAD) {
@@ -868,7 +868,7 @@ static GamepadMapping_t *SDL_CreateMappingForWGIGamepad(SDL_GUID guid)
/*
* Helper function to scan the mappings database for a gamepad with the specified GUID
*/
static GamepadMapping_t *SDL_PrivateMatchGamepadMappingForGUID(SDL_GUID guid, SDL_bool match_version)
static GamepadMapping_t *SDL_PrivateMatchGamepadMappingForGUID(SDL_GUID guid, bool match_version)
{
GamepadMapping_t *mapping, *best_match = NULL;
Uint16 crc = 0;
@@ -920,11 +920,11 @@ static GamepadMapping_t *SDL_PrivateMatchGamepadMappingForGUID(SDL_GUID guid, SD
/*
* Helper function to scan the mappings database for a gamepad with the specified GUID
*/
static GamepadMapping_t *SDL_PrivateGetGamepadMappingForGUID(SDL_GUID guid, SDL_bool adding_mapping)
static GamepadMapping_t *SDL_PrivateGetGamepadMappingForGUID(SDL_GUID guid, bool adding_mapping)
{
GamepadMapping_t *mapping;
mapping = SDL_PrivateMatchGamepadMappingForGUID(guid, SDL_TRUE);
mapping = SDL_PrivateMatchGamepadMappingForGUID(guid, true);
if (mapping) {
return mapping;
}
@@ -938,7 +938,7 @@ static GamepadMapping_t *SDL_PrivateGetGamepadMappingForGUID(SDL_GUID guid, SDL_
if (SDL_JoystickGUIDUsesVersion(guid)) {
// Try again, ignoring the version
mapping = SDL_PrivateMatchGamepadMappingForGUID(guid, SDL_FALSE);
mapping = SDL_PrivateMatchGamepadMappingForGUID(guid, false);
if (mapping) {
return mapping;
}
@@ -1092,7 +1092,7 @@ SDL_COMPILE_TIME_ASSERT(map_StringForGamepadButton, SDL_arraysize(map_StringForG
/*
* convert a string to its enum equivalent
*/
static SDL_GamepadButton SDL_PrivateGetGamepadButtonFromString(const char *str, SDL_bool baxy)
static SDL_GamepadButton SDL_PrivateGetGamepadButtonFromString(const char *str, bool baxy)
{
int i;
@@ -1124,7 +1124,7 @@ static SDL_GamepadButton SDL_PrivateGetGamepadButtonFromString(const char *str,
}
SDL_GamepadButton SDL_GetGamepadButtonFromString(const char *str)
{
return SDL_PrivateGetGamepadButtonFromString(str, SDL_FALSE);
return SDL_PrivateGetGamepadButtonFromString(str, false);
}
/*
@@ -1141,17 +1141,17 @@ const char *SDL_GetGamepadStringForButton(SDL_GamepadButton button)
/*
* given a gamepad button name and a joystick name update our mapping structure with it
*/
static SDL_bool SDL_PrivateParseGamepadElement(SDL_Gamepad *gamepad, const char *szGameButton, const char *szJoystickButton)
static bool SDL_PrivateParseGamepadElement(SDL_Gamepad *gamepad, const char *szGameButton, const char *szJoystickButton)
{
SDL_GamepadBinding bind;
SDL_GamepadButton button;
SDL_GamepadAxis axis;
SDL_bool invert_input = SDL_FALSE;
bool invert_input = false;
char half_axis_input = 0;
char half_axis_output = 0;
int i;
SDL_GamepadBinding *new_bindings;
SDL_bool baxy_mapping = SDL_FALSE;
bool baxy_mapping = false;
SDL_AssertJoysticksLocked();
@@ -1162,7 +1162,7 @@ static SDL_bool SDL_PrivateParseGamepadElement(SDL_Gamepad *gamepad, const char
}
if (SDL_strstr(gamepad->mapping->mapping, ",hint:SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1") != NULL) {
baxy_mapping = SDL_TRUE;
baxy_mapping = true;
}
axis = SDL_GetGamepadAxisFromString(szGameButton);
@@ -1189,14 +1189,14 @@ static SDL_bool SDL_PrivateParseGamepadElement(SDL_Gamepad *gamepad, const char
bind.output_type = SDL_GAMEPAD_BINDTYPE_BUTTON;
bind.output.button = button;
} else {
return SDL_FALSE;
return false;
}
if (*szJoystickButton == '+' || *szJoystickButton == '-') {
half_axis_input = *szJoystickButton++;
}
if (szJoystickButton[SDL_strlen(szJoystickButton) - 1] == '~') {
invert_input = SDL_TRUE;
invert_input = true;
}
if (szJoystickButton[0] == 'a' && SDL_isdigit((unsigned char)szJoystickButton[1])) {
@@ -1228,13 +1228,13 @@ static SDL_bool SDL_PrivateParseGamepadElement(SDL_Gamepad *gamepad, const char
bind.input.hat.hat = hat;
bind.input.hat.hat_mask = mask;
} else {
return SDL_FALSE;
return false;
}
for (i = 0; i < gamepad->num_bindings; ++i) {
if (SDL_memcmp(&gamepad->bindings[i], &bind, sizeof(bind)) == 0) {
// We already have this binding, could be different face button names?
return SDL_TRUE;
return true;
}
}
@@ -1244,11 +1244,11 @@ static SDL_bool SDL_PrivateParseGamepadElement(SDL_Gamepad *gamepad, const char
SDL_free(gamepad->bindings);
gamepad->num_bindings = 0;
gamepad->bindings = NULL;
return SDL_FALSE;
return false;
}
gamepad->bindings = new_bindings;
gamepad->bindings[gamepad->num_bindings - 1] = bind;
return SDL_TRUE;
return true;
}
/*
@@ -1258,7 +1258,7 @@ static int SDL_PrivateParseGamepadConfigString(SDL_Gamepad *gamepad, const char
{
char szGameButton[20];
char szJoystickButton[20];
SDL_bool bGameButton = SDL_TRUE;
bool bGameButton = true;
int i = 0;
const char *pchPos = pchString;
@@ -1268,12 +1268,12 @@ static int SDL_PrivateParseGamepadConfigString(SDL_Gamepad *gamepad, const char
while (pchPos && *pchPos) {
if (*pchPos == ':') {
i = 0;
bGameButton = SDL_FALSE;
bGameButton = false;
} else if (*pchPos == ' ') {
} else if (*pchPos == ',') {
i = 0;
bGameButton = SDL_TRUE;
bGameButton = true;
SDL_PrivateParseGamepadElement(gamepad, szGameButton, szJoystickButton);
SDL_zeroa(szGameButton);
SDL_zeroa(szJoystickButton);
@@ -1529,7 +1529,7 @@ static char *SDL_PrivateGetGamepadMappingFromMappingString(const char *pMapping)
/*
* Helper function to add a mapping for a guid
*/
static GamepadMapping_t *SDL_PrivateAddMappingForGUID(SDL_GUID jGUID, const char *mappingString, SDL_bool *existing, SDL_GamepadMappingPriority priority)
static GamepadMapping_t *SDL_PrivateAddMappingForGUID(SDL_GUID jGUID, const char *mappingString, bool *existing, SDL_GamepadMappingPriority priority)
{
char *pchName;
char *pchMapping;
@@ -1595,7 +1595,7 @@ static GamepadMapping_t *SDL_PrivateAddMappingForGUID(SDL_GUID jGUID, const char
PushMappingChangeTracking();
pGamepadMapping = SDL_PrivateGetGamepadMappingForGUID(jGUID, SDL_TRUE);
pGamepadMapping = SDL_PrivateGetGamepadMappingForGUID(jGUID, true);
if (pGamepadMapping) {
// Only overwrite the mapping if the priority is the same or higher.
if (pGamepadMapping->priority <= priority) {
@@ -1610,7 +1610,7 @@ static GamepadMapping_t *SDL_PrivateAddMappingForGUID(SDL_GUID jGUID, const char
SDL_free(pchMapping);
}
if (existing) {
*existing = SDL_TRUE;
*existing = true;
}
AddMappingChangeTracking(pGamepadMapping);
} else {
@@ -1645,7 +1645,7 @@ static GamepadMapping_t *SDL_PrivateAddMappingForGUID(SDL_GUID jGUID, const char
s_pSupportedGamepads = pGamepadMapping;
}
if (existing) {
*existing = SDL_FALSE;
*existing = false;
}
}
@@ -1663,12 +1663,12 @@ static GamepadMapping_t *SDL_PrivateGetGamepadMappingForNameAndGUID(const char *
SDL_AssertJoysticksLocked();
mapping = SDL_PrivateGetGamepadMappingForGUID(guid, SDL_FALSE);
mapping = SDL_PrivateGetGamepadMappingForGUID(guid, false);
#ifdef SDL_PLATFORM_LINUX
if (!mapping && name) {
if (SDL_strstr(name, "Xbox 360 Wireless Receiver")) {
// The Linux driver xpad.c maps the wireless dpad to buttons
SDL_bool existing;
bool existing;
mapping = SDL_PrivateAddMappingForGUID(guid,
"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,",
&existing, SDL_GAMEPAD_MAPPING_PRIORITY_DEFAULT);
@@ -1706,7 +1706,7 @@ static void SDL_PrivateAppendToMappingString(char *mapping_string,
(void)SDL_snprintf(buffer, sizeof(buffer), "h%i.%i", mapping->target >> 4, mapping->target & 0x0F);
break;
default:
SDL_assert(SDL_FALSE);
SDL_assert(false);
}
SDL_strlcat(mapping_string, buffer, mapping_string_len);
@@ -1717,7 +1717,7 @@ static GamepadMapping_t *SDL_PrivateGenerateAutomaticGamepadMapping(const char *
SDL_GUID guid,
SDL_GamepadMapping *raw_map)
{
SDL_bool existing;
bool existing;
char name_string[128];
char mapping[1024];
@@ -1770,7 +1770,7 @@ static GamepadMapping_t *SDL_PrivateGenerateAutomaticGamepadMapping(const char *
return SDL_PrivateAddMappingForGUID(guid, mapping, &existing, SDL_GAMEPAD_MAPPING_PRIORITY_DEFAULT);
}
static GamepadMapping_t *SDL_PrivateGetGamepadMapping(SDL_JoystickID instance_id, SDL_bool create_mapping)
static GamepadMapping_t *SDL_PrivateGetGamepadMapping(SDL_JoystickID instance_id, bool create_mapping)
{
const char *name;
SDL_GUID guid;
@@ -1855,7 +1855,7 @@ int SDL_AddGamepadMappingsFromIO(SDL_IOStream *src, SDL_bool closeio)
int SDL_AddGamepadMappingsFromFile(const char *file)
{
return SDL_AddGamepadMappingsFromIO(SDL_IOFromFile(file, "rb"), 1);
return SDL_AddGamepadMappingsFromIO(SDL_IOFromFile(file, "rb"), true);
}
int SDL_ReloadGamepadMappings(void)
@@ -1928,9 +1928,9 @@ static int SDL_PrivateAddGamepadMapping(const char *mappingString, SDL_GamepadMa
char *remapped = NULL;
char *pchGUID;
SDL_GUID jGUID;
SDL_bool is_default_mapping = SDL_FALSE;
SDL_bool is_xinput_mapping = SDL_FALSE;
SDL_bool existing = SDL_FALSE;
bool is_default_mapping = false;
bool is_xinput_mapping = false;
bool existing = false;
GamepadMapping_t *pGamepadMapping;
int retval = -1;
@@ -1945,17 +1945,17 @@ static int SDL_PrivateAddGamepadMapping(const char *mappingString, SDL_GamepadMa
tmp = SDL_strstr(mappingString, SDL_GAMEPAD_HINT_FIELD);
if (tmp) {
SDL_bool default_value, value, negate;
bool default_value, value, negate;
int len;
char hint[128];
tmp += SDL_GAMEPAD_HINT_FIELD_SIZE;
if (*tmp == '!') {
negate = SDL_TRUE;
negate = true;
++tmp;
} else {
negate = SDL_FALSE;
negate = false;
}
len = 0;
@@ -1968,7 +1968,7 @@ static int SDL_PrivateAddGamepadMapping(const char *mappingString, SDL_GamepadMa
tmp += 2;
default_value = SDL_atoi(tmp);
} else {
default_value = SDL_FALSE;
default_value = false;
}
if (SDL_strcmp(hint, "SDL_GAMECONTROLLER_USE_BUTTON_LABELS") == 0) {
@@ -2025,9 +2025,9 @@ static int SDL_PrivateAddGamepadMapping(const char *mappingString, SDL_GamepadMa
goto done;
}
if (!SDL_strcasecmp(pchGUID, "default")) {
is_default_mapping = SDL_TRUE;
is_default_mapping = true;
} else if (!SDL_strcasecmp(pchGUID, "xinput")) {
is_xinput_mapping = SDL_TRUE;
is_xinput_mapping = true;
}
jGUID = SDL_StringToGUID(pchGUID);
SDL_free(pchGUID);
@@ -2078,7 +2078,7 @@ static char *CreateMappingString(GamepadMapping_t *mapping, SDL_GUID guid)
char *pMappingString, *pPlatformString;
char pchGUID[33];
size_t needed;
SDL_bool need_platform = SDL_FALSE;
bool need_platform = false;
const char *platform = NULL;
SDL_AssertJoysticksLocked();
@@ -2090,7 +2090,7 @@ static char *CreateMappingString(GamepadMapping_t *mapping, SDL_GUID guid)
if (!SDL_strstr(mapping->mapping, SDL_GAMEPAD_PLATFORM_FIELD)) {
// add memory for ',' + platform:PLATFORM
need_platform = SDL_TRUE;
need_platform = true;
if (mapping->mapping[SDL_strlen(mapping->mapping) - 1] != ',') {
needed += 1;
}
@@ -2145,10 +2145,10 @@ char **SDL_GetGamepadMappings(int *count)
}
size_t final_allocation = sizeof (char *); // for the NULL terminator element.
SDL_bool failed = SDL_FALSE;
bool failed = false;
mappings = (char **) SDL_calloc(num_mappings + 1, sizeof (char *));
if (!mappings) {
failed = SDL_TRUE;
failed = true;
} else {
int i = 0;
for (GamepadMapping_t *mapping = s_pSupportedGamepads; mapping; mapping = mapping->next) {
@@ -2158,7 +2158,7 @@ char **SDL_GetGamepadMappings(int *count)
char *mappingstr = CreateMappingString(mapping, mapping->guid);
if (!mappingstr) {
failed = SDL_TRUE;
failed = true;
break; // error string is already set.
}
@@ -2210,7 +2210,7 @@ char *SDL_GetGamepadMappingForGUID(SDL_GUID guid)
SDL_LockJoysticks();
{
GamepadMapping_t *mapping = SDL_PrivateGetGamepadMappingForGUID(guid, SDL_FALSE);
GamepadMapping_t *mapping = SDL_PrivateGetGamepadMappingForGUID(guid, false);
if (mapping) {
retval = CreateMappingString(mapping, guid);
} else {
@@ -2305,7 +2305,7 @@ static void SDL_LoadGamepadHints(void)
* Usually this will just be SDL_HINT_GAMECONTROLLERCONFIG_FILE, but for
* Android, we want to get the internal storage path.
*/
static SDL_bool SDL_GetGamepadMappingFilePath(char *path, size_t size)
static bool SDL_GetGamepadMappingFilePath(char *path, size_t size)
{
const char *hint = SDL_GetHint(SDL_HINT_GAMECONTROLLERCONFIG_FILE);
if (hint && *hint) {
@@ -2315,7 +2315,7 @@ static SDL_bool SDL_GetGamepadMappingFilePath(char *path, size_t size)
#ifdef SDL_PLATFORM_ANDROID
return SDL_snprintf(path, size, "%s/gamepad_map.txt", SDL_GetAndroidInternalStoragePath()) < size;
#else
return SDL_FALSE;
return false;
#endif
}
@@ -2360,7 +2360,7 @@ int SDL_InitGamepads(void)
int i;
SDL_JoystickID *joysticks;
SDL_gamepads_initialized = SDL_TRUE;
SDL_gamepads_initialized = true;
// Watch for joystick events and fire gamepad ones if needed
SDL_AddEventWatch(SDL_GamepadEventWatcher, NULL);
@@ -2394,9 +2394,9 @@ SDL_bool SDL_HasGamepad(void)
SDL_free(joysticks);
}
if (num_gamepads > 0) {
return SDL_TRUE;
return true;
}
return SDL_FALSE;
return false;
}
SDL_JoystickID *SDL_GetGamepads(int *count)
@@ -2426,7 +2426,7 @@ const char *SDL_GetGamepadNameForID(SDL_JoystickID instance_id)
SDL_LockJoysticks();
{
GamepadMapping_t *mapping = SDL_PrivateGetGamepadMapping(instance_id, SDL_TRUE);
GamepadMapping_t *mapping = SDL_PrivateGetGamepadMapping(instance_id, true);
if (mapping) {
if (SDL_strcmp(mapping->name, "*") == 0) {
retval = SDL_GetJoystickNameForID(instance_id);
@@ -2476,7 +2476,7 @@ SDL_GamepadType SDL_GetGamepadTypeForID(SDL_JoystickID instance_id)
SDL_LockJoysticks();
{
GamepadMapping_t *mapping = SDL_PrivateGetGamepadMapping(instance_id, SDL_TRUE);
GamepadMapping_t *mapping = SDL_PrivateGetGamepadMapping(instance_id, true);
if (mapping) {
char *type_string, *comma;
@@ -2525,7 +2525,7 @@ char *SDL_GetGamepadMappingForID(SDL_JoystickID instance_id)
SDL_LockJoysticks();
{
GamepadMapping_t *mapping = SDL_PrivateGetGamepadMapping(instance_id, SDL_TRUE);
GamepadMapping_t *mapping = SDL_PrivateGetGamepadMapping(instance_id, true);
if (mapping) {
char pchGUID[33];
SDL_GUID guid = SDL_GetJoystickGUIDForID(instance_id);
@@ -2541,16 +2541,16 @@ char *SDL_GetGamepadMappingForID(SDL_JoystickID instance_id)
/*
* Return 1 if the joystick with this name and GUID is a supported gamepad
*/
SDL_bool SDL_IsGamepadNameAndGUID(const char *name, SDL_GUID guid)
bool SDL_IsGamepadNameAndGUID(const char *name, SDL_GUID guid)
{
SDL_bool retval;
bool retval;
SDL_LockJoysticks();
{
if (s_pDefaultMapping || SDL_PrivateGetGamepadMappingForNameAndGUID(name, guid) != NULL) {
retval = SDL_TRUE;
retval = true;
} else {
retval = SDL_FALSE;
retval = false;
}
}
SDL_UnlockJoysticks();
@@ -2563,22 +2563,22 @@ SDL_bool SDL_IsGamepadNameAndGUID(const char *name, SDL_GUID guid)
*/
SDL_bool SDL_IsGamepad(SDL_JoystickID instance_id)
{
SDL_bool retval;
bool retval;
SDL_LockJoysticks();
{
const void *value;
if (SDL_FindInHashTable(s_gamepadInstanceIDs, (void *)(uintptr_t)instance_id, &value)) {
retval = (SDL_bool)(uintptr_t)value;
retval = (bool)(uintptr_t)value;
} else {
if (SDL_PrivateGetGamepadMapping(instance_id, SDL_TRUE) != NULL) {
retval = SDL_TRUE;
if (SDL_PrivateGetGamepadMapping(instance_id, true) != NULL) {
retval = true;
} else {
retval = SDL_FALSE;
retval = false;
}
if (!s_gamepadInstanceIDs) {
s_gamepadInstanceIDs = SDL_CreateHashTable(NULL, 4, SDL_HashID, SDL_KeyMatchID, NULL, SDL_FALSE);
s_gamepadInstanceIDs = SDL_CreateHashTable(NULL, 4, SDL_HashID, SDL_KeyMatchID, NULL, false);
}
SDL_InsertIntoHashTable(s_gamepadInstanceIDs, (void *)(uintptr_t)instance_id, (void *)(uintptr_t)retval);
}
@@ -2591,7 +2591,7 @@ SDL_bool SDL_IsGamepad(SDL_JoystickID instance_id)
/*
* Return 1 if the gamepad should be ignored by SDL
*/
SDL_bool SDL_ShouldIgnoreGamepad(const char *name, SDL_GUID guid)
bool SDL_ShouldIgnoreGamepad(const char *name, SDL_GUID guid)
{
Uint16 vendor;
Uint16 product;
@@ -2600,60 +2600,60 @@ SDL_bool SDL_ShouldIgnoreGamepad(const char *name, SDL_GUID guid)
#ifdef SDL_PLATFORM_LINUX
if (SDL_endswith(name, " Motion Sensors")) {
// Don't treat the PS3 and PS4 motion controls as a separate gamepad
return SDL_TRUE;
return true;
}
if (SDL_strncmp(name, "Nintendo ", 9) == 0 && SDL_strstr(name, " IMU") != NULL) {
// Don't treat the Nintendo IMU as a separate gamepad
return SDL_TRUE;
return true;
}
if (SDL_endswith(name, " Accelerometer") ||
SDL_endswith(name, " IR") ||
SDL_endswith(name, " Motion Plus") ||
SDL_endswith(name, " Nunchuk")) {
// Don't treat the Wii extension controls as a separate gamepad
return SDL_TRUE;
return true;
}
#endif
if (name && SDL_strcmp(name, "uinput-fpc") == 0) {
// The Google Pixel fingerprint sensor reports itself as a joystick
return SDL_TRUE;
return true;
}
if (SDL_allowed_gamepads.num_included_entries == 0 &&
SDL_ignored_gamepads.num_included_entries == 0) {
return SDL_FALSE;
return false;
}
SDL_GetJoystickGUIDInfo(guid, &vendor, &product, &version, NULL);
if (SDL_GetHintBoolean("SDL_GAMECONTROLLER_ALLOW_STEAM_VIRTUAL_GAMEPAD", SDL_FALSE)) {
if (SDL_GetHintBoolean("SDL_GAMECONTROLLER_ALLOW_STEAM_VIRTUAL_GAMEPAD", false)) {
// We shouldn't ignore Steam's virtual gamepad since it's using the hints to filter out the real gamepads so it can remap input for the virtual gamepad
// https://partner.steamgames.com/doc/features/steam_gamepad/steam_input_gamepad_emulation_bestpractices
SDL_bool bSteamVirtualGamepad = SDL_FALSE;
bool bSteamVirtualGamepad = false;
#ifdef SDL_PLATFORM_LINUX
bSteamVirtualGamepad = (vendor == USB_VENDOR_VALVE && product == USB_PRODUCT_STEAM_VIRTUAL_GAMEPAD);
#elif defined(SDL_PLATFORM_MACOS)
bSteamVirtualGamepad = (vendor == USB_VENDOR_MICROSOFT && product == USB_PRODUCT_XBOX360_WIRED_CONTROLLER && version == 0);
#elif defined(SDL_PLATFORM_WIN32)
// We can't tell on Windows, but Steam will block others in input hooks
bSteamVirtualGamepad = SDL_TRUE;
bSteamVirtualGamepad = true;
#endif
if (bSteamVirtualGamepad) {
return SDL_FALSE;
return false;
}
}
if (SDL_allowed_gamepads.num_included_entries > 0) {
if (SDL_VIDPIDInList(vendor, product, &SDL_allowed_gamepads)) {
return SDL_FALSE;
return false;
}
return SDL_TRUE;
return true;
} else {
if (SDL_VIDPIDInList(vendor, product, &SDL_ignored_gamepads)) {
return SDL_TRUE;
return true;
}
return SDL_FALSE;
return false;
}
}
@@ -2683,7 +2683,7 @@ SDL_Gamepad *SDL_OpenGamepad(SDL_JoystickID instance_id)
}
// Find a gamepad mapping
pSupportedGamepad = SDL_PrivateGetGamepadMapping(instance_id, SDL_TRUE);
pSupportedGamepad = SDL_PrivateGetGamepadMapping(instance_id, true);
if (!pSupportedGamepad) {
SDL_SetError("Couldn't find mapping for device (%" SDL_PRIu32 ")", instance_id);
SDL_UnlockJoysticks();
@@ -2696,7 +2696,7 @@ SDL_Gamepad *SDL_OpenGamepad(SDL_JoystickID instance_id)
SDL_UnlockJoysticks();
return NULL;
}
SDL_SetObjectValid(gamepad, SDL_OBJECT_TYPE_GAMEPAD, SDL_TRUE);
SDL_SetObjectValid(gamepad, SDL_OBJECT_TYPE_GAMEPAD, true);
gamepad->joystick = SDL_OpenJoystick(instance_id);
if (!gamepad->joystick) {
@@ -2752,18 +2752,18 @@ void SDL_UpdateGamepads(void)
*/
SDL_bool SDL_GamepadHasAxis(SDL_Gamepad *gamepad, SDL_GamepadAxis axis)
{
SDL_bool retval = SDL_FALSE;
bool retval = false;
SDL_LockJoysticks();
{
int i;
CHECK_GAMEPAD_MAGIC(gamepad, SDL_FALSE);
CHECK_GAMEPAD_MAGIC(gamepad, false);
for (i = 0; i < gamepad->num_bindings; ++i) {
SDL_GamepadBinding *binding = &gamepad->bindings[i];
if (binding->output_type == SDL_GAMEPAD_BINDTYPE_AXIS && binding->output.axis.axis == axis) {
retval = SDL_TRUE;
retval = true;
break;
}
}
@@ -2790,8 +2790,8 @@ Sint16 SDL_GetGamepadAxis(SDL_Gamepad *gamepad, SDL_GamepadAxis axis)
SDL_GamepadBinding *binding = &gamepad->bindings[i];
if (binding->output_type == SDL_GAMEPAD_BINDTYPE_AXIS && binding->output.axis.axis == axis) {
int value = 0;
SDL_bool valid_input_range;
SDL_bool valid_output_range;
bool valid_input_range;
bool valid_output_range;
if (binding->input_type == SDL_GAMEPAD_BINDTYPE_AXIS) {
value = SDL_GetJoystickAxis(gamepad->joystick, binding->input.axis.axis);
@@ -2843,18 +2843,18 @@ Sint16 SDL_GetGamepadAxis(SDL_Gamepad *gamepad, SDL_GamepadAxis axis)
*/
SDL_bool SDL_GamepadHasButton(SDL_Gamepad *gamepad, SDL_GamepadButton button)
{
SDL_bool retval = SDL_FALSE;
bool retval = false;
SDL_LockJoysticks();
{
int i;
CHECK_GAMEPAD_MAGIC(gamepad, SDL_FALSE);
CHECK_GAMEPAD_MAGIC(gamepad, false);
for (i = 0; i < gamepad->num_bindings; ++i) {
SDL_GamepadBinding *binding = &gamepad->bindings[i];
if (binding->output_type == SDL_GAMEPAD_BINDTYPE_BUTTON && binding->output.button == button) {
retval = SDL_TRUE;
retval = true;
break;
}
}
@@ -2881,7 +2881,7 @@ Uint8 SDL_GetGamepadButton(SDL_Gamepad *gamepad, SDL_GamepadButton button)
SDL_GamepadBinding *binding = &gamepad->bindings[i];
if (binding->output_type == SDL_GAMEPAD_BINDTYPE_BUTTON && binding->output.button == button) {
if (binding->input_type == SDL_GAMEPAD_BINDTYPE_AXIS) {
SDL_bool valid_input_range;
bool valid_input_range;
int value = SDL_GetJoystickAxis(gamepad->joystick, binding->input.axis.axis);
int threshold = binding->input.axis.axis_min + (binding->input.axis.axis_max - binding->input.axis.axis_min) / 2;
@@ -3097,7 +3097,7 @@ int SDL_GetGamepadTouchpadFinger(SDL_Gamepad *gamepad, int touchpad, int finger,
*/
SDL_bool SDL_GamepadHasSensor(SDL_Gamepad *gamepad, SDL_SensorType type)
{
SDL_bool retval = SDL_FALSE;
bool retval = false;
SDL_LockJoysticks();
{
@@ -3106,7 +3106,7 @@ SDL_bool SDL_GamepadHasSensor(SDL_Gamepad *gamepad, SDL_SensorType type)
int i;
for (i = 0; i < joystick->nsensors; ++i) {
if (joystick->sensors[i].type == type) {
retval = SDL_TRUE;
retval = true;
break;
}
}
@@ -3165,7 +3165,7 @@ int SDL_SetGamepadSensorEnabled(SDL_Gamepad *gamepad, SDL_SensorType type, SDL_b
} else {
if (enabled) {
if (joystick->nsensors_enabled == 0) {
if (joystick->driver->SetSensorsEnabled(joystick, SDL_TRUE) < 0) {
if (joystick->driver->SetSensorsEnabled(joystick, true) < 0) {
SDL_UnlockJoysticks();
return -1;
}
@@ -3173,7 +3173,7 @@ int SDL_SetGamepadSensorEnabled(SDL_Gamepad *gamepad, SDL_SensorType type, SDL_b
++joystick->nsensors_enabled;
} else {
if (joystick->nsensors_enabled == 1) {
if (joystick->driver->SetSensorsEnabled(joystick, SDL_FALSE) < 0) {
if (joystick->driver->SetSensorsEnabled(joystick, false) < 0) {
SDL_UnlockJoysticks();
return -1;
}
@@ -3199,7 +3199,7 @@ int SDL_SetGamepadSensorEnabled(SDL_Gamepad *gamepad, SDL_SensorType type, SDL_b
*/
SDL_bool SDL_GamepadSensorEnabled(SDL_Gamepad *gamepad, SDL_SensorType type)
{
SDL_bool retval = SDL_FALSE;
bool retval = false;
SDL_LockJoysticks();
{
@@ -3481,7 +3481,7 @@ SDL_bool SDL_GamepadConnected(SDL_Gamepad *gamepad)
SDL_Joystick *joystick = SDL_GetGamepadJoystick(gamepad);
if (!joystick) {
return SDL_FALSE;
return false;
}
return SDL_JoystickConnected(joystick);
}
@@ -3655,7 +3655,7 @@ void SDL_CloseGamepad(SDL_Gamepad *gamepad)
gamepadlist = gamepadlist->next;
}
SDL_SetObjectValid(gamepad, SDL_OBJECT_TYPE_GAMEPAD, SDL_FALSE);
SDL_SetObjectValid(gamepad, SDL_OBJECT_TYPE_GAMEPAD, false);
SDL_free(gamepad->bindings);
SDL_free(gamepad->last_match_axis);
SDL_free(gamepad->last_hat_mask);
@@ -3677,7 +3677,7 @@ void SDL_QuitGamepads(void)
SDL_PrivateGamepadRemoved(gamepad->joystick->instance_id);
}
SDL_gamepads_initialized = SDL_FALSE;
SDL_gamepads_initialized = false;
SDL_DelEventWatch(SDL_GamepadEventWatcher, NULL);
@@ -3772,10 +3772,10 @@ static int SDL_SendGamepadButton(Uint64 timestamp, SDL_Gamepad *gamepad, SDL_Gam
}
} else {
if (now < (gamepad->guide_button_down + SDL_MINIMUM_GUIDE_BUTTON_DELAY_MS)) {
gamepad->joystick->delayed_guide_button = SDL_TRUE;
gamepad->joystick->delayed_guide_button = true;
return 0;
}
gamepad->joystick->delayed_guide_button = SDL_FALSE;
gamepad->joystick->delayed_guide_button = false;
}
}
@@ -3815,7 +3815,7 @@ void SDL_SetGamepadEventsEnabled(SDL_bool enabled)
SDL_bool SDL_GamepadEventsEnabled(void)
{
SDL_bool enabled = SDL_FALSE;
bool enabled = false;
unsigned int i;
for (i = 0; i < SDL_arraysize(SDL_gamepad_event_list); ++i) {