mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-03-28 08:37:41 +00:00
Code Issues Packages 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 #else
static INLINE HRESULT XAudio2Create(IXAudio2 **ppXAudio2, UINT32 flags, XAUDIO2_PROCESSOR proc) static INLINE HRESULT XAudio2Create(IXAudio2 **ppXAudio2, UINT32 flags, XAUDIO2_PROCESSOR proc)
{ {
HRESULT hr;
IXAudio2 *pXAudio2 = NULL; IXAudio2 *pXAudio2 = NULL;
(void)flags;
(void)proc;
#ifdef __cplusplus #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 #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 #endif
if (SUCCEEDED(hr)) if (SUCCEEDED(hr))
@ -342,9 +337,7 @@ static INLINE HRESULT XAudio2Create(IXAudio2 **ppXAudio2, UINT32 flags, XAUDIO2_
if (SUCCEEDED(hr)) if (SUCCEEDED(hr))
*ppXAudio2 = pXAudio2; *ppXAudio2 = pXAudio2;
else else
{
IXAudio2_Release(pXAudio2); IXAudio2_Release(pXAudio2);
}
} }
return hr; 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); BITS_COPY16_PTR(state, device->buttons);
} }
else else
BIT128_CLEAR_ALL_PTR(state); BIT256_CLEAR_ALL_PTR(state);
} }
static int16_t hidpad_nesusb_get_axis(void *data, unsigned axis) 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); BITS_COPY16_PTR(state, device->buttons);
} }
else else
BIT128_CLEAR_ALL_PTR(state); BIT256_CLEAR_ALL_PTR(state);
} }
static int16_t hidpad_ps2adapter_get_axis(void *data, unsigned axis) 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?*/ /*PS button?*/
if (device->buttons & 0x10000) if (device->buttons & 0x10000)
BIT128_SET_PTR(state, RARCH_MENU_TOGGLE); BIT256_SET_PTR(state, RARCH_MENU_TOGGLE);
} }
else else
BIT128_CLEAR_ALL_PTR(state); BIT256_CLEAR_ALL_PTR(state);
} }
static int16_t hidpad_ps3_get_axis(void *data, unsigned axis) 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) if (!device || !rpt)
return; return;
BIT128_CLEAR_ALL_PTR( state ); BIT256_CLEAR_ALL_PTR( state );
if (rpt->btn.r3) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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))) 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))) 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))) 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))) 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) 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) 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); BITS_COPY16_PTR(state, device->buttons);
} }
else else
BIT128_CLEAR_ALL_PTR(state); BIT256_CLEAR_ALL_PTR(state);
} }
static int16_t hidpad_psxadapter_get_axis(void *data, unsigned axis) 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); BITS_COPY16_PTR(state, device->buttons);
} }
else else
BIT128_CLEAR_ALL_PTR(state); BIT256_CLEAR_ALL_PTR(state);
} }
static int16_t hidpad_snesusb_get_axis(void *data, unsigned axis) 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); BITS_COPY16_PTR(state, device->buttons);
} }
else else
BIT128_CLEAR_ALL_PTR(state); BIT256_CLEAR_ALL_PTR(state);
} }
static int16_t hidpad_wiiugca_get_axis(void *data, unsigned axis) 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) if (!device || !rpt)
return; return;
BIT128_CLEAR_ALL_PTR(state); BIT256_CLEAR_ALL_PTR(state);
if (rpt->btn.r3) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) void pad_connection_get_buttons(joypad_connection_t *joyconn, unsigned pad, retro_bits_t* state)
{ {
if (joyconn->iface) if (joyconn->iface)
{
joyconn->iface->get_buttons(joyconn->data, state); joyconn->iface->get_buttons(joyconn->data, state);
}
else else
BIT128_CLEAR_ALL_PTR( state ); BIT256_CLEAR_ALL_PTR( state );
} }
int16_t pad_connection_get_axis(joypad_connection_t *joyconn, 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) if (state)
for (i = 0; i < 256; i++) for (i = 0; i < 256; i++)
if (BIT128_GET_PTR(state,i)) if (BIT256_GET_PTR(state,i))
return i; return i;
return -1; 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; retro_bits_t state;
wiiu->joypad->get_buttons(0, &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: case RETRO_DEVICE_ID_POINTER_X:
return wiiu->joypad->axis(0, 0xFFFF0004UL); 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) static bool winraw_mbutton_pressed(winraw_input_t *wr, unsigned port, unsigned key)
{ {
unsigned i; unsigned i;
bool result;
winraw_mouse_t *mouse = NULL; winraw_mouse_t *mouse = NULL;
settings_t *settings = config_get_ptr(); settings_t *settings = config_get_ptr();
if (port >= MAX_USERS) if (port >= MAX_USERS)
return false; 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) if (hid)
pad_connection_get_buttons(&hid->slots[port], port, state); pad_connection_get_buttons(&hid->slots[port], port, state);
else else
BIT128_CLEAR_ALL_PTR(state); BIT256_CLEAR_ALL_PTR(state);
} }
static bool btstack_hid_joypad_button(void *data, unsigned port, uint16_t joykey) 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. */ /* Check the button. */
if ((port < MAX_USERS) && (joykey < 32)) if ((port < MAX_USERS) && (joykey < 32))
return (BIT128_GET(buttons, joykey) != 0); return (BIT256_GET(buttons, joykey) != 0);
return false; 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) if (hid)
return pad_connection_get_buttons(&hid->slots[port], port, state); return pad_connection_get_buttons(&hid->slots[port], port, state);
else else
BIT128_CLEAR_ALL_PTR(state); BIT256_CLEAR_ALL_PTR(state);
} }
static bool iohidmanager_hid_joypad_button(void *data, static bool iohidmanager_hid_joypad_button(void *data,
@ -150,7 +150,7 @@ static bool iohidmanager_hid_joypad_button(void *data,
/* Check the button. */ /* Check the button. */
if ((port < MAX_USERS) && (joykey < 32)) if ((port < MAX_USERS) && (joykey < 32))
return (BIT128_GET(buttons, joykey) != 0) return (BIT256_GET(buttons, joykey) != 0)
|| ((hid->buttons[port] & (1 << joykey)) != 0); || ((hid->buttons[port] & (1 << joykey)) != 0);
return false; 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; libusb_hid_t *hid = (libusb_hid_t*)data;
if (hid) if (hid)
return pad_connection_get_buttons(&hid->slots[port], port, state); {
else pad_connection_get_buttons(&hid->slots[port], port, state);
BIT128_CLEAR_ALL_PTR(state); return;
}
BIT256_CLEAR_ALL_PTR(state);
} }
static bool libusb_hid_joypad_button(void *data, static bool libusb_hid_joypad_button(void *data,
@ -464,7 +467,7 @@ static bool libusb_hid_joypad_button(void *data,
/* Check the button. */ /* Check the button. */
if ((port < MAX_USERS) && (joykey < 32)) if ((port < MAX_USERS) && (joykey < 32))
return (BIT128_GET(buttons, joykey) != 0); return (BIT256_GET(buttons, joykey) != 0);
return false; 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)data;
(void)port; (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) 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; wiiusb_hid_t *hid = (wiiusb_hid_t*)data;
if (hid) if (hid)
return pad_connection_get_buttons(&hid->connections[port], port, state); {
else pad_connection_get_buttons(&hid->connections[port], port, state);
BIT128_CLEAR_ALL_PTR(state); return;
}
BIT256_CLEAR_ALL_PTR(state);
} }
static bool wiiusb_hid_joypad_button(void *data, unsigned port, uint16_t joykey) 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. */ /* Check the button. */
if ((port < MAX_USERS) && (joykey < 32)) if ((port < MAX_USERS) && (joykey < 32))
return (BIT128_GET(buttons, joykey) != 0); return (BIT256_GET(buttons, joykey) != 0);
return false; 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 ); BITS_COPY16_PTR( state, pad_state );
} }
else else
BIT128_CLEAR_ALL_PTR(state); BIT256_CLEAR_ALL_PTR(state);
} }
static int16_t ctr_joypad_axis(unsigned port_num, uint32_t joyaxis) 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] ); BITS_COPY16_PTR( state, pad_state[port] );
} }
else else
BIT128_CLEAR_ALL_PTR(state); BIT256_CLEAR_ALL_PTR(state);
} }
static int16_t gx_joypad_axis(unsigned port, uint32_t joyaxis) 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) if (generic_hid && generic_hid->get_buttons)
generic_hid->get_buttons((void*)hid_driver_get_data(), port, state); generic_hid->get_buttons((void*)hid_driver_get_data(), port, state);
else else
BIT128_CLEAR_ALL_PTR(state); BIT256_CLEAR_ALL_PTR(state);
} }
static int16_t hid_joypad_axis(unsigned port, uint32_t joyaxis) 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); BITS_COPY16_PTR(state, pad->buttons);
} }
else else
BIT128_CLEAR_ALL_PTR(state); BIT256_CLEAR_ALL_PTR(state);
} }
static int16_t linuxraw_joypad_axis(unsigned port, uint32_t joyaxis) 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) 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) 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); BITS_COPY16_PTR(state, pad->buttons);
} }
else else
BIT128_CLEAR_ALL_PTR(state); BIT256_CLEAR_ALL_PTR(state);
} }
static int16_t parport_joypad_axis(unsigned port, uint32_t joyaxis) 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] ); BITS_COPY16_PTR( state, pad_state[port_num] );
} }
else else
BIT128_CLEAR_ALL_PTR(state); BIT256_CLEAR_ALL_PTR(state);
} }
static int16_t ps3_joypad_axis(unsigned port_num, uint32_t joyaxis) 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] ); BITS_COPY16_PTR( state, pad_state[port_num] );
} }
else else
BIT128_CLEAR_ALL_PTR(state); BIT256_CLEAR_ALL_PTR(state);
} }
static int16_t psp_joypad_axis(unsigned port_num, uint32_t joyaxis) 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 ); BITS_COPY16_PTR( state, pad->buttons );
} }
else else
BIT128_CLEAR_ALL_PTR(state); BIT256_CLEAR_ALL_PTR(state);
} }
static int16_t udev_joypad_axis(unsigned port, uint32_t joyaxis) 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] ); BITS_COPY16_PTR( state, pad_state[port_num] );
} }
else else
BIT128_CLAR_ALL_PTR(state); BIT256_CLEAR_ALL_PTR(state);
} }
static int16_t wiiu_joypad_axis(unsigned port_num, uint32_t joyaxis) 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] ); BITS_COPY16_PTR( state, pad_state[port_num] );
} }
else else
BIT128_CLEAR_ALL_PTR(state); BIT256_CLEAR_ALL_PTR(state);
} }
static int16_t xdk_joypad_axis(unsigned port_num, uint32_t joyaxis) 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.joy_idx = 0;
joypad_info.auto_binds = NULL; 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_libretro_input = false;
input_driver_block_hotkey = 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) if (pressed)
{ {
BIT128_SET_PTR(p_new_state, i); BIT256_SET_PTR(p_new_state, i);
continue; 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)) 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; continue;
} }
} }
@ -930,7 +930,7 @@ void input_menu_keys_pressed(void *data, retro_bits_t* p_new_state)
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
if (overlay_ptr && input_overlay_key_pressed(overlay_ptr, i)) 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; continue;
} }
#endif #endif
@ -945,7 +945,7 @@ void input_menu_keys_pressed(void *data, retro_bits_t* p_new_state)
if (command_get(&handle)) if (command_get(&handle))
{ {
BIT128_SET_PTR(p_new_state, i); BIT256_SET_PTR(p_new_state, i);
continue; continue;
} }
} }
@ -954,7 +954,7 @@ void input_menu_keys_pressed(void *data, retro_bits_t* p_new_state)
#ifdef HAVE_NETWORKGAMEPAD #ifdef HAVE_NETWORKGAMEPAD
if (input_driver_remote && input_remote_key_pressed(i, 0)) 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; continue;
} }
#endif #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, if (current_input->input_state(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]))
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]; const struct retro_keybind *enable_hotkey = &input_config_binds[0][RARCH_ENABLE_HOTKEY];
bool game_focus_toggle_valid = false; 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.joy_idx = settings->uints.input_joypad_map[0];
joypad_info.auto_binds = input_autoconf_binds[joypad_info.joy_idx]; 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) 0, RETRO_DEVICE_JOYPAD, 0, i)
) )
{ {
BIT128_SET_PTR(p_new_state, i); BIT256_SET_PTR(p_new_state, i);
continue; 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) current_input->meta_key_pressed(current_input_data, i)
) )
{ {
BIT128_SET_PTR(p_new_state, i); BIT256_SET_PTR(p_new_state, i);
continue; continue;
} }
@ -1099,7 +1099,7 @@ void input_keys_pressed(void *data, retro_bits_t* p_new_state)
if (overlay_ptr && if (overlay_ptr &&
input_overlay_key_pressed(overlay_ptr, i)) input_overlay_key_pressed(overlay_ptr, i))
{ {
BIT128_SET_PTR(p_new_state, i); BIT256_SET_PTR(p_new_state, i);
continue; continue;
} }
#endif #endif
@ -1114,7 +1114,7 @@ void input_keys_pressed(void *data, retro_bits_t* p_new_state)
if (command_get(&handle)) if (command_get(&handle))
{ {
BIT128_SET_PTR(p_new_state, i); BIT256_SET_PTR(p_new_state, i);
continue; continue;
} }
} }
@ -1124,7 +1124,7 @@ void input_keys_pressed(void *data, retro_bits_t* p_new_state)
if (input_driver_remote && if (input_driver_remote &&
input_remote_key_pressed(i, 0)) input_remote_key_pressed(i, 0))
{ {
BIT128_SET_PTR(p_new_state, i); BIT256_SET_PTR(p_new_state, i);
continue; continue;
} }
#endif #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 && unsigned menu_cancel_btn = (!input_swap_override &&
settings->bools.input_menu_swap_ok_cancel_buttons) ? settings->bools.input_menu_swap_ok_cancel_buttons) ?
RETRO_DEVICE_ID_JOYPAD_A : RETRO_DEVICE_ID_JOYPAD_B; 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; unsigned ok_trigger = ok_current & ~ok_old;
ok_old = ok_current; 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(); 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) if (menu_event_get_osk_ptr() < 33)
menu_event_set_osk_ptr(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_UP)) if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_UP))
{ {
if (menu_event_get_osk_ptr() >= OSK_CHARS_PER_LINE) if (menu_event_get_osk_ptr() >= OSK_CHARS_PER_LINE)
menu_event_set_osk_ptr(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) if (menu_event_get_osk_ptr() < 43)
menu_event_set_osk_ptr(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_LEFT)) if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_LEFT))
{ {
if (menu_event_get_osk_ptr() >= 1) if (menu_event_get_osk_ptr() >= 1)
menu_event_set_osk_ptr(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) if (menu_event_get_osk_idx() > OSK_TYPE_UNKNOWN + 1)
menu_event_set_osk_idx((enum osk_type)(menu_event_get_osk_idx() - 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)); 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) if (menu_event_get_osk_idx() < OSK_TYPE_LAST - 1)
menu_event_set_osk_idx((enum osk_type)(menu_event_get_osk_idx() + 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)); 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) if (menu_event_get_osk_ptr() >= 0)
menu_event_osk_append(menu_event_get_osk_ptr()); 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); input_keyboard_event(true, '\x7f', '\x7f', 0, RETRO_DEVICE_KEYBOARD);
} }
/* send return key to close keyboard input window */ /* 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); 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 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; 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; 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; 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; 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; 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; ret = MENU_ACTION_SCROLL_DOWN;
else if (ok_trigger) else if (ok_trigger)
ret = MENU_ACTION_OK; 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; 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; 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; 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; 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; 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; 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); 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; return MENU_ACTION_QUIT;
mouse_enabled = settings->bools.menu_mouse_enable; 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) if (val)
{ {
unsigned bit = *val; unsigned bit = *val;
return BIT128_GET(has_set_libretro_device, bit); return BIT256_GET(has_set_libretro_device, bit);
} }
} }
break; break;
@ -1980,7 +1980,7 @@ void retroarch_override_setting_set(enum rarch_override_setting enum_idx, void *
if (val) if (val)
{ {
unsigned bit = *val; unsigned bit = *val;
BIT128_SET(has_set_libretro_device, bit); BIT256_SET(has_set_libretro_device, bit);
} }
} }
break; break;
@ -2039,7 +2039,7 @@ void retroarch_override_setting_unset(enum rarch_override_setting enum_idx, void
if (val) if (val)
{ {
unsigned bit = *val; unsigned bit = *val;
BIT128_CLEAR(has_set_libretro_device, bit); BIT256_CLEAR(has_set_libretro_device, bit);
} }
} }
break; break;
@ -2315,35 +2315,35 @@ 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 (!BIT128_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_DOWN)) if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_DOWN))
return false; 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; 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; 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; return false;
break; break;
case INPUT_TOGGLE_L3_R3: 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; 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; return false;
break; break;
case INPUT_TOGGLE_L1_R1_START_SELECT: 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; 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; 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; 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; return false;
break; break;
case INPUT_TOGGLE_START_SELECT: 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; 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; return false;
break; break;
default: default:
@ -2391,7 +2391,7 @@ static enum runloop_state runloop_check_state(
((settings->uints.input_menu_toggle_gamepad_combo != INPUT_TOGGLE_NONE) && ((settings->uints.input_menu_toggle_gamepad_combo != INPUT_TOGGLE_NONE) &&
input_driver_toggle_button_combo( input_driver_toggle_button_combo(
settings->uints.input_menu_toggle_gamepad_combo, &last_input))) settings->uints.input_menu_toggle_gamepad_combo, &last_input)))
BIT128_SET(current_input, RARCH_MENU_TOGGLE); BIT256_SET(current_input, RARCH_MENU_TOGGLE);
#endif #endif
if (input_driver_flushing_input) if (input_driver_flushing_input)
@ -2399,9 +2399,9 @@ static enum runloop_state runloop_check_state(
input_driver_flushing_input = false; input_driver_flushing_input = false;
if (BITS_ANY_SET(current_input)) if (BITS_ANY_SET(current_input))
{ {
BIT128_CLEAR_ALL(current_input); BIT256_CLEAR_ALL(current_input);
if (runloop_paused) if (runloop_paused)
BIT128_SET(current_input, RARCH_PAUSE_TOGGLE); BIT256_SET(current_input, RARCH_PAUSE_TOGGLE);
input_driver_flushing_input = true; input_driver_flushing_input = true;
} }
} }
@ -2410,14 +2410,14 @@ static enum runloop_state runloop_check_state(
#ifdef HAVE_MENU #ifdef HAVE_MENU
if (menu_driver_binding_state) if (menu_driver_binding_state)
BIT128_CLEAR_ALL(current_input); BIT256_CLEAR_ALL(current_input);
#endif #endif
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
/* Check next overlay */ /* Check next overlay */
{ {
static bool old_should_check_next_overlay = false; 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); current_input, RARCH_OVERLAY_NEXT);
if (should_check_next_overlay && !old_should_check_next_overlay) if (should_check_next_overlay && !old_should_check_next_overlay)
@ -2429,7 +2429,7 @@ static enum runloop_state runloop_check_state(
/* Check fullscreen toggle */ /* Check fullscreen toggle */
{ {
bool fs_toggle_pressed = BIT128_GET( bool fs_toggle_pressed = BIT256_GET(
current_input, RARCH_FULLSCREEN_TOGGLE_KEY); current_input, RARCH_FULLSCREEN_TOGGLE_KEY);
fs_toggle_triggered = fs_toggle_pressed && !old_fs_toggle_pressed; 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 */ /* Check mouse grab toggle */
{ {
static bool old_pressed = false; static bool old_pressed = false;
bool pressed = BIT128_GET( bool pressed = BIT256_GET(
current_input, RARCH_GRAB_MOUSE_TOGGLE); current_input, RARCH_GRAB_MOUSE_TOGGLE);
if (pressed && !old_pressed) if (pressed && !old_pressed)
@ -2487,7 +2487,7 @@ static enum runloop_state runloop_check_state(
/* Check quit key */ /* Check quit key */
{ {
static bool old_quit_key = false; static bool old_quit_key = false;
bool quit_key = BIT128_GET( bool quit_key = BIT256_GET(
current_input, RARCH_QUIT_KEY); current_input, RARCH_QUIT_KEY);
bool trig_quit_key = quit_key && !old_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 */ /* Check game focus toggle */
{ {
static bool old_pressed = false; static bool old_pressed = false;
bool pressed = BIT128_GET( bool pressed = BIT256_GET(
current_input, RARCH_GAME_FOCUS_TOGGLE); current_input, RARCH_GAME_FOCUS_TOGGLE);
if (pressed && !old_pressed) if (pressed && !old_pressed)
@ -2592,7 +2592,7 @@ static enum runloop_state runloop_check_state(
/* Check menu toggle */ /* Check menu toggle */
{ {
static bool old_pressed = false; static bool old_pressed = false;
bool pressed = BIT128_GET( bool pressed = BIT256_GET(
current_input, RARCH_MENU_TOGGLE); current_input, RARCH_MENU_TOGGLE);
if (menu_event_kb_is_set(RETROK_F1) == 1) if (menu_event_kb_is_set(RETROK_F1) == 1)
@ -2642,7 +2642,7 @@ static enum runloop_state runloop_check_state(
/* Check screenshot toggle */ /* Check screenshot toggle */
{ {
static bool old_pressed = false; static bool old_pressed = false;
bool pressed = BIT128_GET( bool pressed = BIT256_GET(
current_input, RARCH_SCREENSHOT); current_input, RARCH_SCREENSHOT);
if (pressed && old_pressed) if (pressed && old_pressed)
@ -2654,7 +2654,7 @@ static enum runloop_state runloop_check_state(
/* Check audio mute toggle */ /* Check audio mute toggle */
{ {
static bool old_pressed = false; static bool old_pressed = false;
bool pressed = BIT128_GET( bool pressed = BIT256_GET(
current_input, RARCH_MUTE); current_input, RARCH_MUTE);
if (pressed && !old_pressed) if (pressed && !old_pressed)
@ -2666,7 +2666,7 @@ static enum runloop_state runloop_check_state(
/* Check OSK toggle */ /* Check OSK toggle */
{ {
static bool old_pressed = false; 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) if (pressed && !old_pressed)
{ {
@ -2682,9 +2682,9 @@ static enum runloop_state runloop_check_state(
old_pressed = pressed; 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); 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); command_event(CMD_EVENT_VOLUME_DOWN, NULL);
#ifdef HAVE_NETWORKING #ifdef HAVE_NETWORKING
@ -2692,9 +2692,9 @@ static enum runloop_state runloop_check_state(
{ {
static bool old_netplay_flip = false; static bool old_netplay_flip = false;
static bool old_netplay_watch = false; static bool old_netplay_watch = false;
bool netplay_flip = BIT128_GET( bool netplay_flip = BIT256_GET(
current_input, RARCH_NETPLAY_FLIP); current_input, RARCH_NETPLAY_FLIP);
bool netplay_watch = BIT128_GET( bool netplay_watch = BIT256_GET(
current_input, RARCH_NETPLAY_GAME_WATCH); current_input, RARCH_NETPLAY_GAME_WATCH);
if (netplay_flip && !old_netplay_flip) 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_frameadvance = false;
static bool old_pause_pressed = false; static bool old_pause_pressed = false;
bool check_is_oneshot = true; bool check_is_oneshot = true;
bool frameadvance_pressed = BIT128_GET( bool frameadvance_pressed = BIT256_GET(
current_input, RARCH_FRAMEADVANCE); current_input, RARCH_FRAMEADVANCE);
bool pause_pressed = BIT128_GET( bool pause_pressed = BIT256_GET(
current_input, RARCH_PAUSE_TOGGLE); current_input, RARCH_PAUSE_TOGGLE);
bool trig_frameadvance = frameadvance_pressed && !old_frameadvance; bool trig_frameadvance = frameadvance_pressed && !old_frameadvance;
@ -2739,7 +2739,7 @@ static enum runloop_state runloop_check_state(
if (runloop_paused) if (runloop_paused)
{ {
check_is_oneshot = trig_frameadvance || check_is_oneshot = trig_frameadvance ||
BIT128_GET(current_input, RARCH_REWIND); BIT256_GET(current_input, RARCH_REWIND);
if (fs_toggle_triggered) if (fs_toggle_triggered)
{ {
@ -2764,9 +2764,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 = BIT128_GET( bool new_button_state = BIT256_GET(
current_input, RARCH_FAST_FORWARD_KEY); 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); current_input, RARCH_FAST_FORWARD_HOLD_KEY);
if (new_button_state && !old_button_state) 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_increase = false;
static bool old_should_slot_decrease = 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); current_input, RARCH_STATE_SLOT_PLUS);
bool should_slot_decrease = BIT128_GET( bool should_slot_decrease = BIT256_GET(
current_input, RARCH_STATE_SLOT_MINUS); current_input, RARCH_STATE_SLOT_MINUS);
/* Checks if the state increase/decrease keys have been pressed /* 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_savestate = false;
static bool old_should_loadstate = false; static bool old_should_loadstate = false;
bool should_savestate = BIT128_GET( bool should_savestate = BIT256_GET(
current_input, RARCH_SAVE_STATE_KEY); current_input, RARCH_SAVE_STATE_KEY);
bool should_loadstate = BIT128_GET( bool should_loadstate = BIT256_GET(
current_input, RARCH_LOAD_STATE_KEY); current_input, RARCH_LOAD_STATE_KEY);
if (should_savestate && !old_should_savestate) if (should_savestate && !old_should_savestate)
@ -2883,14 +2883,14 @@ static enum runloop_state runloop_check_state(
s[0] = '\0'; 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)) settings->uints.rewind_granularity, runloop_paused, s, sizeof(s), &t))
runloop_msg_queue_push(s, 0, t, true); runloop_msg_queue_push(s, 0, t, true);
} }
/* Checks if slowmotion toggle/hold was being pressed and/or held. */ /* 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) if (runloop_slowmotion)
{ {
@ -2912,7 +2912,7 @@ static enum runloop_state runloop_check_state(
/* Check movie record toggle */ /* Check movie record toggle */
{ {
static bool old_pressed = false; static bool old_pressed = false;
bool pressed = BIT128_GET( bool pressed = BIT256_GET(
current_input, RARCH_MOVIE_RECORD_TOGGLE); current_input, RARCH_MOVIE_RECORD_TOGGLE);
if (pressed && !old_pressed) 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_next = false;
static bool old_shader_prev = false; static bool old_shader_prev = false;
bool shader_next = BIT128_GET( bool shader_next = BIT256_GET(
current_input, RARCH_SHADER_NEXT); current_input, RARCH_SHADER_NEXT);
bool shader_prev = BIT128_GET( bool shader_prev = BIT256_GET(
current_input, RARCH_SHADER_PREV); current_input, RARCH_SHADER_PREV);
bool trig_shader_next = shader_next && !old_shader_next; bool trig_shader_next = shader_next && !old_shader_next;
bool trig_shader_prev = shader_prev && !old_shader_prev; 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_eject = false;
static bool old_disk_next = false; static bool old_disk_next = false;
static bool old_disk_prev = false; static bool old_disk_prev = false;
bool disk_eject = BIT128_GET( bool disk_eject = BIT256_GET(
current_input, RARCH_DISK_EJECT_TOGGLE); current_input, RARCH_DISK_EJECT_TOGGLE);
bool disk_next = BIT128_GET( bool disk_next = BIT256_GET(
current_input, RARCH_DISK_NEXT); current_input, RARCH_DISK_NEXT);
bool disk_prev = BIT128_GET( bool disk_prev = BIT256_GET(
current_input, RARCH_DISK_PREV); current_input, RARCH_DISK_PREV);
if (disk_eject && !old_disk_eject) if (disk_eject && !old_disk_eject)
@ -2966,7 +2966,7 @@ static enum runloop_state runloop_check_state(
/* Check reset */ /* Check reset */
{ {
static bool old_state = false; static bool old_state = false;
bool new_state = BIT128_GET( bool new_state = BIT256_GET(
current_input, RARCH_RESET); current_input, RARCH_RESET);
if (new_state && !old_state) 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_plus = false;
static bool old_cheat_index_minus = false; static bool old_cheat_index_minus = false;
static bool old_cheat_index_toggle = 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); current_input, RARCH_CHEAT_INDEX_PLUS);
bool cheat_index_minus = BIT128_GET( bool cheat_index_minus = BIT256_GET(
current_input, RARCH_CHEAT_INDEX_MINUS); current_input, RARCH_CHEAT_INDEX_MINUS);
bool cheat_index_toggle = BIT128_GET( bool cheat_index_toggle = BIT256_GET(
current_input, RARCH_CHEAT_TOGGLE); current_input, RARCH_CHEAT_TOGGLE);
if (cheat_index_plus && !old_cheat_index_plus) if (cheat_index_plus && !old_cheat_index_plus)