mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-01-31 06:32:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Reduce button state from 256bit to 128bit - all the bind IDs

Browse Source 
combined right now are still under 80, so 256 bits is too
overboard for now
This commit is contained in:
twinaphex 2020-06-08 20:13:00 +02:00
parent f64da5cb1e
commit 47456cf94b
2 changed files with 114 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
input/input_types.h
View File

@ -23,9 +23,9 @@ typedef struct rarch_joypad_info rarch_joypad_info_t;
typedef struct input_driver input_driver_t; typedef struct input_driver input_driver_t;
typedef struct input_keyboard_ctx_wait input_keyboard_ctx_wait_t; typedef struct input_keyboard_ctx_wait input_keyboard_ctx_wait_t;
typedef struct { typedef struct {
uint32_t data[8]; uint32_t data[4];
uint16_t analogs[8]; uint16_t analogs[4];
uint16_t analog_buttons[16]; uint16_t analog_buttons[8];
} input_bits_t; } input_bits_t;
typedef struct joypad_connection joypad_connection_t; typedef struct joypad_connection joypad_connection_t;
typedef struct pad_connection_listener_interface pad_connection_listener_t; typedef struct pad_connection_listener_interface pad_connection_listener_t;

225
retroarch.c
View File

@ -1186,7 +1186,7 @@ static const camera_driver_t *camera_drivers[] = {
#define HOTKEY_CHECK(cmd1, cmd2, cond, cond2) \ #define HOTKEY_CHECK(cmd1, cmd2, cond, cond2) \
{ \ { \
static bool old_pressed = false; \ static bool old_pressed = false; \
bool pressed = BIT256_GET(current_bits, cmd1); \ bool pressed = BIT128_GET(current_bits, cmd1); \
if (pressed && !old_pressed) \ if (pressed && !old_pressed) \
if (cond) \ if (cond) \
command_event(cmd2, cond2); \ command_event(cmd2, cond2); \
@ -1198,9 +1198,9 @@ static const camera_driver_t *camera_drivers[] = {
static bool old_pressed = false; \ static bool old_pressed = false; \
static bool old_pressed2 = false; \ static bool old_pressed2 = false; \
static bool old_pressed3 = false; \ static bool old_pressed3 = false; \
bool pressed = BIT256_GET(current_bits, cmd1); \ bool pressed = BIT128_GET(current_bits, cmd1); \
bool pressed2 = BIT256_GET(current_bits, cmd3); \ bool pressed2 = BIT128_GET(current_bits, cmd3); \
bool pressed3 = BIT256_GET(current_bits, cmd5); \ bool pressed3 = BIT128_GET(current_bits, cmd5); \
if (pressed && !old_pressed) \ if (pressed && !old_pressed) \
command_event(cmd2, (void*)(intptr_t)0); \ command_event(cmd2, (void*)(intptr_t)0); \
else if (pressed2 && !old_pressed2) \ else if (pressed2 && !old_pressed2) \
@ -2249,7 +2249,7 @@ struct rarch_state
*/ */
gfx_ctx_flags_t deferred_flag_data; gfx_ctx_flags_t deferred_flag_data;
retro_bits_t has_set_libretro_device; input_bits_t has_set_libretro_device;
rarch_system_info_t runloop_system; rarch_system_info_t runloop_system;
struct retro_frame_time_callback runloop_frame_time; struct retro_frame_time_callback runloop_frame_time;
@ -15546,7 +15546,7 @@ void retroarch_override_setting_set(
if (val) if (val)
{ {
unsigned bit = *val; unsigned bit = *val;
BIT256_SET(p_rarch->has_set_libretro_device, bit); BIT128_SET(p_rarch->has_set_libretro_device, bit);
} }
} }
break; break;
@ -15613,7 +15613,7 @@ void retroarch_override_setting_unset(
if (val) if (val)
{ {
unsigned bit = *val; unsigned bit = *val;
BIT256_CLEAR(p_rarch->has_set_libretro_device, bit); BIT128_CLEAR(p_rarch->has_set_libretro_device, bit);
} }
} }
break; break;
@ -21019,7 +21019,7 @@ static void input_overlay_poll(
desc->button_mask.data, desc->button_mask.data,
ARRAY_SIZE(desc->button_mask.data)); ARRAY_SIZE(desc->button_mask.data));
if (BIT256_GET(desc->button_mask, RARCH_OVERLAY_NEXT)) if (BIT128_GET(desc->button_mask, RARCH_OVERLAY_NEXT))
ol->next_index = desc->next_index; ol->next_index = desc->next_index;
} }
break; break;
@ -21289,7 +21289,7 @@ bool input_overlay_key_pressed(input_overlay_t *ol, unsigned key)
input_overlay_state_t *ol_state = ol ? &ol->overlay_state : NULL; input_overlay_state_t *ol_state = ol ? &ol->overlay_state : NULL;
if (!ol) if (!ol)
return false; return false;
return (BIT256_GET(ol_state->buttons, key)); return (BIT128_GET(ol_state->buttons, key));
} }
/* /*
@ -21407,9 +21407,9 @@ static void input_poll_overlay(
if (ol_state->analog[j]) if (ol_state->analog[j])
continue; continue;
if ((BIT256_GET(ol->overlay_state.buttons, bind_plus))) if ((BIT128_GET(ol->overlay_state.buttons, bind_plus)))
ol_state->analog[j] += 0x7fff; ol_state->analog[j] += 0x7fff;
if ((BIT256_GET(ol->overlay_state.buttons, bind_minus))) if ((BIT128_GET(ol->overlay_state.buttons, bind_minus)))
ol_state->analog[j] -= 0x7fff; ol_state->analog[j] -= 0x7fff;
} }
@ -21430,13 +21430,13 @@ static void input_poll_overlay(
analog_y = (float)ol_state->analog[analog_base + 1] / 0x7fff; analog_y = (float)ol_state->analog[analog_base + 1] / 0x7fff;
if (analog_x <= -axis_threshold) if (analog_x <= -axis_threshold)
BIT256_SET(ol_state->buttons, RETRO_DEVICE_ID_JOYPAD_LEFT); BIT128_SET(ol_state->buttons, RETRO_DEVICE_ID_JOYPAD_LEFT);
if (analog_x >= axis_threshold) if (analog_x >= axis_threshold)
BIT256_SET(ol_state->buttons, RETRO_DEVICE_ID_JOYPAD_RIGHT); BIT128_SET(ol_state->buttons, RETRO_DEVICE_ID_JOYPAD_RIGHT);
if (analog_y <= -axis_threshold) if (analog_y <= -axis_threshold)
BIT256_SET(ol_state->buttons, RETRO_DEVICE_ID_JOYPAD_UP); BIT128_SET(ol_state->buttons, RETRO_DEVICE_ID_JOYPAD_UP);
if (analog_y >= axis_threshold) if (analog_y >= axis_threshold)
BIT256_SET(ol_state->buttons, RETRO_DEVICE_ID_JOYPAD_DOWN); BIT128_SET(ol_state->buttons, RETRO_DEVICE_ID_JOYPAD_DOWN);
break; break;
} }
@ -21784,16 +21784,13 @@ static void input_driver_poll(void)
case RETRO_DEVICE_KEYBOARD: case RETRO_DEVICE_KEYBOARD:
case RETRO_DEVICE_JOYPAD: case RETRO_DEVICE_JOYPAD:
case RETRO_DEVICE_ANALOG: case RETRO_DEVICE_ANALOG:
BIT256_CLEAR_ALL_PTR(&current_inputs); BIT128_CLEAR_ALL_PTR(&current_inputs);
{ {
unsigned k, j; unsigned k, j;
if (joypad_driver) if (joypad_driver)
{ {
int16_t ret = 0; int16_t ret = p_rarch->current_input->input_state(
if ( p_rarch->current_input &&
p_rarch->current_input->input_state)
ret = p_rarch->current_input->input_state(
p_rarch->current_input_data, p_rarch->current_input_data,
&joypad_info[i], &joypad_info[i],
p_rarch->libretro_input_binds, p_rarch->libretro_input_binds,
@ -21809,7 +21806,7 @@ static void input_driver_poll(void)
RETRO_DEVICE_INDEX_ANALOG_BUTTON, k, RETRO_DEVICE_INDEX_ANALOG_BUTTON, k,
p_rarch->libretro_input_binds[i]); p_rarch->libretro_input_binds[i]);
BIT256_SET_PTR(p_new_state, k); BIT128_SET_PTR(p_new_state, k);
if (val) if (val)
p_new_state->analog_buttons[k] = val; p_new_state->analog_buttons[k] = val;
@ -21851,7 +21848,7 @@ static void input_driver_poll(void)
bool remap_valid = remap_button != RETROK_UNKNOWN; bool remap_valid = remap_button != RETROK_UNKNOWN;
if (remap_valid) if (remap_valid)
{ {
unsigned current_button_value = BIT256_GET_PTR(p_new_state, j); unsigned current_button_value = BIT128_GET_PTR(p_new_state, j);
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
if (poll_overlay && i == 0) if (poll_overlay && i == 0)
current_button_value |= input_overlay_key_pressed(overlay_pointer, j); current_button_value |= input_overlay_key_pressed(overlay_pointer, j);
@ -21882,7 +21879,7 @@ static void input_driver_poll(void)
* other button than the default one, then it sets * other button than the default one, then it sets
* the bit on the mapper input bitmap, later on the * the bit on the mapper input bitmap, later on the
* original input is cleared in input_state */ * original input is cleared in input_state */
BIT256_CLEAR_ALL(handle->buttons[i]); BIT128_CLEAR_ALL(handle->buttons[i]);
for (j = 0; j < 8; j++) for (j = 0; j < 8; j++)
handle->analog_value[i][j] = 0; handle->analog_value[i][j] = 0;
@ -21892,7 +21889,7 @@ static void input_driver_poll(void)
bool remap_valid; bool remap_valid;
unsigned remap_button = unsigned remap_button =
settings->uints.input_remap_ids[i][j]; settings->uints.input_remap_ids[i][j];
unsigned current_button_value = BIT256_GET_PTR(p_new_state, j); unsigned current_button_value = BIT128_GET_PTR(p_new_state, j);
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
if (poll_overlay && i == 0) if (poll_overlay && i == 0)
current_button_value |= current_button_value |=
@ -21907,7 +21904,7 @@ static void input_driver_poll(void)
/* gamepad override */ /* gamepad override */
if (i == 0 && p_rarch->gamepad_input_override & (1 << j)) if (i == 0 && p_rarch->gamepad_input_override & (1 << j))
{ {
BIT256_SET(handle->buttons[i], j); BIT128_SET(handle->buttons[i], j);
} }
#endif #endif
@ -21915,7 +21912,7 @@ static void input_driver_poll(void)
{ {
if (remap_button < RARCH_FIRST_CUSTOM_BIND) if (remap_button < RARCH_FIRST_CUSTOM_BIND)
{ {
BIT256_SET(handle->buttons[i], remap_button); BIT128_SET(handle->buttons[i], remap_button);
} }
else if (remap_button >= RARCH_FIRST_CUSTOM_BIND) else if (remap_button >= RARCH_FIRST_CUSTOM_BIND)
{ {
@ -21933,7 +21930,7 @@ static void input_driver_poll(void)
} }
} }
for (j = 0; j < 8; j++) for (j = 0; j < 4; j++)
{ {
unsigned k = j + RARCH_FIRST_CUSTOM_BIND; unsigned k = j + RARCH_FIRST_CUSTOM_BIND;
int16_t current_axis_value = p_new_state->analogs[j]; int16_t current_axis_value = p_new_state->analogs[j];
@ -21951,7 +21948,7 @@ static void input_driver_poll(void)
p_rarch->input_driver_axis_threshold p_rarch->input_driver_axis_threshold
* 32767) * 32767)
{ {
BIT256_SET(handle->buttons[i], remap_axis); BIT128_SET(handle->buttons[i], remap_axis);
} }
else else
{ {
@ -22100,7 +22097,7 @@ static int16_t input_state_device(
&& port == 0 && port == 0
&& p_rarch->overlay_ptr->alive) && p_rarch->overlay_ptr->alive)
{ {
if ((BIT256_GET(p_rarch->overlay_ptr->overlay_state.buttons, id))) if ((BIT128_GET(p_rarch->overlay_ptr->overlay_state.buttons, id)))
res_overlay |= 1; res_overlay |= 1;
if (p_rarch->overlay_ptr->alive) if (p_rarch->overlay_ptr->alive)
res |= res_overlay; res |= res_overlay;
@ -22111,7 +22108,7 @@ static int16_t input_state_device(
} }
if (input_remap_binds_enable && p_rarch->input_driver_mapper) if (input_remap_binds_enable && p_rarch->input_driver_mapper)
if (BIT256_GET(p_rarch->input_driver_mapper->buttons[port], id)) if (BIT128_GET(p_rarch->input_driver_mapper->buttons[port], id))
res = 1; res = 1;
/* Don't allow turbo for D-pad. */ /* Don't allow turbo for D-pad. */
@ -22481,7 +22478,7 @@ static INLINE bool input_keys_pressed_other_sources(
{ {
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
if (p_rarch->overlay_ptr && if (p_rarch->overlay_ptr &&
((BIT256_GET(p_rarch->overlay_ptr->overlay_state.buttons, i)))) ((BIT128_GET(p_rarch->overlay_ptr->overlay_state.buttons, i))))
return true; return true;
#endif #endif
@ -22905,7 +22902,7 @@ static unsigned menu_event(
unsigned menu_cancel_btn = unsigned menu_cancel_btn =
(!input_swap_override && swap_ok_cancel_btns) ? (!input_swap_override && swap_ok_cancel_btns) ?
RETRO_DEVICE_ID_JOYPAD_A : RETRO_DEVICE_ID_JOYPAD_B; RETRO_DEVICE_ID_JOYPAD_A : RETRO_DEVICE_ID_JOYPAD_B;
unsigned ok_current = BIT256_GET_PTR(p_input, menu_ok_btn); unsigned ok_current = BIT128_GET_PTR(p_input, menu_ok_btn);
unsigned ok_trigger = ok_current & ~ok_old; unsigned ok_trigger = ok_current & ~ok_old;
#ifdef HAVE_RGUI #ifdef HAVE_RGUI
menu_handle_t *menu = p_rarch->menu_driver_data; menu_handle_t *menu = p_rarch->menu_driver_data;
@ -22975,14 +22972,14 @@ static unsigned menu_event(
{ {
input_event_osk_iterate(p_rarch->osk_idx); input_event_osk_iterate(p_rarch->osk_idx);
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_DOWN)) if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_DOWN))
{ {
int old_osk_ptr = input_event_get_osk_ptr(); int old_osk_ptr = input_event_get_osk_ptr();
if (old_osk_ptr < 33) if (old_osk_ptr < 33)
input_event_set_osk_ptr(old_osk_ptr + OSK_CHARS_PER_LINE); input_event_set_osk_ptr(old_osk_ptr + OSK_CHARS_PER_LINE);
} }
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_UP)) if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_UP))
{ {
int old_osk_ptr = input_event_get_osk_ptr(); int old_osk_ptr = input_event_get_osk_ptr();
if (old_osk_ptr >= OSK_CHARS_PER_LINE) if (old_osk_ptr >= OSK_CHARS_PER_LINE)
@ -22990,21 +22987,21 @@ static unsigned menu_event(
- OSK_CHARS_PER_LINE); - OSK_CHARS_PER_LINE);
} }
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_RIGHT)) if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_RIGHT))
{ {
int old_osk_ptr = input_event_get_osk_ptr(); int old_osk_ptr = input_event_get_osk_ptr();
if (old_osk_ptr < 43) if (old_osk_ptr < 43)
input_event_set_osk_ptr(old_osk_ptr + 1); input_event_set_osk_ptr(old_osk_ptr + 1);
} }
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_LEFT)) if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_LEFT))
{ {
int old_osk_ptr = input_event_get_osk_ptr(); int old_osk_ptr = input_event_get_osk_ptr();
if (old_osk_ptr >= 1) if (old_osk_ptr >= 1)
input_event_set_osk_ptr(old_osk_ptr - 1); input_event_set_osk_ptr(old_osk_ptr - 1);
} }
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_L)) if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_L))
{ {
if (p_rarch->osk_idx > OSK_TYPE_UNKNOWN + 1) if (p_rarch->osk_idx > OSK_TYPE_UNKNOWN + 1)
p_rarch->osk_idx = ((enum osk_type) p_rarch->osk_idx = ((enum osk_type)
@ -23015,7 +23012,7 @@ static unsigned menu_event(
: OSK_TYPE_LAST - 1)); : OSK_TYPE_LAST - 1));
} }
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_R)) if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_R))
{ {
if (p_rarch->osk_idx < (menu_has_fb if (p_rarch->osk_idx < (menu_has_fb
? OSK_SYMBOLS_PAGE1 ? OSK_SYMBOLS_PAGE1
@ -23026,7 +23023,7 @@ static unsigned menu_event(
p_rarch->osk_idx = ((enum osk_type)(OSK_TYPE_UNKNOWN + 1)); p_rarch->osk_idx = ((enum osk_type)(OSK_TYPE_UNKNOWN + 1));
} }
if (BIT256_GET_PTR(p_trigger_input, menu_ok_btn)) if (BIT128_GET_PTR(p_trigger_input, menu_ok_btn))
{ {
int ptr = input_event_get_osk_ptr(); int ptr = input_event_get_osk_ptr();
if (ptr >= 0) if (ptr >= 0)
@ -23034,43 +23031,43 @@ static unsigned menu_event(
ptr, menu_has_fb); ptr, menu_has_fb);
} }
if (BIT256_GET_PTR(p_trigger_input, menu_cancel_btn)) if (BIT128_GET_PTR(p_trigger_input, menu_cancel_btn))
input_keyboard_event(true, '\x7f', '\x7f', input_keyboard_event(true, '\x7f', '\x7f',
0, RETRO_DEVICE_KEYBOARD); 0, RETRO_DEVICE_KEYBOARD);
/* send return key to close keyboard input window */ /* send return key to close keyboard input window */
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_START)) if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_START))
input_keyboard_event(true, '\n', '\n', 0, RETRO_DEVICE_KEYBOARD); input_keyboard_event(true, '\n', '\n', 0, RETRO_DEVICE_KEYBOARD);
BIT256_CLEAR_ALL_PTR(p_trigger_input); BIT128_CLEAR_ALL_PTR(p_trigger_input);
} }
else else
{ {
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_UP)) if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_UP))
ret = MENU_ACTION_UP; ret = MENU_ACTION_UP;
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_DOWN)) else if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_DOWN))
ret = MENU_ACTION_DOWN; ret = MENU_ACTION_DOWN;
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_LEFT)) else if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_LEFT))
ret = MENU_ACTION_LEFT; ret = MENU_ACTION_LEFT;
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_RIGHT)) else if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_RIGHT))
ret = MENU_ACTION_RIGHT; ret = MENU_ACTION_RIGHT;
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_L)) else if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_L))
ret = MENU_ACTION_SCROLL_UP; ret = MENU_ACTION_SCROLL_UP;
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_R)) else if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_R))
ret = MENU_ACTION_SCROLL_DOWN; ret = MENU_ACTION_SCROLL_DOWN;
else if (ok_trigger) else if (ok_trigger)
ret = MENU_ACTION_OK; ret = MENU_ACTION_OK;
else if (BIT256_GET_PTR(p_trigger_input, menu_cancel_btn)) else if (BIT128_GET_PTR(p_trigger_input, menu_cancel_btn))
ret = MENU_ACTION_CANCEL; ret = MENU_ACTION_CANCEL;
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_X)) else if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_X))
ret = MENU_ACTION_SEARCH; ret = MENU_ACTION_SEARCH;
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_Y)) else if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_Y))
ret = MENU_ACTION_SCAN; ret = MENU_ACTION_SCAN;
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_START)) else if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_START))
ret = MENU_ACTION_START; ret = MENU_ACTION_START;
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_SELECT)) else if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_SELECT))
ret = MENU_ACTION_INFO; ret = MENU_ACTION_INFO;
else if (BIT256_GET_PTR(p_trigger_input, RARCH_MENU_TOGGLE)) else if (BIT128_GET_PTR(p_trigger_input, RARCH_MENU_TOGGLE))
ret = MENU_ACTION_TOGGLE; ret = MENU_ACTION_TOGGLE;
} }
@ -24056,7 +24053,7 @@ static void input_menu_keys_pressed(
if (bit_pressed || input_keys_pressed_other_sources( if (bit_pressed || input_keys_pressed_other_sources(
p_rarch, i, p_new_state)) p_rarch, i, p_new_state))
{ {
BIT256_SET_PTR(p_new_state, i); BIT128_SET_PTR(p_new_state, i);
} }
} }
@ -24090,7 +24087,7 @@ static void input_menu_keys_pressed(
|| BIT64_GET(lifecycle_state, i) || BIT64_GET(lifecycle_state, i)
|| input_keys_pressed_other_sources(p_rarch, i, p_new_state)) || input_keys_pressed_other_sources(p_rarch, i, p_new_state))
{ {
BIT256_SET_PTR(p_new_state, i); BIT128_SET_PTR(p_new_state, i);
} }
} }
} }
@ -24185,7 +24182,7 @@ static void input_keys_pressed(
if (bit_pressed || input_keys_pressed_other_sources(p_rarch, if (bit_pressed || input_keys_pressed_other_sources(p_rarch,
i, p_new_state)) i, p_new_state))
{ {
BIT256_SET_PTR(p_new_state, i); BIT128_SET_PTR(p_new_state, i);
} }
} }
} }
@ -24200,7 +24197,7 @@ static void input_keys_pressed(
|| BIT64_GET(lifecycle_state, i) || BIT64_GET(lifecycle_state, i)
|| input_keys_pressed_other_sources(p_rarch, i, p_new_state)) || input_keys_pressed_other_sources(p_rarch, i, p_new_state))
{ {
BIT256_SET_PTR(p_new_state, i); BIT128_SET_PTR(p_new_state, i);
} }
} }
} }
@ -35693,7 +35690,7 @@ bool retroarch_override_setting_is_set(
if (val) if (val)
{ {
unsigned bit = *val; unsigned bit = *val;
return BIT256_GET(p_rarch->has_set_libretro_device, bit); return BIT128_GET(p_rarch->has_set_libretro_device, bit);
} }
} }
break; break;
@ -35982,60 +35979,60 @@ static bool input_driver_toggle_button_combo(
switch (mode) switch (mode)
{ {
case INPUT_TOGGLE_DOWN_Y_L_R: case INPUT_TOGGLE_DOWN_Y_L_R:
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_DOWN)) if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_DOWN))
return false; return false;
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_Y)) if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_Y))
return false; return false;
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L)) if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L))
return false; return false;
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R)) if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R))
return false; return false;
break; break;
case INPUT_TOGGLE_L3_R3: case INPUT_TOGGLE_L3_R3:
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L3)) if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L3))
return false; return false;
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R3)) if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R3))
return false; return false;
break; break;
case INPUT_TOGGLE_L1_R1_START_SELECT: case INPUT_TOGGLE_L1_R1_START_SELECT:
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_START)) if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_START))
return false; return false;
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_SELECT)) if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_SELECT))
return false; return false;
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L)) if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L))
return false; return false;
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R)) if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R))
return false; return false;
break; break;
case INPUT_TOGGLE_START_SELECT: case INPUT_TOGGLE_START_SELECT:
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_START)) if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_START))
return false; return false;
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_SELECT)) if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_SELECT))
return false; return false;
break; break;
case INPUT_TOGGLE_L3_R: case INPUT_TOGGLE_L3_R:
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L3)) if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L3))
return false; return false;
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R)) if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R))
return false; return false;
break; break;
case INPUT_TOGGLE_L_R: case INPUT_TOGGLE_L_R:
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L)) if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L))
return false; return false;
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R)) if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R))
return false; return false;
break; break;
case INPUT_TOGGLE_DOWN_SELECT: case INPUT_TOGGLE_DOWN_SELECT:
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_DOWN)) if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_DOWN))
return false; return false;
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_SELECT)) if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_SELECT))
return false; return false;
break; break;
case INPUT_TOGGLE_HOLD_START: case INPUT_TOGGLE_HOLD_START:
{ {
static rarch_timer_t timer = {0}; static rarch_timer_t timer = {0};
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_START)) if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_START))
{ {
/* timer only runs while start is held down */ /* timer only runs while start is held down */
rarch_timer_end(&timer); rarch_timer_end(&timer);
@ -36192,7 +36189,7 @@ static enum runloop_state runloop_check_state(
return RUNLOOP_STATE_QUIT; return RUNLOOP_STATE_QUIT;
#endif #endif
BIT256_CLEAR_ALL_PTR(&current_bits); BIT128_CLEAR_ALL_PTR(&current_bits);
p_rarch->input_driver_block_libretro_input = false; p_rarch->input_driver_block_libretro_input = false;
p_rarch->input_driver_block_hotkey = false; p_rarch->input_driver_block_hotkey = false;
@ -36256,7 +36253,7 @@ static enum runloop_state runloop_check_state(
p_rarch->current_input_data, p_rarch->current_input_data,
&joypad_info, binds, 0, &joypad_info, binds, 0,
RETRO_DEVICE_KEYBOARD, 0, ids[i][0])) RETRO_DEVICE_KEYBOARD, 0, ids[i][0]))
BIT256_SET_PTR(&current_bits, ids[i][1]); BIT128_SET_PTR(&current_bits, ids[i][1]);
} }
} }
} }
@ -36291,7 +36288,7 @@ static enum runloop_state runloop_check_state(
input_driver_toggle_button_combo( input_driver_toggle_button_combo(
menu_toggle_gamepad_combo, current_time, menu_toggle_gamepad_combo, current_time,
&last_input))) &last_input)))
BIT256_SET(current_bits, RARCH_MENU_TOGGLE); BIT128_SET(current_bits, RARCH_MENU_TOGGLE);
#endif #endif
if (p_rarch->input_driver_flushing_input > 0) if (p_rarch->input_driver_flushing_input > 0)
@ -36304,9 +36301,9 @@ static enum runloop_state runloop_check_state(
if (input_active || (p_rarch->input_driver_flushing_input > 0)) if (input_active || (p_rarch->input_driver_flushing_input > 0))
{ {
BIT256_CLEAR_ALL(current_bits); BIT128_CLEAR_ALL(current_bits);
if (runloop_paused) if (runloop_paused)
BIT256_SET(current_bits, RARCH_PAUSE_TOGGLE); BIT128_SET(current_bits, RARCH_PAUSE_TOGGLE);
} }
} }
@ -36327,7 +36324,7 @@ static enum runloop_state runloop_check_state(
#ifdef HAVE_MENU #ifdef HAVE_MENU
if (menu_driver_binding_state) if (menu_driver_binding_state)
BIT256_CLEAR_ALL(current_bits); BIT128_CLEAR_ALL(current_bits);
#endif #endif
/* Check fullscreen toggle */ /* Check fullscreen toggle */
@ -36393,7 +36390,7 @@ static enum runloop_state runloop_check_state(
static bool quit_key = false; static bool quit_key = false;
static bool old_quit_key = false; static bool old_quit_key = false;
static bool runloop_exec = false; static bool runloop_exec = false;
quit_key = BIT256_GET( quit_key = BIT128_GET(
current_bits, RARCH_QUIT_KEY); current_bits, RARCH_QUIT_KEY);
trig_quit_key = quit_key && !old_quit_key; trig_quit_key = quit_key && !old_quit_key;
old_quit_key = quit_key; old_quit_key = quit_key;
@ -36669,7 +36666,7 @@ static enum runloop_state runloop_check_state(
{ {
static bool old_pressed = false; static bool old_pressed = false;
char *menu_driver = settings->arrays.menu_driver; char *menu_driver = settings->arrays.menu_driver;
bool pressed = BIT256_GET( bool pressed = BIT128_GET(
current_bits, RARCH_MENU_TOGGLE) && current_bits, RARCH_MENU_TOGGLE) &&
!string_is_equal(menu_driver, "null"); !string_is_equal(menu_driver, "null");
bool core_type_is_dummy = p_rarch->current_core_type == CORE_TYPE_DUMMY; bool core_type_is_dummy = p_rarch->current_core_type == CORE_TYPE_DUMMY;
@ -36743,9 +36740,9 @@ static enum runloop_state runloop_check_state(
/* Check if we have pressed the streaming toggle button */ /* Check if we have pressed the streaming toggle button */
HOTKEY_CHECK(RARCH_STREAMING_TOGGLE, CMD_EVENT_STREAMING_TOGGLE, true, NULL); HOTKEY_CHECK(RARCH_STREAMING_TOGGLE, CMD_EVENT_STREAMING_TOGGLE, true, NULL);
if (BIT256_GET(current_bits, RARCH_VOLUME_UP)) if (BIT128_GET(current_bits, RARCH_VOLUME_UP))
command_event(CMD_EVENT_VOLUME_UP, NULL); command_event(CMD_EVENT_VOLUME_UP, NULL);
else if (BIT256_GET(current_bits, RARCH_VOLUME_DOWN)) else if (BIT128_GET(current_bits, RARCH_VOLUME_DOWN))
command_event(CMD_EVENT_VOLUME_DOWN, NULL); command_event(CMD_EVENT_VOLUME_DOWN, NULL);
#ifdef HAVE_NETWORKING #ifdef HAVE_NETWORKING
@ -36757,9 +36754,9 @@ static enum runloop_state runloop_check_state(
{ {
static bool old_frameadvance = false; static bool old_frameadvance = false;
static bool old_pause_pressed = false; static bool old_pause_pressed = false;
bool frameadvance_pressed = BIT256_GET( bool frameadvance_pressed = BIT128_GET(
current_bits, RARCH_FRAMEADVANCE); current_bits, RARCH_FRAMEADVANCE);
bool pause_pressed = BIT256_GET( bool pause_pressed = BIT128_GET(
current_bits, RARCH_PAUSE_TOGGLE); current_bits, RARCH_PAUSE_TOGGLE);
bool trig_frameadvance = frameadvance_pressed && !old_frameadvance; bool trig_frameadvance = frameadvance_pressed && !old_frameadvance;
@ -36789,7 +36786,7 @@ static enum runloop_state runloop_check_state(
CMD_EVENT_FULLSCREEN_TOGGLE, true, &toggle); CMD_EVENT_FULLSCREEN_TOGGLE, true, &toggle);
/* Check if it's not oneshot */ /* Check if it's not oneshot */
if (!(trig_frameadvance || BIT256_GET(current_bits, RARCH_REWIND))) if (!(trig_frameadvance || BIT128_GET(current_bits, RARCH_REWIND)))
focused = false; focused = false;
} }
} }
@ -36800,25 +36797,25 @@ static enum runloop_state runloop_check_state(
to send off if it's run. */ to send off if it's run. */
if (settings->bools.ai_service_enable) if (settings->bools.ai_service_enable)
{ {
p_rarch->ai_gamepad_state[0] = BIT256_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_B); p_rarch->ai_gamepad_state[0] = BIT128_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_B);
p_rarch->ai_gamepad_state[1] = BIT256_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_Y); p_rarch->ai_gamepad_state[1] = BIT128_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_Y);
p_rarch->ai_gamepad_state[2] = BIT256_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_SELECT); p_rarch->ai_gamepad_state[2] = BIT128_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_SELECT);
p_rarch->ai_gamepad_state[3] = BIT256_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_START); p_rarch->ai_gamepad_state[3] = BIT128_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_START);
p_rarch->ai_gamepad_state[4] = BIT256_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_UP); p_rarch->ai_gamepad_state[4] = BIT128_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_UP);
p_rarch->ai_gamepad_state[5] = BIT256_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_DOWN); p_rarch->ai_gamepad_state[5] = BIT128_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_DOWN);
p_rarch->ai_gamepad_state[6] = BIT256_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_LEFT); p_rarch->ai_gamepad_state[6] = BIT128_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_LEFT);
p_rarch->ai_gamepad_state[7] = BIT256_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_RIGHT); p_rarch->ai_gamepad_state[7] = BIT128_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_RIGHT);
p_rarch->ai_gamepad_state[8] = BIT256_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_A); p_rarch->ai_gamepad_state[8] = BIT128_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_A);
p_rarch->ai_gamepad_state[9] = BIT256_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_X); p_rarch->ai_gamepad_state[9] = BIT128_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_X);
p_rarch->ai_gamepad_state[10] = BIT256_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_L); p_rarch->ai_gamepad_state[10] = BIT128_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_L);
p_rarch->ai_gamepad_state[11] = BIT256_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_R); p_rarch->ai_gamepad_state[11] = BIT128_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_R);
p_rarch->ai_gamepad_state[12] = BIT256_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_L2); p_rarch->ai_gamepad_state[12] = BIT128_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_L2);
p_rarch->ai_gamepad_state[13] = BIT256_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_R2); p_rarch->ai_gamepad_state[13] = BIT128_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_R2);
p_rarch->ai_gamepad_state[14] = BIT256_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_L3); p_rarch->ai_gamepad_state[14] = BIT128_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_L3);
p_rarch->ai_gamepad_state[15] = BIT256_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_R3); p_rarch->ai_gamepad_state[15] = BIT128_GET(current_bits, RETRO_DEVICE_ID_JOYPAD_R3);
} }
#endif #endif
#endif #endif
@ -36837,9 +36834,9 @@ static enum runloop_state runloop_check_state(
{ {
static bool old_button_state = false; static bool old_button_state = false;
static bool old_hold_button_state = false; static bool old_hold_button_state = false;
bool new_button_state = BIT256_GET( bool new_button_state = BIT128_GET(
current_bits, RARCH_FAST_FORWARD_KEY); current_bits, RARCH_FAST_FORWARD_KEY);
bool new_hold_button_state = BIT256_GET( bool new_hold_button_state = BIT128_GET(
current_bits, RARCH_FAST_FORWARD_HOLD_KEY); current_bits, RARCH_FAST_FORWARD_HOLD_KEY);
bool check1 = !new_hold_button_state; bool check1 = !new_hold_button_state;
bool check2 = new_button_state && !old_button_state; bool check2 = new_button_state && !old_button_state;
@ -36890,9 +36887,9 @@ static enum runloop_state runloop_check_state(
{ {
static bool old_should_slot_increase = false; static bool old_should_slot_increase = false;
static bool old_should_slot_decrease = false; static bool old_should_slot_decrease = false;
bool should_slot_increase = BIT256_GET( bool should_slot_increase = BIT128_GET(
current_bits, RARCH_STATE_SLOT_PLUS); current_bits, RARCH_STATE_SLOT_PLUS);
bool should_slot_decrease = BIT256_GET( bool should_slot_decrease = BIT128_GET(
current_bits, RARCH_STATE_SLOT_MINUS); current_bits, RARCH_STATE_SLOT_MINUS);
bool check1 = true; bool check1 = true;
bool check2 = should_slot_increase && !old_should_slot_increase; bool check2 = should_slot_increase && !old_should_slot_increase;
@ -36946,7 +36943,7 @@ static enum runloop_state runloop_check_state(
s[0] = '\0'; s[0] = '\0';
rewinding = state_manager_check_rewind( rewinding = state_manager_check_rewind(
BIT256_GET(current_bits, RARCH_REWIND), BIT128_GET(current_bits, RARCH_REWIND),
settings->uints.rewind_granularity, settings->uints.rewind_granularity,
p_rarch->runloop_paused, p_rarch->runloop_paused,
s, sizeof(s), &t); s, sizeof(s), &t);
@ -36970,9 +36967,9 @@ static enum runloop_state runloop_check_state(
{ {
static bool old_slowmotion_button_state = false; static bool old_slowmotion_button_state = false;
static bool old_slowmotion_hold_button_state = false; static bool old_slowmotion_hold_button_state = false;
bool new_slowmotion_button_state = BIT256_GET( bool new_slowmotion_button_state = BIT128_GET(
current_bits, RARCH_SLOWMOTION_KEY); current_bits, RARCH_SLOWMOTION_KEY);
bool new_slowmotion_hold_button_state = BIT256_GET( bool new_slowmotion_hold_button_state = BIT128_GET(
current_bits, RARCH_SLOWMOTION_HOLD_KEY); current_bits, RARCH_SLOWMOTION_HOLD_KEY);
if (new_slowmotion_button_state && !old_slowmotion_button_state) if (new_slowmotion_button_state && !old_slowmotion_button_state)