mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-01-31 15:32:59 +00:00
Code Issues Packages Projects Releases Wiki Activity
RetroArch/input/drivers/switch_input.c

930 lines
27 KiB
C
Raw Blame History

#include <stdint.h>
#include <stdlib.h>
#include <boolean.h>
#include <libretro.h>
#include <retro_miscellaneous.h>
#ifdef HAVE_CONFIG_H
#include "../../config.h"
#endif
#include "../../retroarch.h"
#ifdef HAVE_LIBNX
#include <switch.h>
#define MULTITOUCH_LIMIT 4 /* supports up to this many fingers at once */
#define TOUCH_AXIS_MAX 0x7fff /* abstraction of pointer coords */
#define SWITCH_NUM_SCANCODES 114 /* size of rarch_key_map_switch */
#define SWITCH_MAX_SCANCODE 0xfb /* see https://switchbrew.github.io/libnx/hid_8h.html */
#define MOUSE_MAX_X 1920
#define MOUSE_MAX_Y 1080
/* beginning of touch mouse defines and types */
#define TOUCH_MAX_X 1280
#define TOUCH_MAX_Y 720
#define TOUCH_MOUSE_BUTTON_LEFT 0
#define TOUCH_MOUSE_BUTTON_RIGHT 1
#define NO_TOUCH -1 /* finger id setting if finger is not touching the screen */
enum
{
MAX_NUM_FINGERS = 3, /* number of fingers to track per panel for touch mouse */
MAX_TAP_TIME = 250, /* taps longer than this will not result in mouse click events */
MAX_TAP_MOTION_DISTANCE = 10, /* max distance finger motion in Vita screen pixels to be considered a tap */
SIMULATED_CLICK_DURATION = 50, /* time in ms how long simulated mouse clicks should be */
}; /* track three fingers per panel */
typedef struct
{
int id; /* -1: no touch */
int time_last_down;
float last_down_x;
float last_down_y;
} Touch;
typedef enum DraggingType
{
DRAG_NONE = 0,
DRAG_TWO_FINGER,
DRAG_THREE_FINGER,
} DraggingType;
typedef enum TouchEventType
{
FINGERDOWN,
FINGERUP,
FINGERMOTION,
} TouchEventType;
typedef struct
{
TouchEventType type;
uint64_t timestamp;
int touchId;
int fingerId;
float x;
float y;
float dx;
float dy;
} FingerType;
typedef struct
{
TouchEventType type;
FingerType tfinger;
} TouchEvent;
/* end of touch mouse defines and types */
#endif
#include "../input_driver.h"
#include "../input_keymaps.h"
#define MAX_PADS 10
/* TODO/FIXME -
* fix game focus toggle */
typedef struct switch_input
{
const input_device_driver_t *joypad;
bool blocked;
#ifdef HAVE_LIBNX
/* pointer */
bool touch_state[MULTITOUCH_LIMIT];
bool previous_touch_state[MULTITOUCH_LIMIT];
int16_t touch_x_viewport[MULTITOUCH_LIMIT]; /* used for POINTER device */
int16_t touch_y_viewport[MULTITOUCH_LIMIT]; /* used for POINTER device */
int16_t touch_x_screen[MULTITOUCH_LIMIT]; /* used for POINTER_SCREEN device */
int16_t touch_y_screen[MULTITOUCH_LIMIT]; /* used for POINTER_SCREEN device */
uint32_t touch_x[MULTITOUCH_LIMIT]; /* used for touch mouse */
uint32_t touch_y[MULTITOUCH_LIMIT]; /* used for touch mouse */
uint32_t touch_previous_x[MULTITOUCH_LIMIT];
uint32_t touch_previous_y[MULTITOUCH_LIMIT];
bool keyboard_state[SWITCH_MAX_SCANCODE + 1];
/* physical mouse */
int32_t mouse_x;
int32_t mouse_y;
int32_t mouse_x_delta;
int32_t mouse_y_delta;
int32_t mouse_wheel;
bool mouse_button_left;
bool mouse_button_right;
bool mouse_button_middle;
uint64_t mouse_previous_report;
/* touch mouse */
bool touch_mouse_indirect;
float touch_mouse_speed_factor;
int hires_dx; /* sub-pixel touch mouse precision */
int hires_dy; /* sub-pixel touch mouse precision */
Touch finger[MAX_NUM_FINGERS]; /* keep track of finger status for touch mouse */
DraggingType multi_finger_dragging; /* keep track whether we are currently drag-and-dropping */
int32_t simulated_click_start_time[2]; /* initiation time of last simulated left or right click (zero if no click) */
#endif
} switch_input_t;
#ifdef HAVE_LIBNX
/* beginning of touch mouse function declarations */
static void handle_touch_mouse(switch_input_t *sw);
static void normalize_touch_mouse_xy(float *normalized_x, float *normalized_y, int reported_x, int reported_y);
static void process_touch_mouse_event(switch_input_t *sw, TouchEvent *event);
static void process_touch_mouse_finger_down(switch_input_t * sw, TouchEvent *event);
static void process_touch_mouse_finger_up(switch_input_t *sw, TouchEvent *event);
static void process_touch_mouse_finger_motion(switch_input_t *sw, TouchEvent *event);
static void normalized_to_screen_xy(int *screenX, int *screenY, float x, float y);
static void finish_simulated_mouse_clicks(switch_input_t *sw, uint64_t currentTime);
/* end of touch mouse function declarations */
#endif
static void switch_input_poll(void *data)
{
switch_input_t *sw = (switch_input_t*) data;
#ifdef HAVE_LIBNX
uint32_t touch_count;
unsigned int i = 0;
int keySym = 0;
unsigned keyCode = 0;
uint16_t mod = 0;
MousePosition mouse_pos;
uint64_t mouse_current_report = 0;
#endif
if (sw->joypad)
sw->joypad->poll();
#ifdef HAVE_LIBNX
touch_count = hidTouchCount();
for (i = 0; i < MULTITOUCH_LIMIT; i++)
{
sw->previous_touch_state[i] = sw->touch_state[i];
sw->touch_state[i] = touch_count > i;
if (sw->touch_state[i])
{
struct video_viewport vp;
touchPosition touch_position;
hidTouchRead(&touch_position, i);
sw->touch_previous_x[i] = sw->touch_x[i];
sw->touch_previous_y[i] = sw->touch_y[i];
sw->touch_x[i] = touch_position.px;
sw->touch_y[i] = touch_position.py;
/* convert from event coordinates to core and screen coordinates */
vp.x = 0;
vp.y = 0;
vp.width = 0;
vp.height = 0;
vp.full_width = 0;
vp.full_height = 0;
video_driver_translate_coord_viewport_wrap(
&vp,
touch_position.px,
touch_position.py,
&sw->touch_x_viewport[i],
&sw->touch_y_viewport[i],
&sw->touch_x_screen[i],
&sw->touch_y_screen[i]);
}
}
mod = 0;
if (hidKeyboardHeld(KBD_LEFTALT) || hidKeyboardHeld(KBD_RIGHTALT))
mod |= RETROKMOD_ALT;
if (hidKeyboardHeld(KBD_LEFTCTRL) || hidKeyboardHeld(KBD_RIGHTCTRL))
mod |= RETROKMOD_CTRL;
if (hidKeyboardHeld(KBD_LEFTSHIFT) || hidKeyboardHeld(KBD_RIGHTSHIFT))
mod |= RETROKMOD_SHIFT;
for (i = 0; i < SWITCH_NUM_SCANCODES; i++)
{
keySym = rarch_key_map_switch[i].sym;
keyCode = input_keymaps_translate_keysym_to_rk(keySym);
if (hidKeyboardHeld(keySym) && !(sw->keyboard_state[keySym]))
{
sw->keyboard_state[keySym] = true;
input_keyboard_event(true, keyCode, 0, mod, RETRO_DEVICE_KEYBOARD);
}
else if (!hidKeyboardHeld(keySym) && sw->keyboard_state[keySym])
{
sw->keyboard_state[keySym] = false;
input_keyboard_event(false, keyCode, 0, mod, RETRO_DEVICE_KEYBOARD);
}
}
/* update physical mouse buttons only when they change
* this allows the physical mouse and touch mouse to coexist */
mouse_current_report = hidMouseButtonsHeld();
if ((mouse_current_report & MOUSE_LEFT) != (sw->mouse_previous_report & MOUSE_LEFT))
{
if (mouse_current_report & MOUSE_LEFT)
sw->mouse_button_left = true;
else
sw->mouse_button_left = false;
}
if ((mouse_current_report & MOUSE_RIGHT) != (sw->mouse_previous_report & MOUSE_RIGHT))
{
if (mouse_current_report & MOUSE_RIGHT)
sw->mouse_button_right = true;
else
sw->mouse_button_right = false;
}
if ((mouse_current_report & MOUSE_MIDDLE) != (sw->mouse_previous_report & MOUSE_MIDDLE))
{
if (mouse_current_report & MOUSE_MIDDLE)
sw->mouse_button_middle = true;
else
sw->mouse_button_middle = false;
}
sw->mouse_previous_report = mouse_current_report;
/* physical mouse position */
hidMouseRead(&mouse_pos);
sw->mouse_x_delta = mouse_pos.velocityX;
sw->mouse_y_delta = mouse_pos.velocityY;
sw->mouse_x += sw->mouse_x_delta;
sw->mouse_y += sw->mouse_y_delta;
/* touch mouse events
* handle_touch_mouse will update sw->mouse_* variables
* depending on touch input gestures
* see first comment in process_touch_mouse_event() for a list of
* supported touch gestures */
handle_touch_mouse(sw);
if (sw->mouse_x < 0)
sw->mouse_x = 0;
else if (sw->mouse_x > MOUSE_MAX_X)
sw->mouse_x = MOUSE_MAX_X;
if (sw->mouse_y < 0)
sw->mouse_y = 0;
else if (sw->mouse_y > MOUSE_MAX_Y)
sw->mouse_y = MOUSE_MAX_Y;
sw->mouse_wheel = mouse_pos.scrollVelocityY;
#endif
}
#ifdef HAVE_LIBNX
static int16_t switch_pointer_screen_device_state(switch_input_t *sw,
unsigned id, unsigned idx)
{
if (idx >= MULTITOUCH_LIMIT)
return 0;
switch (id)
{
case RETRO_DEVICE_ID_POINTER_PRESSED:
return sw->touch_state[idx];
case RETRO_DEVICE_ID_POINTER_X:
return sw->touch_x_screen[idx];
case RETRO_DEVICE_ID_POINTER_Y:
return sw->touch_y_screen[idx];
}
return 0;
}
static int16_t switch_pointer_device_state(switch_input_t *sw,
unsigned id, unsigned idx)
{
if (idx >= MULTITOUCH_LIMIT)
return 0;
switch (id)
{
case RETRO_DEVICE_ID_POINTER_PRESSED:
return sw->touch_state[idx];
case RETRO_DEVICE_ID_POINTER_X:
return sw->touch_x_viewport[idx];
case RETRO_DEVICE_ID_POINTER_Y:
return sw->touch_y_viewport[idx];
}
return 0;
}
static int16_t switch_input_mouse_state(switch_input_t *sw, unsigned id, bool screen)
{
int val = 0;
switch (id)
{
case RETRO_DEVICE_ID_MOUSE_LEFT:
val = sw->mouse_button_left;
break;
case RETRO_DEVICE_ID_MOUSE_RIGHT:
val = sw->mouse_button_right;
break;
case RETRO_DEVICE_ID_MOUSE_MIDDLE:
val = sw->mouse_button_middle;
break;
case RETRO_DEVICE_ID_MOUSE_X:
if (screen)
val = sw->mouse_x;
else
{
val = sw->mouse_x_delta;
sw->mouse_x_delta = 0; /* flush delta after it has been read */
}
break;
case RETRO_DEVICE_ID_MOUSE_Y:
if (screen)
val = sw->mouse_y;
else
{
val = sw->mouse_y_delta;
sw->mouse_y_delta = 0; /* flush delta after it has been read */
}
break;
case RETRO_DEVICE_ID_MOUSE_WHEELUP:
if (sw->mouse_wheel > 0)
{
val = sw->mouse_wheel;
sw->mouse_wheel = 0;
}
break;
case RETRO_DEVICE_ID_MOUSE_WHEELDOWN:
if (sw->mouse_wheel < 0)
{
val = sw->mouse_wheel;
sw->mouse_wheel = 0;
}
break;
}
return val;
}
#endif
static int16_t switch_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 = 0;
switch_input_t *sw = (switch_input_t*) data;
if (port > MAX_PADS-1)
return 0;
switch (device)
{
case RETRO_DEVICE_JOYPAD:
if (id == RETRO_DEVICE_ID_JOYPAD_MASK)
{
unsigned i;
for (i = 0; i < RARCH_FIRST_CUSTOM_BIND; i++)
{
/* Auto-binds are per joypad, not per user. */
const uint16_t joykey = (binds[port][i].joykey != NO_BTN)
? binds[port][i].joykey : joypad_info.auto_binds[i].joykey;
const uint32_t joyaxis = (binds[port][i].joyaxis != AXIS_NONE)
? binds[port][i].joyaxis : joypad_info.auto_binds[i].joyaxis;
if (joykey != NO_BTN && sw->joypad->button(joypad_info.joy_idx, joykey))
ret |= (1 << i);
else if (((float)abs(sw->joypad->axis(joypad_info.joy_idx, joyaxis)) / 0x8000) > joypad_info.axis_threshold)
ret |= (1 << 1);
}
}
else
{
/* Auto-binds are per joypad, not per user. */
const uint16_t joykey = (binds[port][id].joykey != NO_BTN)
? binds[port][id].joykey : joypad_info.auto_binds[id].joykey;
const uint32_t joyaxis = (binds[port][id].joyaxis != AXIS_NONE)
? binds[port][id].joyaxis : joypad_info.auto_binds[id].joyaxis;
if (joykey != NO_BTN && sw->joypad->button(joypad_info.joy_idx, joykey))
ret = 1;
else if (((float)abs(sw->joypad->axis(joypad_info.joy_idx, joyaxis)) / 0x8000) > joypad_info.axis_threshold)
ret = 1;
}
return ret;
case RETRO_DEVICE_ANALOG:
if (binds[port])
return input_joypad_analog(sw->joypad,
joypad_info, port, idx, id, binds[port]);
break;
#ifdef HAVE_LIBNX
case RETRO_DEVICE_KEYBOARD:
return ((id < RETROK_LAST) && sw->keyboard_state[rarch_keysym_lut[(enum retro_key)id]]);
break;
case RETRO_DEVICE_MOUSE:
return switch_input_mouse_state(sw, id, false);
break;
case RARCH_DEVICE_MOUSE_SCREEN:
return switch_input_mouse_state(sw, id, true);
break;
case RETRO_DEVICE_POINTER:
return switch_pointer_device_state(sw, id, idx);
break;
case RARCH_DEVICE_POINTER_SCREEN:
return switch_pointer_screen_device_state(sw, id, idx);
break;
#endif
}
return 0;
}
#ifdef HAVE_LIBNX
void handle_touch_mouse(switch_input_t *sw)
{
int finger_id = 0;
uint64_t current_time = svcGetSystemTick() * 1000 / 19200000;
unsigned int i;
finish_simulated_mouse_clicks(sw, current_time);
for (i = 0; i < MULTITOUCH_LIMIT; i++)
{
if (sw->touch_state[i])
{
float x = 0;
float y = 0;
normalize_touch_mouse_xy(&x, &y, sw->touch_x[i], sw->touch_y[i]);
finger_id = i;
/* Send an initial touch if finger hasn't been down */
if (!sw->previous_touch_state[i])
{
TouchEvent ev;
ev.type = FINGERDOWN;
ev.tfinger.timestamp = current_time;
ev.tfinger.fingerId = finger_id;
ev.tfinger.x = x;
ev.tfinger.y = y;
process_touch_mouse_event(sw, &ev);
}
else
{
/* If finger moved, send motion event instead */
if (sw->touch_x[i] != sw->touch_previous_x[i] ||
sw->touch_y[i] != sw->touch_previous_y[i])
{
float oldx = 0;
float oldy = 0;
TouchEvent ev;
normalize_touch_mouse_xy(&oldx, &oldy, sw->touch_previous_x[i], sw->touch_previous_y[i]);
ev.type = FINGERMOTION;
ev.tfinger.timestamp = current_time;
ev.tfinger.fingerId = finger_id;
ev.tfinger.x = x;
ev.tfinger.y = y;
ev.tfinger.dx = x - oldx;
ev.tfinger.dy = y - oldy;
process_touch_mouse_event(sw, &ev);
}
}
}
/* some fingers might have been let go */
if (sw->previous_touch_state[i] == true && sw->touch_state[i] == false)
{
float x = 0;
float y = 0;
TouchEvent ev;
normalize_touch_mouse_xy(&x, &y, sw->touch_previous_x[i], sw->touch_previous_y[i]);
finger_id = i;
/* finger released from screen */
ev.type = FINGERUP;
ev.tfinger.timestamp = current_time;
ev.tfinger.fingerId = finger_id;
ev.tfinger.x = x;
ev.tfinger.y = y;
process_touch_mouse_event(sw, &ev);
}
}
}
void normalize_touch_mouse_xy(float *normalized_x, float *normalized_y, int reported_x, int reported_y)
{
float x = 0;
float y = 0;
x = (float) reported_x / TOUCH_MAX_X;
y = (float) reported_y / TOUCH_MAX_Y;
if (x < 0.0)
x = 0.0;
else if (x > 1.0)
x = 1.0;
if (y < 0.0)
y = 0.0;
else if (y > 1.0)
y = 1.0;
*normalized_x = x;
*normalized_y = y;
}
void process_touch_mouse_event(switch_input_t *sw, TouchEvent *event)
{
/* supported touch gestures:
* pointer motion = single finger drag
* left mouse click = single finger short tap
* right mouse click = second finger short tap while first finger is still down
* left click drag and drop = dual finger drag
* right click drag and drop = triple finger drag */
if (event->type == FINGERDOWN || event->type == FINGERUP || event->type == FINGERMOTION)
{
switch (event->type)
{
case FINGERDOWN:
process_touch_mouse_finger_down(sw, event);
break;
case FINGERUP:
process_touch_mouse_finger_up(sw, event);
break;
case FINGERMOTION:
process_touch_mouse_finger_motion(sw, event);
break;
}
}
}
void process_touch_mouse_finger_down(switch_input_t *sw, TouchEvent *event)
{
/* id (for multitouch) */
int id = event->tfinger.fingerId;
unsigned int i;
/* make sure each finger is not reported down multiple times */
for (i = 0; i < MAX_NUM_FINGERS; i++)
{
if (sw->finger[i].id == id)
sw->finger[i].id = NO_TOUCH;
}
/* we need the timestamps to decide later if the user performed a short tap (click)
* or a long tap (drag)
* we also need the last coordinates for each finger to keep track of dragging */
for (i = 0; i < MAX_NUM_FINGERS; i++)
{
if (sw->finger[i].id == NO_TOUCH)
{
sw->finger[i].id = id;
sw->finger[i].time_last_down = event->tfinger.timestamp;
sw->finger[i].last_down_x = event->tfinger.x;
sw->finger[i].last_down_y = event->tfinger.y;
break;
}
}
}
void process_touch_mouse_finger_up(switch_input_t *sw, TouchEvent *event)
{
/* id (for multitouch) */
int id = event->tfinger.fingerId;
int num_fingers_down;
unsigned int i;
/* find out how many fingers were down before this event */
num_fingers_down = 0;
for (i = 0; i < MAX_NUM_FINGERS; i++)
{
if (sw->finger[i].id >= 0)
num_fingers_down++;
}
for (i = 0; i < MAX_NUM_FINGERS; i++)
{
if (sw->finger[i].id != id)
continue;
sw->finger[i].id = NO_TOUCH;
if (!sw->multi_finger_dragging)
{
float xrel;
float yrel;
float max_r_squared;
int simulated_button;
if ((event->tfinger.timestamp - sw->finger[i].time_last_down) > MAX_TAP_TIME)
continue;
/* short (<MAX_TAP_TIME ms) tap is interpreted as right/left mouse click depending on # fingers already down
* but only if the finger hasn't moved since it was pressed down by more than MAX_TAP_MOTION_DISTANCE pixels */
xrel = ((event->tfinger.x * TOUCH_MAX_X) - (sw->finger[i].last_down_x * TOUCH_MAX_X));
yrel = ((event->tfinger.y * TOUCH_MAX_Y) - (sw->finger[i].last_down_y * TOUCH_MAX_Y));
max_r_squared = (float) (MAX_TAP_MOTION_DISTANCE * MAX_TAP_MOTION_DISTANCE);
if ((xrel * xrel + yrel * yrel) >= max_r_squared)
continue;
if (num_fingers_down != 2 && num_fingers_down != 1)
continue;
simulated_button = 0;
if (num_fingers_down == 2)
{
simulated_button = TOUCH_MOUSE_BUTTON_RIGHT;
/* need to raise the button later */
sw->simulated_click_start_time[TOUCH_MOUSE_BUTTON_RIGHT] = event->tfinger.timestamp;
}
else if (num_fingers_down == 1)
{
if (!sw->touch_mouse_indirect)
{
int x;
int y;
normalized_to_screen_xy(&x, &y, event->tfinger.x, event->tfinger.y);
sw->mouse_x_delta = x - sw->mouse_x;
sw->mouse_y_delta = y - sw->mouse_y;
sw->mouse_x = x;
sw->mouse_y = y;
}
simulated_button = TOUCH_MOUSE_BUTTON_LEFT;
/* need to raise the button later */
sw->simulated_click_start_time[TOUCH_MOUSE_BUTTON_LEFT] = event->tfinger.timestamp;
}
/* simulate mouse button down */
if (simulated_button == TOUCH_MOUSE_BUTTON_LEFT)
sw->mouse_button_left = true;
else if (simulated_button == TOUCH_MOUSE_BUTTON_RIGHT)
sw->mouse_button_right = true;
}
else if (num_fingers_down == 1)
{
/* when dragging, and the last finger is lifted, the drag is over
* so simulate mouse button up */
if (sw->multi_finger_dragging == DRAG_THREE_FINGER)
sw->mouse_button_right = false;
else
sw->mouse_button_left = false;
sw->multi_finger_dragging = DRAG_NONE;
}
}
}
void process_touch_mouse_finger_motion(switch_input_t *sw, TouchEvent *event)
{
/* id (for multitouch) */
int id = event->tfinger.fingerId;
unsigned int i;
unsigned int j;
int num_fingers_down;
bool update_pointer;
/* find out how many fingers were down before this event */
num_fingers_down = 0;
for (i = 0; i < MAX_NUM_FINGERS; i++)
{
if (sw->finger[i].id >= 0)
num_fingers_down++;
}
if (num_fingers_down == 0)
return;
/* If we are starting a multi-finger drag, start holding down the mouse button */
if (num_fingers_down >= 2 && !sw->multi_finger_dragging)
{
/* only start a multi-finger drag if at least two fingers have been down long enough */
int num_fingers_down_long = 0;
for (i = 0; i < MAX_NUM_FINGERS; i++)
{
if (sw->finger[i].id == NO_TOUCH)
continue;
if (event->tfinger.timestamp - sw->finger[i].time_last_down > MAX_TAP_TIME)
num_fingers_down_long++;
}
if (num_fingers_down_long >= 2)
{
int simulated_button = 0;
if (num_fingers_down_long == 2)
{
simulated_button = TOUCH_MOUSE_BUTTON_LEFT;
sw->multi_finger_dragging = DRAG_TWO_FINGER;
}
else
{
simulated_button = TOUCH_MOUSE_BUTTON_RIGHT;
sw->multi_finger_dragging = DRAG_THREE_FINGER;
}
if (simulated_button == TOUCH_MOUSE_BUTTON_LEFT)
sw->mouse_button_left = true;
else if (simulated_button == TOUCH_MOUSE_BUTTON_RIGHT)
sw->mouse_button_right = true;
}
}
/* check if this is the "oldest" finger down (or the only finger down)
* otherwise it will not affect mouse motion */
update_pointer = true;
if (num_fingers_down > 1)
{
for (i = 0; i < MAX_NUM_FINGERS; i++)
{
if (sw->finger[i].id != id)
continue;
for (j = 0; j < MAX_NUM_FINGERS; j++)
{
if (sw->finger[j].id == NO_TOUCH || (j == i))
continue;
if (sw->finger[j].time_last_down < sw->finger[i].time_last_down)
update_pointer = false;
}
}
}
if (!update_pointer)
return;
if (!sw->touch_mouse_indirect)
{
int x;
int y;
normalized_to_screen_xy(&x, &y, event->tfinger.x, event->tfinger.y);
sw->mouse_x_delta = x - sw->mouse_x;
sw->mouse_y_delta = y - sw->mouse_y;
sw->mouse_x = x;
sw->mouse_y = y;
}
else
{
/* for relative mode, use the pointer speed setting */
int dx = event->tfinger.dx * TOUCH_MAX_X * 256 * sw->touch_mouse_speed_factor;
int dy = event->tfinger.dy * TOUCH_MAX_Y * 256 * sw->touch_mouse_speed_factor;
sw->hires_dx += dx;
sw->hires_dy += dy;
int x_rel = sw->hires_dx / 256;
int y_rel = sw->hires_dy / 256;
if (x_rel || y_rel)
{
sw->mouse_x_delta = x_rel;
sw->mouse_y_delta = y_rel;
sw->mouse_x += x_rel;
sw->mouse_y += y_rel;
}
sw->hires_dx %= 256;
sw->hires_dy %= 256;
}
}
void normalized_to_screen_xy(int *screenX, int *screenY, float x, float y)
{
/* map to display */
*screenX = x * TOUCH_MAX_X;
*screenY = y * TOUCH_MAX_Y;
}
void finish_simulated_mouse_clicks(switch_input_t *sw, uint64_t currentTime)
{
unsigned int i;
for (i = 0; i < 2; i++)
{
if (sw->simulated_click_start_time[i] == 0)
continue;
if (currentTime - sw->simulated_click_start_time[i] < SIMULATED_CLICK_DURATION)
continue;
if (i == 0)
sw->mouse_button_left = false;
else
sw->mouse_button_right = false;
sw->simulated_click_start_time[i] = 0;
}
}
#endif
static void switch_input_free_input(void *data)
{
switch_input_t *sw = (switch_input_t*) data;
if (sw && sw->joypad)
sw->joypad->destroy();
free(sw);
#ifdef HAVE_LIBNX
hidExit();
#endif
}
static void* switch_input_init(const char *joypad_driver)
{
switch_input_t *sw = (switch_input_t*) calloc(1, sizeof(*sw));
if (!sw)
return NULL;
#ifdef HAVE_LIBNX
hidInitialize();
#endif
sw->joypad = input_joypad_init_driver(joypad_driver, sw);
#ifdef HAVE_LIBNX
/*
Here we assume that the touch screen is always 1280x720
Call me back when a Nintendo Switch XL is out
*/
input_keymaps_init_keyboard_lut(rarch_key_map_switch);
unsigned int i;
for (i = 0; i <= SWITCH_MAX_SCANCODE; i++)
sw->keyboard_state[i] = false;
sw->mouse_x = 0;
sw->mouse_y = 0;
sw->mouse_previous_report = 0;
/* touch mouse init */
sw->touch_mouse_indirect = true; /* direct mode is not calibrated it seems */
sw->touch_mouse_speed_factor = 1.0;
for (i = 0; i < MAX_NUM_FINGERS; i++)
sw->finger[i].id = NO_TOUCH;
sw->multi_finger_dragging = DRAG_NONE;
for (i = 0; i < 2; i++)
sw->simulated_click_start_time[i] = 0;
#endif
return sw;
}
static uint64_t switch_input_get_capabilities(void *data)
{
(void) data;
uint64_t caps = (1 << RETRO_DEVICE_JOYPAD) | (1 << RETRO_DEVICE_ANALOG);
#ifdef HAVE_LIBNX
caps |= (1 << RETRO_DEVICE_POINTER) | (1 << RETRO_DEVICE_KEYBOARD) | (1 << RETRO_DEVICE_MOUSE);
#endif
return caps;
}
static const input_device_driver_t *switch_input_get_joypad_driver(void *data)
{
switch_input_t *sw = (switch_input_t*) data;
if (sw)
return sw->joypad;
return NULL;
}
static void switch_input_grab_mouse(void *data, bool state)
{
(void)data;
(void)state;
}
static bool switch_input_set_rumble(void *data, unsigned port,
enum retro_rumble_effect effect, uint16_t strength)
{
#ifdef HAVE_LIBNX
switch_input_t *sw = (switch_input_t*) data;
if (!sw)
return false;
return input_joypad_set_rumble(sw->joypad, port, effect, strength);
#else
return false;
#endif
}
static bool switch_input_keyboard_mapping_is_blocked(void *data)
{
switch_input_t *sw = (switch_input_t*) data;
if (!sw)
return false;
return sw->blocked;
}
static void switch_input_keyboard_mapping_set_block(void *data, bool value)
{
switch_input_t *sw = (switch_input_t*) data;
if (!sw)
return;
sw->blocked = value;
}
input_driver_t input_switch = {
switch_input_init,
switch_input_poll,
switch_input_state,
switch_input_free_input,
NULL,
NULL,
switch_input_get_capabilities,
"switch",
switch_input_grab_mouse,
NULL,
switch_input_set_rumble,
switch_input_get_joypad_driver,
NULL,
switch_input_keyboard_mapping_is_blocked,
switch_input_keyboard_mapping_set_block,
};
Reference in New Issue View Git Blame Copy Permalink