static retro_input_t input_driver_keys_pressed(void) { unsigned key; retro_input_t ret = 0; for (key = 0; key < RARCH_BIND_LIST_END; key++) { bool state = false; if ((!input_driver_ctl(RARCH_INPUT_CTL_IS_LIBRETRO_INPUT_BLOCKED, NULL) && ((key < RARCH_FIRST_META_KEY))) || !input_driver_ctl(RARCH_INPUT_CTL_IS_HOTKEY_BLOCKED, NULL)) state = input_driver_ctl(RARCH_INPUT_CTL_KEY_PRESSED, &key); if (key >= RARCH_FIRST_META_KEY) state |= current_input->meta_key_pressed(current_input_data, key); #ifdef HAVE_OVERLAY state |= input_overlay_key_pressed(key); #endif #ifdef HAVE_COMMAND if (input_driver_command) state |= rarch_cmd_get(input_driver_command, key); #endif #ifdef HAVE_NETWORK_GAMEPAD if (input_driver_remote) state |= input_remote_key_pressed(key,0); #endif if (state) ret |= (UINT64_C(1) << key); } return ret; }
retro_input_t input_driver_keys_pressed(void) { int key; retro_input_t ret = 0; driver_t *driver = driver_get_ptr(); const input_driver_t *input = input_get_ptr(driver); for (key = 0; key < RARCH_BIND_LIST_END; key++) { bool state = false; if ((!driver->block_libretro_input && ((key < RARCH_FIRST_META_KEY))) || !driver->block_hotkey) state = input->key_pressed(driver->input_data, key); if (key >= RARCH_FIRST_META_KEY) state |= input->meta_key_pressed(driver->input_data, key); #ifdef HAVE_OVERLAY state |= input_overlay_key_pressed(key); #endif #ifdef HAVE_COMMAND if (driver->command) state |= rarch_cmd_get(driver->command, key); #endif if (state) ret |= (UINT64_C(1) << key); } return ret; }
retro_input_t input_driver_keys_pressed(uint64_t *device_type) { int key; retro_input_t ret = 0; driver_t *driver = driver_get_ptr(); const input_driver_t *input = input_get_ptr(driver); for (key = 0; key < RARCH_BIND_LIST_END; key++) { bool state = false; enum input_device_type device = INPUT_DEVICE_TYPE_NONE; if ((!driver->block_libretro_input && ((key < RARCH_FIRST_META_KEY))) || !driver->block_hotkey) state = input->key_pressed(driver->input_data, key, &device); if (key >= RARCH_FIRST_META_KEY) state |= input->meta_key_pressed(driver->input_data, key, &device); if (device == INPUT_DEVICE_TYPE_JOYPAD) BIT64_SET(*device_type, key); #ifdef HAVE_OVERLAY state |= input_overlay_key_pressed(key); #endif #ifdef HAVE_COMMAND if (driver->command) state |= rarch_cmd_get(driver->command, key); #endif if (state) ret |= (UINT64_C(1) << key); } return ret; }
static retro_input_t input_driver_keys_pressed(void) { unsigned key; retro_input_t ret = {0}; for (key = 0; key < RARCH_BIND_LIST_END; key++) { bool state = false; if ((!input_driver_is_libretro_input_blocked() && ((key < RARCH_FIRST_META_KEY))) || !input_driver_is_hotkey_blocked()) state = input_driver_key_pressed(&key); if (key >= RARCH_FIRST_META_KEY) state |= current_input->meta_key_pressed(current_input_data, key); #ifdef HAVE_OVERLAY state |= input_overlay_key_pressed(key); #endif #ifdef HAVE_COMMAND if (input_driver_command) { command_handle_t handle; handle.handle = input_driver_command; handle.id = key; state |= command_get(&handle); } #endif #ifdef HAVE_NETWORKGAMEPAD if (input_driver_remote) state |= input_remote_key_pressed(key,0); #endif if (state) ret.state |= (UINT64_C(1) << key); } return ret; }
void input_state_overlay(int16_t *ret, unsigned port, unsigned device, unsigned idx, unsigned id) { input_overlay_state_t *ol_state = &overlay_st_ptr; if (!ol_state) return; if (port != 0) return; switch (device) { case RETRO_DEVICE_JOYPAD: if (input_overlay_key_pressed(id)) *ret |= 1; break; case RETRO_DEVICE_KEYBOARD: if (id < RETROK_LAST) { if (OVERLAY_GET_KEY(ol_state, id)) *ret |= 1; } break; case RETRO_DEVICE_ANALOG: { unsigned base = 0; if (idx == RETRO_DEVICE_INDEX_ANALOG_RIGHT) base = 2; if (id == RETRO_DEVICE_ID_ANALOG_Y) base += 1; if (ol_state && ol_state->analog[base]) *ret = ol_state->analog[base]; } break; } }
/* * input_poll_overlay: * * Poll pressed buttons/keys on currently active overlay. **/ void input_poll_overlay(float opacity) { input_overlay_state_t old_key_state; unsigned i, j, device; uint16_t key_mod = 0; bool polled = false; settings_t *settings = config_get_ptr(); input_overlay_state_t *ol_state = &overlay_st_ptr; if (!input_overlay_is_alive() || !ol_state) return; memcpy(old_key_state.keys, ol_state->keys, sizeof(ol_state->keys)); memset(ol_state, 0, sizeof(*ol_state)); device = input_overlay_full_screen() ? RARCH_DEVICE_POINTER_SCREEN : RETRO_DEVICE_POINTER; for (i = 0; input_driver_state(NULL, 0, device, i, RETRO_DEVICE_ID_POINTER_PRESSED); i++) { input_overlay_state_t polled_data; int16_t x = input_driver_state(NULL, 0, device, i, RETRO_DEVICE_ID_POINTER_X); int16_t y = input_driver_state(NULL, 0, device, i, RETRO_DEVICE_ID_POINTER_Y); input_overlay_poll(&polled_data, x, y); ol_state->buttons |= polled_data.buttons; for (j = 0; j < ARRAY_SIZE(ol_state->keys); j++) ol_state->keys[j] |= polled_data.keys[j]; /* Fingers pressed later take prio and matched up * with overlay poll priorities. */ for (j = 0; j < 4; j++) if (polled_data.analog[j]) ol_state->analog[j] = polled_data.analog[j]; polled = true; } if (OVERLAY_GET_KEY(ol_state, RETROK_LSHIFT) || OVERLAY_GET_KEY(ol_state, RETROK_RSHIFT)) key_mod |= RETROKMOD_SHIFT; if (OVERLAY_GET_KEY(ol_state, RETROK_LCTRL) || OVERLAY_GET_KEY(ol_state, RETROK_RCTRL)) key_mod |= RETROKMOD_CTRL; if (OVERLAY_GET_KEY(ol_state, RETROK_LALT) || OVERLAY_GET_KEY(ol_state, RETROK_RALT)) key_mod |= RETROKMOD_ALT; if (OVERLAY_GET_KEY(ol_state, RETROK_LMETA) || OVERLAY_GET_KEY(ol_state, RETROK_RMETA)) key_mod |= RETROKMOD_META; /* CAPSLOCK SCROLLOCK NUMLOCK */ for (i = 0; i < ARRAY_SIZE(ol_state->keys); i++) { if (ol_state->keys[i] != old_key_state.keys[i]) { uint32_t orig_bits = old_key_state.keys[i]; uint32_t new_bits = ol_state->keys[i]; for (j = 0; j < 32; j++) if ((orig_bits & (1 << j)) != (new_bits & (1 << j))) input_keyboard_event(new_bits & (1 << j), i * 32 + j, 0, key_mod, RETRO_DEVICE_POINTER); } } /* Map "analog" buttons to analog axes like regular input drivers do. */ for (j = 0; j < 4; j++) { unsigned bind_plus = RARCH_ANALOG_LEFT_X_PLUS + 2 * j; unsigned bind_minus = bind_plus + 1; if (ol_state->analog[j]) continue; if (input_overlay_key_pressed(bind_plus)) ol_state->analog[j] += 0x7fff; if (input_overlay_key_pressed(bind_minus)) ol_state->analog[j] -= 0x7fff; } /* Check for analog_dpad_mode. * Map analogs to d-pad buttons when configured. */ switch (settings->input.analog_dpad_mode[0]) { case ANALOG_DPAD_LSTICK: case ANALOG_DPAD_RSTICK: { float analog_x, analog_y; unsigned analog_base = 2; if (settings->input.analog_dpad_mode[0] == ANALOG_DPAD_LSTICK) analog_base = 0; analog_x = (float)ol_state->analog[analog_base + 0] / 0x7fff; analog_y = (float)ol_state->analog[analog_base + 1] / 0x7fff; if (analog_x <= -settings->input.axis_threshold) ol_state->buttons |= (1UL << RETRO_DEVICE_ID_JOYPAD_LEFT); if (analog_x >= settings->input.axis_threshold) ol_state->buttons |= (1UL << RETRO_DEVICE_ID_JOYPAD_RIGHT); if (analog_y <= -settings->input.axis_threshold) ol_state->buttons |= (1UL << RETRO_DEVICE_ID_JOYPAD_UP); if (analog_y >= settings->input.axis_threshold) ol_state->buttons |= (1UL << RETRO_DEVICE_ID_JOYPAD_DOWN); break; } default: break; } if (polled) input_overlay_post_poll(opacity); else input_overlay_poll_clear(opacity); }
void input_mapper_poll(input_mapper_t *handle) { unsigned i, j; input_bits_t current_input; settings_t *settings = config_get_ptr(); unsigned max_users = *(input_driver_get_uint(INPUT_ACTION_MAX_USERS)); bool key_event[RARCH_CUSTOM_BIND_LIST_END] = { false }; #ifdef HAVE_OVERLAY bool poll_overlay = input_overlay_is_alive(overlay_ptr) ? true : false; #endif #ifdef HAVE_MENU if (menu_driver_is_alive()) return; #endif memset(handle->keys, 0, sizeof(handle->keys)); for (i = 0; i < max_users; i++) { unsigned device = settings->uints.input_libretro_device[i]; device &= RETRO_DEVICE_MASK; switch (device) { /* keyboard to gamepad remapping */ case RETRO_DEVICE_KEYBOARD: BIT256_CLEAR_ALL_PTR(¤t_input); input_get_state_for_port(settings, i, ¤t_input); for (j = 0; j < RARCH_CUSTOM_BIND_LIST_END; j++) { unsigned remap_button = settings->uints.input_keymapper_ids[i][j]; bool remap_valid = remap_button != RETROK_UNKNOWN; if (remap_valid) { unsigned current_button_value = BIT256_GET(current_input, j); if ((current_button_value == 1) && (j != remap_button)) { MAPPER_SET_KEY (handle, remap_button); input_keyboard_event(true, remap_button, 0, 0, RETRO_DEVICE_KEYBOARD); key_event[j] = true; } /* key_event tracks if a key is pressed for ANY PLAYER, so we must check if the key was used by any player before releasing */ else if (!key_event[j]) { input_keyboard_event(false, remap_button, 0, 0, RETRO_DEVICE_KEYBOARD); } } } break; /* gamepad remapping */ case RETRO_DEVICE_JOYPAD: case RETRO_DEVICE_ANALOG: /* this loop iterates on all users and all buttons, * and checks if a pressed button is assigned to any * other button than the default one, then it sets * the bit on the mapper input bitmap, later on the * original input is cleared in input_state */ BIT256_CLEAR_ALL(handle->buttons[i]); BIT256_CLEAR_ALL_PTR(¤t_input); for (j = 0; j < 8; j++) handle->analog_value[i][j] = 0; input_get_state_for_port(settings, i, ¤t_input); for (j = 0; j < RARCH_FIRST_CUSTOM_BIND; j++) { bool remap_valid; unsigned remap_button; unsigned current_button_value = BIT256_GET(current_input, j); #ifdef HAVE_OVERLAY if (poll_overlay && i == 0) current_button_value |= input_overlay_key_pressed(overlay_ptr, j); #endif remap_button = settings->uints.input_remap_ids[i][j]; remap_valid = (current_button_value == 1) && (j != remap_button) && (remap_button != RARCH_UNMAPPED); if (remap_valid) { if (remap_button < RARCH_FIRST_CUSTOM_BIND) { BIT256_SET(handle->buttons[i], remap_button); } else if (remap_button >= RARCH_FIRST_CUSTOM_BIND) { int invert = 1; if (remap_button % 2 != 0) invert = -1; handle->analog_value[i][ remap_button - RARCH_FIRST_CUSTOM_BIND] = 32767 * invert; } } } for (j = 0; j < 8; j++) { unsigned k = j + RARCH_FIRST_CUSTOM_BIND; int16_t current_axis_value = current_input.analogs[j]; unsigned remap_axis = settings->uints.input_remap_ids[i][k]; if ( (abs(current_axis_value) > *input_driver_get_float(INPUT_ACTION_AXIS_THRESHOLD) * 32767) && (k != remap_axis) && (remap_axis != RARCH_UNMAPPED) ) { if (remap_axis < RARCH_FIRST_CUSTOM_BIND) { BIT256_SET(handle->buttons[i], remap_axis); } else { int invert = 1; if ( (k % 2 == 0 && remap_axis % 2 != 0) || (k % 2 != 0 && remap_axis % 2 == 0) ) invert = -1; handle->analog_value[i][ remap_axis - RARCH_FIRST_CUSTOM_BIND] = current_axis_value * invert; #if 0 RARCH_LOG("axis %d(%d) remapped to axis %d val %d\n", j, k, remap_axis - RARCH_FIRST_CUSTOM_BIND, current_axis_value); #endif } } } break; default: break; } } }