gaming/RetroArch
gaming/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2024-07-08 12:15:49 +00:00
Code Issues Projects Releases Wiki Activity

Change to 256bit macros

Browse Source
This commit is contained in:
twinaphex 2017-12-05 12:07:35 +01:00
parent 6c09661a64
commit f0c143766e
32 changed files with 168 additions and 173 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
audio/drivers/xaudio.h
View File

@ -324,16 +324,11 @@ STDAPI XAudio2Create(__deref_out IXAudio2** ppXAudio2, UINT32 Flags X2DEFAULT(0)
#else
static INLINE HRESULT XAudio2Create(IXAudio2 **ppXAudio2, UINT32 flags, XAUDIO2_PROCESSOR proc)
{
HRESULT hr;
IXAudio2 *pXAudio2 = NULL;
(void)flags;
(void)proc;
#ifdef __cplusplus
hr = CoCreateInstance(CLSID_XAudio2, NULL, CLSCTX_INPROC_SERVER, IID_IXAudio2, (void**)&pXAudio2);
HRESULT hr = CoCreateInstance(CLSID_XAudio2, NULL, CLSCTX_INPROC_SERVER, IID_IXAudio2, (void**)&pXAudio2);
#else
hr = CoCreateInstance(&CLSID_XAudio2, NULL, CLSCTX_INPROC_SERVER, &IID_IXAudio2, (void**)&pXAudio2);
HRESULT hr = CoCreateInstance(&CLSID_XAudio2, NULL, CLSCTX_INPROC_SERVER, &IID_IXAudio2, (void**)&pXAudio2);
#endif
if (SUCCEEDED(hr))
@ -342,9 +337,7 @@ static INLINE HRESULT XAudio2Create(IXAudio2 **ppXAudio2, UINT32 flags, XAUDIO2_
if (SUCCEEDED(hr))
*ppXAudio2 = pXAudio2;
else
{
IXAudio2_Release(pXAudio2);
}
}
return hr;
}

2
input/connect/connect_nesusb.c
View File

@ -67,7 +67,7 @@ static void hidpad_nesusb_get_buttons(void *data, retro_bits_t* state)
BITS_COPY16_PTR(state, device->buttons);
}
else
BIT128_CLEAR_ALL_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t hidpad_nesusb_get_axis(void *data, unsigned axis)

2
input/connect/connect_ps2adapter.c
View File

@ -67,7 +67,7 @@ static void hidpad_ps2adapter_get_buttons(void *data, retro_bits_t *state)
BITS_COPY16_PTR(state, device->buttons);
}
else
BIT128_CLEAR_ALL_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t hidpad_ps2adapter_get_axis(void *data, unsigned axis)

4
input/connect/connect_ps3.c
View File

@ -115,10 +115,10 @@ static void hidpad_ps3_get_buttons(void *data, retro_bits_t *state)
/*PS button?*/
if (device->buttons & 0x10000)
BIT128_SET_PTR(state, RARCH_MENU_TOGGLE);
BIT256_SET_PTR(state, RARCH_MENU_TOGGLE);
}
else
BIT128_CLEAR_ALL_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t hidpad_ps3_get_axis(void *data, unsigned axis)

36
input/connect/connect_ps4.c
View File

@ -194,42 +194,42 @@ static void hidpad_ps4_get_buttons(void *data, retro_bits_t* state)
if (!device || !rpt)
return;
BIT128_CLEAR_ALL_PTR( state );
BIT256_CLEAR_ALL_PTR( state );
if (rpt->btn.r3)
BIT128_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_R3 );
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_R3 );
if (rpt->btn.l3)
BIT128_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_L3 );
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_L3 );
if (rpt->btn.options)
BIT128_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_START );
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_START );
if ( rpt->btn.share)
BIT128_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_SELECT );
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_SELECT );
if ( rpt->btn.r2)
BIT128_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_R2 );
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_R2 );
if (rpt->btn.l2)
BIT128_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_L2 );
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_L2 );
if (rpt->btn.r1)
BIT128_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_R );
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_R );
if (rpt->btn.l1)
BIT128_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_L );
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_L );
if (rpt->btn.triangle)
BIT128_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_X );
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_X );
if (rpt->btn.circle)
BIT128_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_A );
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_A );
if (rpt->btn.cross)
BIT128_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_B );
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_B );
if (rpt->btn.square)
BIT128_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_Y );
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_Y );
if ((hidpad_ps4_check_dpad(rpt, RETRO_DEVICE_ID_JOYPAD_LEFT)))
BIT128_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_LEFT );
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_LEFT );
if ((hidpad_ps4_check_dpad(rpt, RETRO_DEVICE_ID_JOYPAD_DOWN)))
BIT128_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_DOWN );
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_DOWN );
if ((hidpad_ps4_check_dpad(rpt, RETRO_DEVICE_ID_JOYPAD_RIGHT)))
BIT128_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_RIGHT );
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_RIGHT );
if ((hidpad_ps4_check_dpad(rpt, RETRO_DEVICE_ID_JOYPAD_UP)))
BIT128_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_UP );
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_UP );
if (rpt->btn.ps)
BIT128_SET_PTR( state, RARCH_MENU_TOGGLE );
BIT256_SET_PTR( state, RARCH_MENU_TOGGLE );
}
static int16_t hidpad_ps4_get_axis(void *data, unsigned axis)

2
input/connect/connect_psxadapter.c
View File

@ -67,7 +67,7 @@ static void hidpad_psxadapter_get_buttons(void *data, retro_bits_t *state)
BITS_COPY16_PTR(state, device->buttons);
}
else
BIT128_CLEAR_ALL_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t hidpad_psxadapter_get_axis(void *data, unsigned axis)

2
input/connect/connect_snesusb.c
View File

@ -68,7 +68,7 @@ static void hidpad_snesusb_get_buttons(void *data, retro_bits_t *state)
BITS_COPY16_PTR(state, device->buttons);
}
else
BIT128_CLEAR_ALL_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t hidpad_snesusb_get_axis(void *data, unsigned axis)

2
input/connect/connect_wiiugca.c
View File

@ -71,7 +71,7 @@ static void hidpad_wiiugca_get_buttons(void *data, retro_bits_t *state)
BITS_COPY16_PTR(state, device->buttons);
}
else
BIT128_CLEAR_ALL_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t hidpad_wiiugca_get_axis(void *data, unsigned axis)

36
input/connect/connect_wiiupro.c
View File

@ -127,42 +127,42 @@ static void hidpad_wiiupro_get_buttons(void *data, retro_bits_t *state)
if (!device || !rpt)
return;
BIT128_CLEAR_ALL_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
if (rpt->btn.r3)
BIT128_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_R3);
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_R3);
if (rpt->btn.l3)
BIT128_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_L3);
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_L3);
if (rpt->btn.plus)
BIT128_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_START);
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_START);
if ( rpt->btn.minus)
BIT128_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_SELECT);
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_SELECT);
if ( rpt->btn.zr)
BIT128_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_R2);
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_R2);
if ( rpt->btn.zl)
BIT128_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_L2);
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_L2);
if ( rpt->btn.r)
BIT128_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_R);
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_R);
if ( rpt->btn.l)
BIT128_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_L);
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_L);
if ( rpt->btn.x)
BIT128_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_X);
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_X);
if ( rpt->btn.a)
BIT128_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_A);
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_A);
if ( rpt->btn.b)
BIT128_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_B);
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_B);
if ( rpt->btn.y)
BIT128_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_Y);
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_Y);
if ( rpt->btn.left)
BIT128_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_LEFT);
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_LEFT);
if ( rpt->btn.down)
BIT128_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_DOWN);
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_DOWN);
if ( rpt->btn.right)
BIT128_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_RIGHT);
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_RIGHT);
if ( rpt->btn.up)
BIT128_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_UP);
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_UP);
if ( rpt->btn.home)
BIT128_SET_PTR(state, RARCH_MENU_TOGGLE);
BIT256_SET_PTR(state, RARCH_MENU_TOGGLE);
}
static int16_t hidpad_wiiupro_get_axis(void *data, unsigned axis)

4
input/connect/joypad_connection.c
View File

@ -176,11 +176,9 @@ void pad_connection_packet(joypad_connection_t *joyconn, uint32_t pad,
void pad_connection_get_buttons(joypad_connection_t *joyconn, unsigned pad, retro_bits_t* state)
{
if (joyconn->iface)
{
joyconn->iface->get_buttons(joyconn->data, state);
}
else
BIT128_CLEAR_ALL_PTR( state );
BIT256_CLEAR_ALL_PTR( state );
}
int16_t pad_connection_get_axis(joypad_connection_t *joyconn,

2
input/drivers/cocoa_input.c
View File

@ -59,7 +59,7 @@ static int cocoa_input_find_any_button_ret(cocoa_input_data_t *apple,
if (state)
for (i = 0; i < 256; i++)
if (BIT128_GET_PTR(state,i))
if (BIT256_GET_PTR(state,i))
return i;
return -1;
}

2
input/drivers/wiiu_input.c
View File

@ -108,7 +108,7 @@ static int16_t wiiu_pointer_device_state(wiiu_input_t* wiiu, unsigned id)
{
retro_bits_t state;
wiiu->joypad->get_buttons(0, &state);
return BIT128_GET(state, VPAD_BUTTON_TOUCH) ? 1 : 0;
return BIT256_GET(state, VPAD_BUTTON_TOUCH) ? 1 : 0;
}
case RETRO_DEVICE_ID_POINTER_X:
return wiiu->joypad->axis(0, 0xFFFF0004UL);

3
input/drivers/winraw_input.c
View File

@ -356,9 +356,8 @@ static bool winraw_keyboard_pressed(winraw_input_t *wr, unsigned key)
static bool winraw_mbutton_pressed(winraw_input_t *wr, unsigned port, unsigned key)
{
unsigned i;
bool result;
winraw_mouse_t *mouse = NULL;
settings_t *settings = config_get_ptr();
settings_t *settings = config_get_ptr();
if (port >= MAX_USERS)
return false;

4
input/drivers_hid/btstack_hid.c
View File

@ -1370,7 +1370,7 @@ static void btstack_hid_joypad_get_buttons(void *data, unsigned port, retro_bits
if (hid)
pad_connection_get_buttons(&hid->slots[port], port, state);
else
BIT128_CLEAR_ALL_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static bool btstack_hid_joypad_button(void *data, unsigned port, uint16_t joykey)
@ -1384,7 +1384,7 @@ static bool btstack_hid_joypad_button(void *data, unsigned port, uint16_t joykey
/* Check the button. */
if ((port < MAX_USERS) && (joykey < 32))
return (BIT128_GET(buttons, joykey) != 0);
return (BIT256_GET(buttons, joykey) != 0);
return false;
}

4
input/drivers_hid/iohidmanager_hid.c
View File

@ -114,7 +114,7 @@ static void iohidmanager_hid_joypad_get_buttons(void *data, unsigned port, retro
if (hid)
return pad_connection_get_buttons(&hid->slots[port], port, state);
else
BIT128_CLEAR_ALL_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static bool iohidmanager_hid_joypad_button(void *data,
@ -150,7 +150,7 @@ static bool iohidmanager_hid_joypad_button(void *data,
/* Check the button. */
if ((port < MAX_USERS) && (joykey < 32))
return (BIT128_GET(buttons, joykey) != 0)
return (BIT256_GET(buttons, joykey) != 0)
|| ((hid->buttons[port] & (1 << joykey)) != 0);
return false;

11
input/drivers_hid/libusb_hid.c
View File

@ -447,9 +447,12 @@ static void libusb_hid_joypad_get_buttons(void *data, unsigned port, retro_bits_
{
libusb_hid_t *hid = (libusb_hid_t*)data;
if (hid)
return pad_connection_get_buttons(&hid->slots[port], port, state);
else
BIT128_CLEAR_ALL_PTR(state);
{
pad_connection_get_buttons(&hid->slots[port], port, state);
return;
}
BIT256_CLEAR_ALL_PTR(state);
}
static bool libusb_hid_joypad_button(void *data,
@ -464,7 +467,7 @@ static bool libusb_hid_joypad_button(void *data,
/* Check the button. */
if ((port < MAX_USERS) && (joykey < 32))
return (BIT128_GET(buttons, joykey) != 0);
return (BIT256_GET(buttons, joykey) != 0);
return false;
}

2
input/drivers_hid/null_hid.c
View File

@ -43,7 +43,7 @@ static void null_hid_joypad_get_buttons(void *data, unsigned port, retro_bits_t
(void)data;
(void)port;
BIT128_CLEAR_ALL_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static bool null_hid_joypad_button(void *data, unsigned port, uint16_t joykey)

10
input/drivers_hid/wiiusb_hid.c
View File

@ -482,9 +482,11 @@ static void wiiusb_hid_joypad_get_buttons(void *data, unsigned port, retro_bits_
{
wiiusb_hid_t *hid = (wiiusb_hid_t*)data;
if (hid)
return pad_connection_get_buttons(&hid->connections[port], port, state);
else
BIT128_CLEAR_ALL_PTR(state);
{
pad_connection_get_buttons(&hid->connections[port], port, state);
return;
}
BIT256_CLEAR_ALL_PTR(state);
}
static bool wiiusb_hid_joypad_button(void *data, unsigned port, uint16_t joykey)
@ -499,7 +501,7 @@ static bool wiiusb_hid_joypad_button(void *data, unsigned port, uint16_t joykey)
/* Check the button. */
if ((port < MAX_USERS) && (joykey < 32))
return (BIT128_GET(buttons, joykey) != 0);
return (BIT256_GET(buttons, joykey) != 0);
return false;
}

2
input/drivers_joypad/ctr_joypad.c
View File

@ -77,7 +77,7 @@ static void ctr_joypad_get_buttons(unsigned port_num, retro_bits_t *state)
BITS_COPY16_PTR( state, pad_state );
}
else
BIT128_CLEAR_ALL_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t ctr_joypad_axis(unsigned port_num, uint32_t joyaxis)

2
input/drivers_joypad/gx_joypad.c
View File

@ -169,7 +169,7 @@ static void gx_joypad_get_buttons(unsigned port, retro_bits_t *state)
BITS_COPY16_PTR( state, pad_state[port] );
}
else
BIT128_CLEAR_ALL_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t gx_joypad_axis(unsigned port, uint32_t joyaxis)

2
input/drivers_joypad/hid_joypad.c
View File

@ -60,7 +60,7 @@ static void hid_joypad_get_buttons(unsigned port, retro_bits_t *state)
if (generic_hid && generic_hid->get_buttons)
generic_hid->get_buttons((void*)hid_driver_get_data(), port, state);
else
BIT128_CLEAR_ALL_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t hid_joypad_axis(unsigned port, uint32_t joyaxis)

2
input/drivers_joypad/linuxraw_joypad.c
View File

@ -334,7 +334,7 @@ static void linuxraw_joypad_get_buttons(unsigned port, retro_bits_t *state)
BITS_COPY16_PTR(state, pad->buttons);
}
else
BIT128_CLEAR_ALL_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t linuxraw_joypad_axis(unsigned port, uint32_t joyaxis)

2
input/drivers_joypad/null_joypad.c
View File

@ -39,7 +39,7 @@ static bool null_joypad_button(unsigned port_num, uint16_t joykey)
static void null_joypad_get_buttons(unsigned port_num, retro_bits_t *state)
{
BIT128_CLEAR_ALL_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t null_joypad_axis(unsigned port_num, uint32_t joyaxis)

2
input/drivers_joypad/parport_joypad.c
View File

@ -348,7 +348,7 @@ static void parport_joypad_get_buttons(unsigned port, retro_bits_t *state)
BITS_COPY16_PTR(state, pad->buttons);
}
else
BIT128_CLEAR_ALL_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t parport_joypad_axis(unsigned port, uint32_t joyaxis)

2
input/drivers_joypad/ps3_joypad.c
View File

@ -75,7 +75,7 @@ static void ps3_joypad_get_buttons(unsigned port_num, retro_bits_t *state)
BITS_COPY16_PTR( state, pad_state[port_num] );
}
else
BIT128_CLEAR_ALL_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t ps3_joypad_axis(unsigned port_num, uint32_t joyaxis)

2
input/drivers_joypad/psp_joypad.c
View File

@ -131,7 +131,7 @@ static void psp_joypad_get_buttons(unsigned port_num, retro_bits_t *state)
BITS_COPY16_PTR( state, pad_state[port_num] );
}
else
BIT128_CLEAR_ALL_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t psp_joypad_axis(unsigned port_num, uint32_t joyaxis)

2
input/drivers_joypad/udev_joypad.c
View File

@ -612,7 +612,7 @@ static void udev_joypad_get_buttons(unsigned port, retro_bits_t *state)
BITS_COPY16_PTR( state, pad->buttons );
}
else
BIT128_CLEAR_ALL_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t udev_joypad_axis(unsigned port, uint32_t joyaxis)

2
input/drivers_joypad/wiiu_joypad.c
View File

@ -142,7 +142,7 @@ static void wiiu_joypad_get_buttons(unsigned port_num, retro_bits_t *state)
BITS_COPY16_PTR( state, pad_state[port_num] );
}
else
BIT128_CLAR_ALL_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t wiiu_joypad_axis(unsigned port_num, uint32_t joyaxis)

2
input/drivers_joypad/xdk_joypad.c
View File

@ -83,7 +83,7 @@ static void xdk_joypad_get_buttons(unsigned port_num, retro_bits_t *state)
BITS_COPY16_PTR( state, pad_state[port_num] );
}
else
BIT128_CLEAR_ALL_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t xdk_joypad_axis(unsigned port_num, uint32_t joyaxis)

26
input/input_driver.c
View File

@ -810,7 +810,7 @@ void input_menu_keys_pressed(void *data, retro_bits_t* p_new_state)
joypad_info.joy_idx = 0;
joypad_info.auto_binds = NULL;
BIT128_CLEAR_ALL_PTR(p_new_state);
BIT256_CLEAR_ALL_PTR(p_new_state);
input_driver_block_libretro_input = false;
input_driver_block_hotkey = false;
@ -912,7 +912,7 @@ void input_menu_keys_pressed(void *data, retro_bits_t* p_new_state)
if (pressed)
{
BIT128_SET_PTR(p_new_state, i);
BIT256_SET_PTR(p_new_state, i);
continue;
}
}
@ -922,7 +922,7 @@ void input_menu_keys_pressed(void *data, retro_bits_t* p_new_state)
{
if (current_input->meta_key_pressed(current_input_data, i))
{
BIT128_SET_PTR(p_new_state, i);
BIT256_SET_PTR(p_new_state, i);
continue;
}
}
@ -930,7 +930,7 @@ void input_menu_keys_pressed(void *data, retro_bits_t* p_new_state)
#ifdef HAVE_OVERLAY
if (overlay_ptr && input_overlay_key_pressed(overlay_ptr, i))
{
BIT128_SET_PTR(p_new_state, i);
BIT256_SET_PTR(p_new_state, i);
continue;
}
#endif
@ -945,7 +945,7 @@ void input_menu_keys_pressed(void *data, retro_bits_t* p_new_state)
if (command_get(&handle))
{
BIT128_SET_PTR(p_new_state, i);
BIT256_SET_PTR(p_new_state, i);
continue;
}
}
@ -954,7 +954,7 @@ void input_menu_keys_pressed(void *data, retro_bits_t* p_new_state)
#ifdef HAVE_NETWORKGAMEPAD
if (input_driver_remote && input_remote_key_pressed(i, 0))
{
BIT128_SET_PTR(p_new_state, i);
BIT256_SET_PTR(p_new_state, i);
continue;
}
#endif
@ -1010,7 +1010,7 @@ void input_menu_keys_pressed(void *data, retro_bits_t* p_new_state)
if (current_input->input_state(current_input_data,
joypad_info, binds, 0,
RETRO_DEVICE_KEYBOARD, 0, ids[i][0]))
BIT128_SET_PTR(p_new_state, ids[i][1]);
BIT256_SET_PTR(p_new_state, ids[i][1]);
}
}
}
@ -1037,7 +1037,7 @@ void input_keys_pressed(void *data, retro_bits_t* p_new_state)
const struct retro_keybind *enable_hotkey = &input_config_binds[0][RARCH_ENABLE_HOTKEY];
bool game_focus_toggle_valid = false;
BIT128_CLEAR_ALL_PTR(p_new_state);
BIT256_CLEAR_ALL_PTR(p_new_state);
joypad_info.joy_idx = settings->uints.input_joypad_map[0];
joypad_info.auto_binds = input_autoconf_binds[joypad_info.joy_idx];
@ -1083,7 +1083,7 @@ void input_keys_pressed(void *data, retro_bits_t* p_new_state)
0, RETRO_DEVICE_JOYPAD, 0, i)
)
{
BIT128_SET_PTR(p_new_state, i);
BIT256_SET_PTR(p_new_state, i);
continue;
}
@ -1091,7 +1091,7 @@ void input_keys_pressed(void *data, retro_bits_t* p_new_state)
current_input->meta_key_pressed(current_input_data, i)
)
{
BIT128_SET_PTR(p_new_state, i);
BIT256_SET_PTR(p_new_state, i);
continue;
}
@ -1099,7 +1099,7 @@ void input_keys_pressed(void *data, retro_bits_t* p_new_state)
if (overlay_ptr &&
input_overlay_key_pressed(overlay_ptr, i))
{
BIT128_SET_PTR(p_new_state, i);
BIT256_SET_PTR(p_new_state, i);
continue;
}
#endif
@ -1114,7 +1114,7 @@ void input_keys_pressed(void *data, retro_bits_t* p_new_state)
if (command_get(&handle))
{
BIT128_SET_PTR(p_new_state, i);
BIT256_SET_PTR(p_new_state, i);
continue;
}
}
@ -1124,7 +1124,7 @@ void input_keys_pressed(void *data, retro_bits_t* p_new_state)
if (input_driver_remote &&
input_remote_key_pressed(i, 0))
{
BIT128_SET_PTR(p_new_state, i);
BIT256_SET_PTR(p_new_state, i);
continue;
}
#endif

48
menu/menu_event.c
View File

@ -160,7 +160,7 @@ unsigned menu_event(retro_bits_t* p_input, retro_bits_t* p_trigger_input)
unsigned menu_cancel_btn = (!input_swap_override &&
settings->bools.input_menu_swap_ok_cancel_buttons) ?
RETRO_DEVICE_ID_JOYPAD_A : RETRO_DEVICE_ID_JOYPAD_B;
unsigned ok_current = BIT128_GET_PTR(p_input, menu_ok_btn );
unsigned ok_current = BIT256_GET_PTR(p_input, menu_ok_btn );
unsigned ok_trigger = ok_current & ~ok_old;
ok_old = ok_current;
@ -221,31 +221,31 @@ unsigned menu_event(retro_bits_t* p_input, retro_bits_t* p_trigger_input)
{
menu_event_osk_iterate();
if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_DOWN))
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_DOWN))
{
if (menu_event_get_osk_ptr() < 33)
menu_event_set_osk_ptr(menu_event_get_osk_ptr() + OSK_CHARS_PER_LINE);
}
if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_UP))
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_UP))
{
if (menu_event_get_osk_ptr() >= OSK_CHARS_PER_LINE)
menu_event_set_osk_ptr(menu_event_get_osk_ptr() - OSK_CHARS_PER_LINE);
}
if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_RIGHT))
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_RIGHT))
{
if (menu_event_get_osk_ptr() < 43)
menu_event_set_osk_ptr(menu_event_get_osk_ptr() + 1);
}
if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_LEFT))
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_LEFT))
{
if (menu_event_get_osk_ptr() >= 1)
menu_event_set_osk_ptr(menu_event_get_osk_ptr() - 1);
}
if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_L))
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_L))
{
if (menu_event_get_osk_idx() > OSK_TYPE_UNKNOWN + 1)
menu_event_set_osk_idx((enum osk_type)(menu_event_get_osk_idx() - 1));
@ -253,7 +253,7 @@ unsigned menu_event(retro_bits_t* p_input, retro_bits_t* p_trigger_input)
menu_event_set_osk_idx((enum osk_type)(OSK_TYPE_LAST - 1));
}
if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_R))
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_R))
{
if (menu_event_get_osk_idx() < OSK_TYPE_LAST - 1)
menu_event_set_osk_idx((enum osk_type)(menu_event_get_osk_idx() + 1));
@ -261,50 +261,50 @@ unsigned menu_event(retro_bits_t* p_input, retro_bits_t* p_trigger_input)
menu_event_set_osk_idx((enum osk_type)(OSK_TYPE_UNKNOWN + 1));
}
if (BIT128_GET_PTR(p_trigger_input, menu_ok_btn))
if (BIT256_GET_PTR(p_trigger_input, menu_ok_btn))
{
if (menu_event_get_osk_ptr() >= 0)
menu_event_osk_append(menu_event_get_osk_ptr());
}
if (BIT128_GET_PTR(p_trigger_input, menu_cancel_btn))
if (BIT256_GET_PTR(p_trigger_input, menu_cancel_btn))
{
input_keyboard_event(true, '\x7f', '\x7f', 0, RETRO_DEVICE_KEYBOARD);
}
/* send return key to close keyboard input window */
if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_START))
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_START))
input_keyboard_event(true, '\n', '\n', 0, RETRO_DEVICE_KEYBOARD);
BIT128_CLEAR_ALL_PTR(p_trigger_input);
BIT256_CLEAR_ALL_PTR(p_trigger_input);
}
else
{
if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_UP))
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_UP))
ret = MENU_ACTION_UP;
else if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_DOWN))
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_DOWN))
ret = MENU_ACTION_DOWN;
else if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_LEFT))
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_LEFT))
ret = MENU_ACTION_LEFT;
else if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_RIGHT))
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_RIGHT))
ret = MENU_ACTION_RIGHT;
else if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_L))
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_L))
ret = MENU_ACTION_SCROLL_UP;
else if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_R))
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_R))
ret = MENU_ACTION_SCROLL_DOWN;
else if (ok_trigger)
ret = MENU_ACTION_OK;
else if (BIT128_GET_PTR(p_trigger_input, menu_cancel_btn))
else if (BIT256_GET_PTR(p_trigger_input, menu_cancel_btn))
ret = MENU_ACTION_CANCEL;
else if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_X))
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_X))
ret = MENU_ACTION_SEARCH;
else if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_Y))
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_Y))
ret = MENU_ACTION_SCAN;
else if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_START))
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_START))
ret = MENU_ACTION_START;
else if (BIT128_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_SELECT))
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_SELECT))
ret = MENU_ACTION_INFO;
else if (BIT128_GET_PTR(p_trigger_input, RARCH_MENU_TOGGLE))
else if (BIT256_GET_PTR(p_trigger_input, RARCH_MENU_TOGGLE))
ret = MENU_ACTION_TOGGLE;
}
@ -314,7 +314,7 @@ unsigned menu_event(retro_bits_t* p_input, retro_bits_t* p_trigger_input)
menu_event_kb_set_internal(RETROK_F11, 0);
}
if (BIT128_GET_PTR(p_trigger_input, RARCH_QUIT_KEY))
if (BIT256_GET_PTR(p_trigger_input, RARCH_QUIT_KEY))
return MENU_ACTION_QUIT;
mouse_enabled = settings->bools.menu_mouse_enable;

106
retroarch.c
View File

@ -1931,7 +1931,7 @@ bool retroarch_override_setting_is_set(enum rarch_override_setting enum_idx, voi
if (val)
{
unsigned bit = *val;
return BIT128_GET(has_set_libretro_device, bit);
return BIT256_GET(has_set_libretro_device, bit);
}
}
break;
@ -1980,7 +1980,7 @@ void retroarch_override_setting_set(enum rarch_override_setting enum_idx, void *
if (val)
{
unsigned bit = *val;
BIT128_SET(has_set_libretro_device, bit);
BIT256_SET(has_set_libretro_device, bit);
}
}
break;
@ -2039,7 +2039,7 @@ void retroarch_override_setting_unset(enum rarch_override_setting enum_idx, void
if (val)
{
unsigned bit = *val;
BIT128_CLEAR(has_set_libretro_device, bit);
BIT256_CLEAR(has_set_libretro_device, bit);
}
}
break;
@ -2315,35 +2315,35 @@ static bool input_driver_toggle_button_combo(
switch (mode)
{
case INPUT_TOGGLE_DOWN_Y_L_R:
if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_DOWN))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_DOWN))
return false;
if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_Y))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_Y))
return false;
if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L))
return false;
if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R))
return false;
break;
case INPUT_TOGGLE_L3_R3:
if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L3))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L3))
return false;
if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R3))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R3))
return false;
break;
case INPUT_TOGGLE_L1_R1_START_SELECT:
if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_START))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_START))
return false;
if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_SELECT))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_SELECT))
return false;
if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L))
return false;
if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R))
return false;
break;
case INPUT_TOGGLE_START_SELECT:
if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_START))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_START))
return false;
if (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_SELECT))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_SELECT))
return false;
break;
default:
@ -2391,7 +2391,7 @@ static enum runloop_state runloop_check_state(
((settings->uints.input_menu_toggle_gamepad_combo != INPUT_TOGGLE_NONE) &&
input_driver_toggle_button_combo(
settings->uints.input_menu_toggle_gamepad_combo, &last_input)))
BIT128_SET(current_input, RARCH_MENU_TOGGLE);
BIT256_SET(current_input, RARCH_MENU_TOGGLE);
#endif
if (input_driver_flushing_input)
@ -2399,9 +2399,9 @@ static enum runloop_state runloop_check_state(
input_driver_flushing_input = false;
if (BITS_ANY_SET(current_input))
{
BIT128_CLEAR_ALL(current_input);
BIT256_CLEAR_ALL(current_input);
if (runloop_paused)
BIT128_SET(current_input, RARCH_PAUSE_TOGGLE);
BIT256_SET(current_input, RARCH_PAUSE_TOGGLE);
input_driver_flushing_input = true;
}
}
@ -2410,14 +2410,14 @@ static enum runloop_state runloop_check_state(
#ifdef HAVE_MENU
if (menu_driver_binding_state)
BIT128_CLEAR_ALL(current_input);
BIT256_CLEAR_ALL(current_input);
#endif
#ifdef HAVE_OVERLAY
/* Check next overlay */
{
static bool old_should_check_next_overlay = false;
bool should_check_next_overlay = BIT128_GET(
bool should_check_next_overlay = BIT256_GET(
current_input, RARCH_OVERLAY_NEXT);
if (should_check_next_overlay && !old_should_check_next_overlay)
@ -2429,7 +2429,7 @@ static enum runloop_state runloop_check_state(
/* Check fullscreen toggle */
{
bool fs_toggle_pressed = BIT128_GET(
bool fs_toggle_pressed = BIT256_GET(
current_input, RARCH_FULLSCREEN_TOGGLE_KEY);
fs_toggle_triggered = fs_toggle_pressed && !old_fs_toggle_pressed;
@ -2452,7 +2452,7 @@ static enum runloop_state runloop_check_state(
/* Check mouse grab toggle */
{
static bool old_pressed = false;
bool pressed = BIT128_GET(
bool pressed = BIT256_GET(
current_input, RARCH_GRAB_MOUSE_TOGGLE);
if (pressed && !old_pressed)
@ -2487,7 +2487,7 @@ static enum runloop_state runloop_check_state(
/* Check quit key */
{
static bool old_quit_key = false;
bool quit_key = BIT128_GET(
bool quit_key = BIT256_GET(
current_input, RARCH_QUIT_KEY);
bool trig_quit_key = quit_key && !old_quit_key;
@ -2579,7 +2579,7 @@ static enum runloop_state runloop_check_state(
/* Check game focus toggle */
{
static bool old_pressed = false;
bool pressed = BIT128_GET(
bool pressed = BIT256_GET(
current_input, RARCH_GAME_FOCUS_TOGGLE);
if (pressed && !old_pressed)
@ -2592,7 +2592,7 @@ static enum runloop_state runloop_check_state(
/* Check menu toggle */
{
static bool old_pressed = false;
bool pressed = BIT128_GET(
bool pressed = BIT256_GET(
current_input, RARCH_MENU_TOGGLE);
if (menu_event_kb_is_set(RETROK_F1) == 1)
@ -2642,7 +2642,7 @@ static enum runloop_state runloop_check_state(
/* Check screenshot toggle */
{
static bool old_pressed = false;
bool pressed = BIT128_GET(
bool pressed = BIT256_GET(
current_input, RARCH_SCREENSHOT);
if (pressed && old_pressed)
@ -2654,7 +2654,7 @@ static enum runloop_state runloop_check_state(
/* Check audio mute toggle */
{
static bool old_pressed = false;
bool pressed = BIT128_GET(
bool pressed = BIT256_GET(
current_input, RARCH_MUTE);
if (pressed && !old_pressed)
@ -2666,7 +2666,7 @@ static enum runloop_state runloop_check_state(
/* Check OSK toggle */
{
static bool old_pressed = false;
bool pressed = BIT128_GET(current_input, RARCH_OSK);
bool pressed = BIT256_GET(current_input, RARCH_OSK);
if (pressed && !old_pressed)
{
@ -2682,9 +2682,9 @@ static enum runloop_state runloop_check_state(
old_pressed = pressed;
}
if (BIT128_GET(current_input, RARCH_VOLUME_UP))
if (BIT256_GET(current_input, RARCH_VOLUME_UP))
command_event(CMD_EVENT_VOLUME_UP, NULL);
else if (BIT128_GET(current_input, RARCH_VOLUME_DOWN))
else if (BIT256_GET(current_input, RARCH_VOLUME_DOWN))
command_event(CMD_EVENT_VOLUME_DOWN, NULL);
#ifdef HAVE_NETWORKING
@ -2692,9 +2692,9 @@ static enum runloop_state runloop_check_state(
{
static bool old_netplay_flip = false;
static bool old_netplay_watch = false;
bool netplay_flip = BIT128_GET(
bool netplay_flip = BIT256_GET(
current_input, RARCH_NETPLAY_FLIP);
bool netplay_watch = BIT128_GET(
bool netplay_watch = BIT256_GET(
current_input, RARCH_NETPLAY_GAME_WATCH);
if (netplay_flip && !old_netplay_flip)
@ -2713,9 +2713,9 @@ static enum runloop_state runloop_check_state(
static bool old_frameadvance = false;
static bool old_pause_pressed = false;
bool check_is_oneshot = true;
bool frameadvance_pressed = BIT128_GET(
bool frameadvance_pressed = BIT256_GET(
current_input, RARCH_FRAMEADVANCE);
bool pause_pressed = BIT128_GET(
bool pause_pressed = BIT256_GET(
current_input, RARCH_PAUSE_TOGGLE);
bool trig_frameadvance = frameadvance_pressed && !old_frameadvance;
@ -2739,7 +2739,7 @@ static enum runloop_state runloop_check_state(
if (runloop_paused)
{
check_is_oneshot = trig_frameadvance ||
BIT128_GET(current_input, RARCH_REWIND);
BIT256_GET(current_input, RARCH_REWIND);
if (fs_toggle_triggered)
{
@ -2764,9 +2764,9 @@ static enum runloop_state runloop_check_state(
{
static bool old_button_state = false;
static bool old_hold_button_state = false;
bool new_button_state = BIT128_GET(
bool new_button_state = BIT256_GET(
current_input, RARCH_FAST_FORWARD_KEY);
bool new_hold_button_state = BIT128_GET(
bool new_hold_button_state = BIT256_GET(
current_input, RARCH_FAST_FORWARD_HOLD_KEY);
if (new_button_state && !old_button_state)
@ -2807,9 +2807,9 @@ static enum runloop_state runloop_check_state(
{
static bool old_should_slot_increase = false;
static bool old_should_slot_decrease = false;
bool should_slot_increase = BIT128_GET(
bool should_slot_increase = BIT256_GET(
current_input, RARCH_STATE_SLOT_PLUS);
bool should_slot_decrease = BIT128_GET(
bool should_slot_decrease = BIT256_GET(
current_input, RARCH_STATE_SLOT_MINUS);
/* Checks if the state increase/decrease keys have been pressed
@ -2860,9 +2860,9 @@ static enum runloop_state runloop_check_state(
{
static bool old_should_savestate = false;
static bool old_should_loadstate = false;
bool should_savestate = BIT128_GET(
bool should_savestate = BIT256_GET(
current_input, RARCH_SAVE_STATE_KEY);
bool should_loadstate = BIT128_GET(
bool should_loadstate = BIT256_GET(
current_input, RARCH_LOAD_STATE_KEY);
if (should_savestate && !old_should_savestate)
@ -2883,14 +2883,14 @@ static enum runloop_state runloop_check_state(
s[0] = '\0';
if (state_manager_check_rewind(BIT128_GET(current_input, RARCH_REWIND),
if (state_manager_check_rewind(BIT256_GET(current_input, RARCH_REWIND),
settings->uints.rewind_granularity, runloop_paused, s, sizeof(s), &t))
runloop_msg_queue_push(s, 0, t, true);
}
/* Checks if slowmotion toggle/hold was being pressed and/or held. */
{
runloop_slowmotion = BIT128_GET(current_input, RARCH_SLOWMOTION);
runloop_slowmotion = BIT256_GET(current_input, RARCH_SLOWMOTION);
if (runloop_slowmotion)
{
@ -2912,7 +2912,7 @@ static enum runloop_state runloop_check_state(
/* Check movie record toggle */
{
static bool old_pressed = false;
bool pressed = BIT128_GET(
bool pressed = BIT256_GET(
current_input, RARCH_MOVIE_RECORD_TOGGLE);
if (pressed && !old_pressed)
@ -2925,9 +2925,9 @@ static enum runloop_state runloop_check_state(
{
static bool old_shader_next = false;
static bool old_shader_prev = false;
bool shader_next = BIT128_GET(
bool shader_next = BIT256_GET(
current_input, RARCH_SHADER_NEXT);
bool shader_prev = BIT128_GET(
bool shader_prev = BIT256_GET(
current_input, RARCH_SHADER_PREV);
bool trig_shader_next = shader_next && !old_shader_next;
bool trig_shader_prev = shader_prev && !old_shader_prev;
@ -2944,11 +2944,11 @@ static enum runloop_state runloop_check_state(
static bool old_disk_eject = false;
static bool old_disk_next = false;
static bool old_disk_prev = false;
bool disk_eject = BIT128_GET(
bool disk_eject = BIT256_GET(
current_input, RARCH_DISK_EJECT_TOGGLE);
bool disk_next = BIT128_GET(
bool disk_next = BIT256_GET(
current_input, RARCH_DISK_NEXT);
bool disk_prev = BIT128_GET(
bool disk_prev = BIT256_GET(
current_input, RARCH_DISK_PREV);
if (disk_eject && !old_disk_eject)
@ -2966,7 +2966,7 @@ static enum runloop_state runloop_check_state(
/* Check reset */
{
static bool old_state = false;
bool new_state = BIT128_GET(
bool new_state = BIT256_GET(
current_input, RARCH_RESET);
if (new_state && !old_state)
@ -2980,11 +2980,11 @@ static enum runloop_state runloop_check_state(
static bool old_cheat_index_plus = false;
static bool old_cheat_index_minus = false;
static bool old_cheat_index_toggle = false;
bool cheat_index_plus = BIT128_GET(
bool cheat_index_plus = BIT256_GET(
current_input, RARCH_CHEAT_INDEX_PLUS);
bool cheat_index_minus = BIT128_GET(
bool cheat_index_minus = BIT256_GET(
current_input, RARCH_CHEAT_INDEX_MINUS);
bool cheat_index_toggle = BIT128_GET(
bool cheat_index_toggle = BIT256_GET(
current_input, RARCH_CHEAT_TOGGLE);
if (cheat_index_plus && !old_cheat_index_plus)