static int16_t input_wl_analog_pressed(input_ctx_wayland_data_t *wl,
const struct retro_keybind *binds,
unsigned idx, unsigned id)
{
unsigned id_minus = 0;
unsigned id_plus = 0;
int16_t pressed_minus = 0;
int16_t pressed_plus = 0;
input_conv_analog_id_to_bind_id(idx, id, &id_minus, &id_plus);
if (binds
&& binds[id_minus].valid
&& (id_minus < RARCH_BIND_LIST_END)
&& BIT_GET(wl->key_state, rarch_keysym_lut[binds[id_minus].key])
)
pressed_minus = -0x7fff;
if (binds
&& binds[id_plus].valid
&& (id_plus < RARCH_BIND_LIST_END)
&& BIT_GET(wl->key_state, rarch_keysym_lut[binds[id_plus].key])
)
pressed_plus = 0x7fff;
return pressed_plus + pressed_minus;
}
static bool android_joypad_button(unsigned port, uint16_t joykey)
{
unsigned hat_dir = 0;
uint8_t *buf = android_keyboard_state_get(port);
struct android_app *android_app = (struct android_app*)g_android;
if (port >= MAX_PADS)
return false;
hat_dir = GET_HAT_DIR(joykey);
if (hat_dir)
{
unsigned h = GET_HAT(joykey);
if (h > 0)
return false;
switch (hat_dir)
{
case HAT_LEFT_MASK:
return android_app->hat_state[port][0] == -1;
case HAT_RIGHT_MASK:
return android_app->hat_state[port][0] == 1;
case HAT_UP_MASK:
return android_app->hat_state[port][1] == -1;
case HAT_DOWN_MASK:
return android_app->hat_state[port][1] == 1;
default:
return false;
}
}
return joykey < LAST_KEYCODE && BIT_GET(buf, joykey);
}
static void pointer_handle_button(void *data,
struct wl_pointer *wl_pointer,
uint32_t serial,
uint32_t time,
uint32_t button,
uint32_t state)
{
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)data;
if (state == WL_POINTER_BUTTON_STATE_PRESSED)
{
if (button == BTN_LEFT)
{
wl->input.mouse.left = true;
/* This behavior matches mpv, seems like a decent way to support window moving for now. */
if (BIT_GET(wl->input.key_state, KEY_LEFTALT) && wl->shell_surf)
wl_shell_surface_move(wl->shell_surf, wl->seat, serial);
}
else if (button == BTN_RIGHT)
wl->input.mouse.right = true;
else if (button == BTN_MIDDLE)
wl->input.mouse.middle = true;
}
else
{
if (button == BTN_LEFT)
wl->input.mouse.left = false;
else if (button == BTN_RIGHT)
wl->input.mouse.right = false;
else if (button == BTN_MIDDLE)
wl->input.mouse.middle = false;
}
}
static bool android_joypad_button(unsigned port, uint16_t joykey)
{
uint8_t *buf = NULL;
driver_t *driver = driver_get_ptr();
android_input_t *android = (android_input_t*)driver->input_data;
if (!android || port >= MAX_PADS)
return false;
buf = android->pad_state[port];
if (GET_HAT_DIR(joykey))
{
unsigned h = GET_HAT(joykey);
if (h > 0)
return false;
switch (GET_HAT_DIR(joykey))
{
case HAT_LEFT_MASK:
return android->hat_state[port][0] == -1;
case HAT_RIGHT_MASK:
return android->hat_state[port][0] == 1;
case HAT_UP_MASK:
return android->hat_state[port][1] == -1;
case HAT_DOWN_MASK:
return android->hat_state[port][1] == 1;
default:
return false;
}
}
return joykey < LAST_KEYCODE && BIT_GET(buf, joykey);
}
/* Get phone numbers from stdin, print them back to stdout */
int main(int argc, char **argv)
{
/* Enough storage for 10^7 phone numbers */
unsigned char buf[NUM_NUMBERS/8];
char in[MAX_PHONE_INPUT_LENGTH];
int i=0;
memset(buf, 0x00, sizeof(buf));
memset(in, 0x00, sizeof(in));
/* Test my bit macros
for(i=0; i<NUM_NUMBERS; i++) {
assert(BIT_GET(buf, i) == 0);
BIT_SET(buf, i);
assert(BIT_GET(buf, i) == 1);
}
*/
/* Read all of the phone numbers from stdin and put them in order */
while(fgets(in, sizeof(in), stdin) != NULL) {
assert(strlen(in) > 0);
assert(strlen(in) < sizeof(in));
assert(sizeof(buf) > (i/8));
BIT_SET(buf, parseNumber(in));
}
/* Print them back out */
for(i=0; i<NUM_NUMBERS; i++) {
if(BIT_GET(buf, i)) {
printf("%07d\n", i);
}
}
return(0);
}
static bool input_wl_state_kb(input_ctx_wayland_data_t *wl,
const struct retro_keybind **binds,
unsigned port, unsigned device, unsigned idx, unsigned id)
{
unsigned bit = rarch_keysym_lut[(enum retro_key)id];
return id < RETROK_LAST && BIT_GET(wl->key_state, bit);
}
static int16_t udev_input_state(void *data, const struct retro_keybind **binds,
unsigned port, unsigned device, unsigned idx, unsigned id)
{
int16_t ret;
udev_input_t *udev = (udev_input_t*)data;
switch (device)
{
case RETRO_DEVICE_JOYPAD:
return udev_input_is_pressed(udev, binds[port], id) ||
input_joypad_pressed(udev->joypad, port, binds[port], id);
case RETRO_DEVICE_ANALOG:
ret = udev_analog_pressed(udev, binds[port], idx, id);
if (!ret)
ret = input_joypad_analog(udev->joypad, port, idx, id, binds[port]);
return ret;
case RETRO_DEVICE_KEYBOARD:
{
unsigned bit = input_keymaps_translate_rk_to_keysym((enum retro_key)id);
return id < RETROK_LAST && BIT_GET(udev->key_state, bit);
}
case RETRO_DEVICE_MOUSE:
return udev_mouse_state(udev, id);
case RETRO_DEVICE_LIGHTGUN:
return udev_lightgun_state(udev, id);
}
return 0;
}
/*!
* @brief 读取引脚输入状态
* @param PTxn 端口
* @return 管脚的状态，1为高电平，0为低电平
* @since v5.0
* @warning 务必保证数据方向为输入（DEBUG模式下，有断言进行检测）
* Sample usage: uint8 pta8_data = gpio_get (PTA8); // 获取 PT8A 管脚 输入电平
*/
uint8 gpio_get(PTXn_e ptxn)
{
ASSERT( BIT_GET( GPIO_PDDR_REG(GPIOX_BASE(ptxn)) , PTn(ptxn)) == GPI ); // 断言，检测 输出方向是否为输入
// 获取 GPIO PDDR 管脚号 ，比较是否为输入
return ((GPIO_PDIR_REG(GPIOX_BASE(ptxn)) >> PTn(ptxn )) & 0x01); // 获取 GPIO PDIR ptxn 状态，即读取管脚输入电平
}
bool digital_get(index_t i)
{
switch (i) {
/* Digitals 1...4, bits 0,1,2,3 in port A */
case IX_DIGITAL(1):
case IX_DIGITAL(2):
case IX_DIGITAL(3):
case IX_DIGITAL(4):
return BIT_GET(PORTA, i - IX_DIGITAL(1) + 0);
/* Digital 5, bit 4 in port A */
case IX_DIGITAL(5):
return BIT_GET(PORTA, 4);
/* Digitals 6...12, bits 0,1... in port F */
case IX_DIGITAL(6):
case IX_DIGITAL(7):
case IX_DIGITAL(8):
case IX_DIGITAL(9):
case IX_DIGITAL(10):
case IX_DIGITAL(11):
case IX_DIGITAL(12):
return BIT_GET(PORTF, i - IX_DIGITAL(6) + 0);
/* Digitals 13...16, bits 4,5,6,7 in port H. */
case IX_DIGITAL(13):
case IX_DIGITAL(14):
case IX_DIGITAL(15):
case IX_DIGITAL(16):
return BIT_GET(PORTH, i - IX_DIGITAL(13) + 4);
/* Interrupts (all), bits 2,3,4,5,6,7 in port B */
case IX_INTERRUPT(1):
case IX_INTERRUPT(2):
case IX_INTERRUPT(3):
case IX_INTERRUPT(4):
case IX_INTERRUPT(5):
case IX_INTERRUPT(6):
return BIT_GET(PORTB, i - IX_INTERRUPT(1) + 2);
/* TODO: OI digitals. */
default:
WARN();
return false;
}
}
/*!
* @brief 反转引脚状态
* @param PTxn 端口
* @since v5.0
* @warning 务必保证数据方向为输出（DEBUG模式下，有断言进行检测）
* Sample usage: gpio_turn (PTA8); // PTA8 管脚 输出 反转
*/
void gpio_turn (PTXn_e ptxn)
{
ASSERT( BIT_GET( GPIO_PDDR_REG(GPIOX_BASE(ptxn)) , PTn(ptxn)) == GPO ); // 断言，检测 输出方向是否为输出
// 获取 GPIO PDDR 管脚号 ，比较是否为输出
GPIO_PTOR_REG( GPIOX_BASE(ptxn)) = 1 << (PTn(ptxn )); // GPIO PTOR ptxn 置1，其他清0 ，即对应管脚配置为端口输出反转，其他位不变
// 此处不能用 BIT_SET 这个宏来置1 ，因为必须保证其他位 不变，其他位直接清0即可
}
static int16_t udev_analog_pressed(const struct retro_keybind *binds, unsigned idx, unsigned id)
{
unsigned id_minus = 0;
unsigned id_plus = 0;
int16_t pressed_minus = 0;
int16_t pressed_plus = 0;
input_conv_analog_id_to_bind_id(idx, id, &id_minus, &id_plus);
if (binds && binds[id_minus].valid &&
BIT_GET(udev_key_state, input_keymaps_translate_rk_to_keysym(binds[id_minus].key)))
pressed_minus = -0x7fff;
if (binds && binds[id_plus].valid &&
BIT_GET(udev_key_state, input_keymaps_translate_rk_to_keysym(binds[id_plus].key)))
pressed_plus = 0x7fff;
return pressed_plus + pressed_minus;
}
static bool udev_input_is_pressed(udev_input_t *udev, const struct retro_keybind *binds, unsigned id)
{
if (id < RARCH_BIND_LIST_END)
{
const struct retro_keybind *bind = &binds[id];
unsigned bit = input_keymaps_translate_rk_to_keysym(binds[id].key);
return bind->valid && BIT_GET(udev->key_state, bit);
}
return false;
}
static int16_t udev_input_state(void *data,
rarch_joypad_info_t joypad_info,
const struct retro_keybind **binds,
unsigned port, unsigned device, unsigned idx, unsigned id)
{
int16_t ret;
unsigned bit;
udev_input_t *udev = (udev_input_t*)data;
if (!udev)
return 0;
switch (device)
{
case RETRO_DEVICE_JOYPAD:
bit = input_keymaps_translate_rk_to_keysym(binds[port][id].key);
if (BIT_GET(udev_key_state, bit))
return true;
return input_joypad_pressed(udev->joypad, joypad_info, port, binds[port], id);
case RETRO_DEVICE_ANALOG:
ret = udev_analog_pressed(binds[port], idx, id);
if (!ret && binds[port])
ret = input_joypad_analog(udev->joypad, joypad_info, port, idx, id, binds[port]);
return ret;
case RETRO_DEVICE_KEYBOARD:
bit = input_keymaps_translate_rk_to_keysym((enum retro_key)id);
return id < RETROK_LAST && BIT_GET(udev_key_state, bit);
case RETRO_DEVICE_MOUSE:
return udev_mouse_state(udev, id);
case RETRO_DEVICE_POINTER:
case RARCH_DEVICE_POINTER_SCREEN:
if (idx == 0)
return udev_pointer_state(udev, idx, id,
device == RARCH_DEVICE_POINTER_SCREEN);
break;
case RETRO_DEVICE_LIGHTGUN:
return udev_lightgun_state(udev, id);
}
return 0;
}
bool android_keyboard_port_input_pressed(const struct retro_keybind *binds, unsigned id)
{
if (id < RARCH_BIND_LIST_END)
{
const struct retro_keybind *bind = &binds[id];
unsigned bit = input_keymaps_translate_rk_to_keysym(binds[id].key);
return bind->valid && BIT_GET(android_key_state[ANDROID_KEYBOARD_PORT], bit);
}
return false;
}
int main ()
{
DDRB = 0x03;
PORTB = 0x02;
while (1) {
if (BIT_GET(PINB, BIT(7))) {
BIT_SET(PORTB, BIT(0));
}
BIT_CLEAR(PORTB, BIT(0));
}
return 1;
}
/*!
* @brief 设置引脚状态
* @param PTxn 端口
* @param data 输出初始状态,0=低电平,1=高电平 （对输入无效）
* @since v5.0
* @warning 务必保证数据方向为输出（DEBUG模式下，有断言进行检测）
* Sample usage: gpio_set (PTA8, 1); // PTA8 管脚 输出 1
*/
void gpio_set (PTXn_e ptxn, uint8 data)
{
ASSERT( BIT_GET( GPIO_PDDR_REG(GPIOX_BASE(ptxn)) , PTn(ptxn)) == GPO ); // 断言，检测 输出方向是否为输出
// 获取 GPIO PDDR 管脚号 ，比较是否为输出
//端口输出数据
if(data == 0)
{
GPIO_PDOR_REG(GPIOX_BASE(ptxn)) &= ~(1 << PTn(ptxn)); // GPIO PDOR 管脚号 清0，即对应管脚配置为端口输出低电平
}
else
{
GPIO_PDOR_REG(GPIOX_BASE(ptxn)) |= (1 << PTn(ptxn)); // GPIO PDOR 管脚号 置1，即对应管脚配置为端口输出高电平
}
}
void bitfile_put_bits(struct bitfile *bf, u8 *bits, size_t count)
{
u8 bit_pos = 0;
assert(bf->mode == 'w');
while (count >= 8) {
bitfile_put_byte(bf, *bits++);
count -= 8;
}
while (count > 0) {
bitfile_put_bit(bf, BIT_GET(*bits, bit_pos));
bit_pos++;
count--;
}
}
static int16_t input_wl_state(void *data,
rarch_joypad_info_t joypad_info,
const struct retro_keybind **binds,
unsigned port, unsigned device, unsigned idx, unsigned id)
{
int16_t ret = 0;
input_ctx_wayland_data_t *wl = (input_ctx_wayland_data_t*)data;
switch (device)
{
case RETRO_DEVICE_JOYPAD:
if (id < RARCH_BIND_LIST_END)
ret = BIT_GET(wl->key_state, rarch_keysym_lut[binds[port][id].key]);
if (!ret && binds[port])
ret = input_joypad_pressed(wl->joypad, joypad_info, port, binds[port], id);
return ret;
case RETRO_DEVICE_ANALOG:
ret = input_wl_analog_pressed(wl, binds[port], idx, id);
if (!ret && binds[port])
ret = input_joypad_analog(wl->joypad, joypad_info, port, idx, id, binds[port]);
return ret;
case RETRO_DEVICE_KEYBOARD:
return input_wl_state_kb(wl, binds, port, device, idx, id);
case RETRO_DEVICE_MOUSE:
return input_wl_mouse_state(wl, id, false);
case RARCH_DEVICE_MOUSE_SCREEN:
return input_wl_mouse_state(wl, id, true);
case RETRO_DEVICE_POINTER:
if (idx == 0)
return input_wl_pointer_state(wl, idx, id,
device == RARCH_DEVICE_POINTER_SCREEN);
break;
case RARCH_DEVICE_POINTER_SCREEN:
if (idx < MAX_TOUCHES)
return input_wl_touch_state(wl, idx, id,
device == RARCH_DEVICE_POINTER_SCREEN);
break;
case RETRO_DEVICE_LIGHTGUN:
return input_wl_lightgun_state(wl, id);
}
return 0;
}
int skabloom_probably_contains(skabloom_t *s, void *data, size_t nbytes){
while (s != NULL){
uint64_t hashes[s->num_hashes];
int ret = generate_n_hashes(s->num_hashes, s->size, data, nbytes, hashes);
if (ret < 0)
return ret;
bool in_this_filter = true;
for (int i = 0; i < s->num_hashes; i++){
if (!BIT_GET(s->bitmap, hashes[i])){
in_this_filter = false;
break;
}
}
if (in_this_filter)
return 1;
s = s->next;
}
return 0;
}
mon_phys_mem_type_t mtrrs_abstraction_get_memory_type(hpa_t address)
{
uint32_t index;
uint32_t var_mtrr_match_bitmap;
mon_phys_mem_type_t type = MON_PHYS_MEM_UNDEFINED;
uint64_t remsize_back = 0, range_base = 0;
mon_phys_mem_type_t type_back = MON_PHYS_MEM_UNDEFINED;
remsize = 0;
MON_ASSERT(mtrrs_cached_info.is_initialized);
if (!mtrrs_abstraction_are_mtrrs_enabled()) {
return MON_PHYS_MEM_UNCACHABLE;
}
if (mtrrs_abstraction_are_fixed_regs_supported() &&
mtrrs_abstraction_are_fixed_ranged_mtrrs_enabled() &&
(address <=
mtrrs_cached_info.ia32_mtrr_fix_range
[MTRRS_ABS_NUM_OF_FIXED_RANGE_MTRRS - 1].end_addr)) {
/* Find proper fixed range MTRR */
for (index = 0; index < MTRRS_ABS_NUM_OF_FIXED_RANGE_MTRRS;
index++) {
if (address <=
mtrrs_cached_info.ia32_mtrr_fix_range[index].
end_addr) {
/* Find proper sub-range */
uint64_t offset =
address -
mtrrs_cached_info.ia32_mtrr_fix_range[
index].start_addr;
uint32_t size =
mtrrs_cached_info.ia32_mtrr_fix_range[
index].end_addr + 1 -
mtrrs_cached_info.ia32_mtrr_fix_range[
index].start_addr;
uint32_t sub_range_size = size /
MTRRS_ABS_NUM_OF_SUB_RANGES;
uint64_t sub_range_index = offset /
sub_range_size;
remsize =
(sub_range_index +
1) * sub_range_size - offset;
MON_ASSERT(
(size % MTRRS_ABS_NUM_OF_SUB_RANGES) == 0);
MON_ASSERT(
sub_range_index < MTRRS_ABS_NUM_OF_SUB_RANGES);
return (mon_phys_mem_type_t)mtrrs_cached_info.
ia32_mtrr_fix[index].type[sub_range_index];
}
}
/* mustn't reach here */
MON_ASSERT(0);
}
var_mtrr_match_bitmap = 0;
for (index = 0;
index < mtrrs_abstraction_get_num_of_variable_range_regs();
index++) {
if (index >= MTRRS_ABS_NUM_OF_VAR_RANGE_MTRRS) {
break;
}
if (!mtrrs_abstraction_is_var_reg_valid(index)) {
continue;
}
if (mtrrs_abstraction_is_addr_covered_by_var_reg(address,
index)) {
type = (mon_phys_mem_type_t)
mtrrs_cached_info.ia32_mtrr_var_phys_base[index].
bits.type;
BIT_SET(var_mtrr_match_bitmap, type);
if (remsize_back > 0) {
if (type == MON_PHYS_MEM_UNCACHABLE
|| type_back == MON_PHYS_MEM_UNCACHABLE) {
if (type_back !=
MON_PHYS_MEM_UNCACHABLE) {
remsize_back = remsize;
}
if (type != MON_PHYS_MEM_UNCACHABLE) {
remsize = 0;
}
if (type == MON_PHYS_MEM_UNCACHABLE
&& type_back ==
MON_PHYS_MEM_UNCACHABLE) {
remsize_back =
(remsize_back >
remsize) ? remsize_back
:
remsize;
}
type_back = MON_PHYS_MEM_UNCACHABLE;
remsize = 0;
} else {
remsize_back =
(remsize_back >
remsize) ? remsize :
remsize_back;
type_back = type;
remsize = 0;
}
} else {
remsize_back = remsize;
remsize = 0;
type_back = type;
}
} else {
range_base = mtrrs_abstraction_get_address_from_reg(
index);
if (address < range_base && address + remsize_back >
range_base) {
remsize_back = range_base - address;
}
}
}
remsize = remsize_back;
if (0 == var_mtrr_match_bitmap) {
/* not described by any MTRR, return default memory type */
return mtrrs_abstraction_get_default_memory_type();
} else if (IS_POW_OF_2(var_mtrr_match_bitmap)) {
/* described by single MTRR, type contains the proper value */
return type;
} else if (BIT_GET(var_mtrr_match_bitmap, MON_PHYS_MEM_UNCACHABLE)) {
/* fall in multiple ranges, UC wins */
return MON_PHYS_MEM_UNCACHABLE;
} else
if ((BIT_VALUE64(MON_PHYS_MEM_WRITE_THROUGH) |
BIT_VALUE64(MON_PHYS_MEM_WRITE_BACK))
== var_mtrr_match_bitmap) {
/* fall in WT + WB, WT wins. */
return MON_PHYS_MEM_WRITE_THROUGH;
}
/* improper MTRR setting */
MON_LOG(mask_anonymous, level_error,
"FATAL: MTRRs Abstraction: Overlapping variable MTRRs"
" have confilting types\n");
MON_DEADLOOP();
return MON_PHYS_MEM_UNDEFINED;
}
void gamepadButtonHandler(enum ButtonName name, enum ButtonState state) {
//Move to ButtonChange()
if (state == BUTTON_PRESSED) {
// Set the corresponding bit:
pressed_buttons |= 1ul<<name;
}
if (state == BUTTON_RELEASED) {
// Clear the corresponding bit:
pressed_buttons &= ~(1ul<<name);
}
if(name==REPORT)
{
BIT_SET(gamepad_buttonsLOW, Button_A, BIT_GET(pressed_buttons, BIT(B_A)));
BIT_SET(gamepad_buttonsLOW, Button_B, BIT_GET(pressed_buttons, BIT(B_B)));
BIT_SET(gamepad_buttonsLOW, Button_X, BIT_GET(pressed_buttons, BIT(B_X)));
BIT_SET(gamepad_buttonsLOW, Button_Y, BIT_GET(pressed_buttons, BIT(B_Y)));
BIT_SET(gamepad_buttonsLOW, Button_LBumper, BIT_GET(pressed_buttons, BIT(B_LB)));
BIT_SET(gamepad_buttonsLOW, Button_RBumper, BIT_GET(pressed_buttons, BIT(B_RB)));
BIT_SET(gamepad_buttonsHIGH, Button_LTrigger, BIT_GET(pressed_buttons, BIT(B_LT)));
BIT_SET(gamepad_buttonsHIGH, Button_RTrigger, BIT_GET(pressed_buttons, BIT(B_RT)));
BIT_SET(gamepad_buttonsHIGH, Button_Select, BIT_GET(pressed_buttons, BIT(B_SELECT)));
BIT_SET(gamepad_buttonsHIGH, Button_Start, BIT_GET(pressed_buttons, BIT(B_START)));
BIT_SET(gamepad_buttonsHIGH, Button_LThumb, BIT_GET(pressed_buttons, BIT(B_JL)));
BIT_SET(gamepad_buttonsHIGH, Button_RThumb, BIT_GET(pressed_buttons, BIT(B_JR)));
dpad_buttons = DPadNoAction;
//Dpad diagonal directions
if (BIT_GET(pressed_buttons, BIT(B_UP)) && BIT_GET(pressed_buttons, BIT(B_LEFT)))
{
dpad_buttons = DPadUpLeft;
}
else if (BIT_GET(pressed_buttons, BIT(B_UP)) && BIT_GET(pressed_buttons, BIT(B_RIGHT)))
{
dpad_buttons = DPadUPRight;
}
else if (BIT_GET(pressed_buttons, BIT(B_DOWN)) && BIT_GET(pressed_buttons, BIT(B_LEFT)))
{
dpad_buttons = DPadDownLeft;
}
else if (BIT_GET(pressed_buttons, BIT(B_DOWN)) && BIT_GET(pressed_buttons, BIT(B_RIGHT)))
{
dpad_buttons = DPadDownRight;
}
//Dpad up,left,down,right directions
else if (BIT_GET(pressed_buttons, BIT(B_UP)))
{
dpad_buttons = DPadUP;
}
else if (BIT_GET(pressed_buttons, BIT(B_LEFT)))
{
dpad_buttons = DPadLeft;
}
else if (BIT_GET(pressed_buttons, BIT(B_DOWN)))
{
dpad_buttons = DPadDown;
}
else if (BIT_GET(pressed_buttons, BIT(B_RIGHT)))
{
dpad_buttons = DPadRight;
}
report.dpad = dpad_buttons;
report.buttons1 = gamepad_buttonsLOW;
report.buttons2 = gamepad_buttonsHIGH;
if( GamepadButtonChanged() )
{
delta = true;
}
}
}
bool qnx_keyboard_pressed(qnx_input_t *qnx, unsigned id)
{
unsigned bit = input_keymaps_translate_rk_to_keysym((enum retro_key)id);
return id < RETROK_LAST && BIT_GET(qnx->keyboard_state, bit);
}
bool android_keyboard_input_pressed(unsigned key)
{
return BIT_GET(android_key_state[0], key);
}
bool udev_input_state_kb(void *data, const struct retro_keybind **binds,
unsigned port, unsigned device, unsigned idx, unsigned id)
{
unsigned bit = input_keymaps_translate_rk_to_keysym((enum retro_key)id);
return id < RETROK_LAST && BIT_GET(udev_key_state, bit);
}
