mirror of
https://github.com/yuzu-mirror/yuzu.git
synced 2024-09-09 16:39:08 +01:00
service/hid: Update touch and gestures to use ring lifo and the emulated console
This commit is contained in:
parent
072559dede
commit
afe2d667d9
4 changed files with 191 additions and 370 deletions
|
@ -5,8 +5,10 @@
|
||||||
#include "common/logging/log.h"
|
#include "common/logging/log.h"
|
||||||
#include "common/math_util.h"
|
#include "common/math_util.h"
|
||||||
#include "common/settings.h"
|
#include "common/settings.h"
|
||||||
|
#include "core/core.h"
|
||||||
#include "core/core_timing.h"
|
#include "core/core_timing.h"
|
||||||
#include "core/frontend/emu_window.h"
|
#include "core/frontend/emu_window.h"
|
||||||
|
#include "core/hid/hid_core.h"
|
||||||
#include "core/hle/service/hid/controllers/gesture.h"
|
#include "core/hle/service/hid/controllers/gesture.h"
|
||||||
|
|
||||||
namespace Service::HID {
|
namespace Service::HID {
|
||||||
|
@ -23,16 +25,15 @@ constexpr f32 Square(s32 num) {
|
||||||
return static_cast<f32>(num * num);
|
return static_cast<f32>(num * num);
|
||||||
}
|
}
|
||||||
|
|
||||||
Controller_Gesture::Controller_Gesture(Core::System& system_) : ControllerBase(system_) {}
|
Controller_Gesture::Controller_Gesture(Core::System& system_) : ControllerBase(system_) {
|
||||||
|
console = system.HIDCore().GetEmulatedConsole();
|
||||||
|
}
|
||||||
|
|
||||||
Controller_Gesture::~Controller_Gesture() = default;
|
Controller_Gesture::~Controller_Gesture() = default;
|
||||||
|
|
||||||
void Controller_Gesture::OnInit() {
|
void Controller_Gesture::OnInit() {
|
||||||
for (std::size_t id = 0; id < MAX_FINGERS; ++id) {
|
gesture_lifo.entry_count = 0;
|
||||||
mouse_finger_id[id] = MAX_POINTS;
|
gesture_lifo.last_entry_index = 0;
|
||||||
keyboard_finger_id[id] = MAX_POINTS;
|
|
||||||
udp_finger_id[id] = MAX_POINTS;
|
|
||||||
}
|
|
||||||
shared_memory.header.entry_count = 0;
|
|
||||||
force_update = true;
|
force_update = true;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -40,50 +41,43 @@ void Controller_Gesture::OnRelease() {}
|
||||||
|
|
||||||
void Controller_Gesture::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8* data,
|
void Controller_Gesture::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8* data,
|
||||||
std::size_t size) {
|
std::size_t size) {
|
||||||
shared_memory.header.timestamp = core_timing.GetCPUTicks();
|
// TODO FIND WTF IS WRONG HERE!!!!!!!!
|
||||||
shared_memory.header.total_entry_count = 17;
|
return;
|
||||||
|
|
||||||
if (!IsControllerActivated()) {
|
if (!IsControllerActivated()) {
|
||||||
shared_memory.header.entry_count = 0;
|
gesture_lifo.entry_count = 0;
|
||||||
shared_memory.header.last_entry_index = 0;
|
gesture_lifo.last_entry_index = 0;
|
||||||
|
std::memcpy(data, &gesture_lifo, sizeof(gesture_lifo));
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
ReadTouchInput();
|
ReadTouchInput();
|
||||||
|
|
||||||
GestureProperties gesture = GetGestureProperties();
|
GestureProperties gesture = GetGestureProperties();
|
||||||
f32 time_difference = static_cast<f32>(shared_memory.header.timestamp - last_update_timestamp) /
|
f32 time_difference =
|
||||||
(1000 * 1000 * 1000);
|
static_cast<f32>(gesture_lifo.timestamp - last_update_timestamp) / (1000 * 1000 * 1000);
|
||||||
|
|
||||||
// Only update if necesary
|
// Only update if necesary
|
||||||
if (!ShouldUpdateGesture(gesture, time_difference)) {
|
if (!ShouldUpdateGesture(gesture, time_difference)) {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
last_update_timestamp = shared_memory.header.timestamp;
|
last_update_timestamp = gesture_lifo.timestamp;
|
||||||
UpdateGestureSharedMemory(data, size, gesture, time_difference);
|
UpdateGestureSharedMemory(data, size, gesture, time_difference);
|
||||||
}
|
}
|
||||||
|
|
||||||
void Controller_Gesture::ReadTouchInput() {
|
void Controller_Gesture::ReadTouchInput() {
|
||||||
const Input::TouchStatus& mouse_status = touch_mouse_device->GetStatus();
|
const auto touch_status = console->GetTouch();
|
||||||
const Input::TouchStatus& udp_status = touch_udp_device->GetStatus();
|
for (std::size_t id = 0; id < fingers.size(); ++id) {
|
||||||
for (std::size_t id = 0; id < mouse_status.size(); ++id) {
|
const Core::HID::TouchFinger& status = touch_status[id];
|
||||||
mouse_finger_id[id] = UpdateTouchInputEvent(mouse_status[id], mouse_finger_id[id]);
|
Finger& finger = fingers[id];
|
||||||
udp_finger_id[id] = UpdateTouchInputEvent(udp_status[id], udp_finger_id[id]);
|
finger.pos = status.position;
|
||||||
}
|
finger.pressed = status.pressed;
|
||||||
|
|
||||||
if (Settings::values.use_touch_from_button) {
|
|
||||||
const Input::TouchStatus& keyboard_status = touch_btn_device->GetStatus();
|
|
||||||
for (std::size_t id = 0; id < mouse_status.size(); ++id) {
|
|
||||||
keyboard_finger_id[id] =
|
|
||||||
UpdateTouchInputEvent(keyboard_status[id], keyboard_finger_id[id]);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
bool Controller_Gesture::ShouldUpdateGesture(const GestureProperties& gesture,
|
bool Controller_Gesture::ShouldUpdateGesture(const GestureProperties& gesture,
|
||||||
f32 time_difference) {
|
f32 time_difference) {
|
||||||
const auto& last_entry = shared_memory.gesture_states[shared_memory.header.last_entry_index];
|
const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
|
||||||
if (force_update) {
|
if (force_update) {
|
||||||
force_update = false;
|
force_update = false;
|
||||||
return true;
|
return true;
|
||||||
|
@ -97,7 +91,7 @@ bool Controller_Gesture::ShouldUpdateGesture(const GestureProperties& gesture,
|
||||||
}
|
}
|
||||||
|
|
||||||
// Update on press and hold event after 0.5 seconds
|
// Update on press and hold event after 0.5 seconds
|
||||||
if (last_entry.type == TouchType::Touch && last_entry.point_count == 1 &&
|
if (last_entry.type == GestureType::Touch && last_entry.point_count == 1 &&
|
||||||
time_difference > press_delay) {
|
time_difference > press_delay) {
|
||||||
return enable_press_and_tap;
|
return enable_press_and_tap;
|
||||||
}
|
}
|
||||||
|
@ -108,27 +102,19 @@ bool Controller_Gesture::ShouldUpdateGesture(const GestureProperties& gesture,
|
||||||
void Controller_Gesture::UpdateGestureSharedMemory(u8* data, std::size_t size,
|
void Controller_Gesture::UpdateGestureSharedMemory(u8* data, std::size_t size,
|
||||||
GestureProperties& gesture,
|
GestureProperties& gesture,
|
||||||
f32 time_difference) {
|
f32 time_difference) {
|
||||||
TouchType type = TouchType::Idle;
|
GestureType type = GestureType::Idle;
|
||||||
Attribute attributes{};
|
GestureAttribute attributes{};
|
||||||
|
|
||||||
const auto& last_entry = shared_memory.gesture_states[shared_memory.header.last_entry_index];
|
const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
|
||||||
shared_memory.header.last_entry_index = (shared_memory.header.last_entry_index + 1) % 17;
|
|
||||||
auto& cur_entry = shared_memory.gesture_states[shared_memory.header.last_entry_index];
|
|
||||||
|
|
||||||
if (shared_memory.header.entry_count < 16) {
|
// Reset next state to default
|
||||||
shared_memory.header.entry_count++;
|
next_state.sampling_number = last_entry.sampling_number + 1;
|
||||||
}
|
next_state.delta = {};
|
||||||
|
next_state.vel_x = 0;
|
||||||
cur_entry.sampling_number = last_entry.sampling_number + 1;
|
next_state.vel_y = 0;
|
||||||
cur_entry.sampling_number2 = cur_entry.sampling_number;
|
next_state.direction = GestureDirection::None;
|
||||||
|
next_state.rotation_angle = 0;
|
||||||
// Reset values to default
|
next_state.scale = 0;
|
||||||
cur_entry.delta = {};
|
|
||||||
cur_entry.vel_x = 0;
|
|
||||||
cur_entry.vel_y = 0;
|
|
||||||
cur_entry.direction = Direction::None;
|
|
||||||
cur_entry.rotation_angle = 0;
|
|
||||||
cur_entry.scale = 0;
|
|
||||||
|
|
||||||
if (gesture.active_points > 0) {
|
if (gesture.active_points > 0) {
|
||||||
if (last_gesture.active_points == 0) {
|
if (last_gesture.active_points == 0) {
|
||||||
|
@ -141,46 +127,47 @@ void Controller_Gesture::UpdateGestureSharedMemory(u8* data, std::size_t size,
|
||||||
}
|
}
|
||||||
|
|
||||||
// Apply attributes
|
// Apply attributes
|
||||||
cur_entry.detection_count = gesture.detection_count;
|
next_state.detection_count = gesture.detection_count;
|
||||||
cur_entry.type = type;
|
next_state.type = type;
|
||||||
cur_entry.attributes = attributes;
|
next_state.attributes = attributes;
|
||||||
cur_entry.pos = gesture.mid_point;
|
next_state.pos = gesture.mid_point;
|
||||||
cur_entry.point_count = static_cast<s32>(gesture.active_points);
|
next_state.point_count = static_cast<s32>(gesture.active_points);
|
||||||
cur_entry.points = gesture.points;
|
next_state.points = gesture.points;
|
||||||
last_gesture = gesture;
|
last_gesture = gesture;
|
||||||
|
|
||||||
std::memcpy(data + SHARED_MEMORY_OFFSET, &shared_memory, sizeof(SharedMemory));
|
gesture_lifo.WriteNextEntry(next_state);
|
||||||
|
std::memcpy(data + SHARED_MEMORY_OFFSET, &gesture_lifo, sizeof(gesture_lifo));
|
||||||
}
|
}
|
||||||
|
|
||||||
void Controller_Gesture::NewGesture(GestureProperties& gesture, TouchType& type,
|
void Controller_Gesture::NewGesture(GestureProperties& gesture, GestureType& type,
|
||||||
Attribute& attributes) {
|
GestureAttribute& attributes) {
|
||||||
const auto& last_entry = GetLastGestureEntry();
|
const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
|
||||||
|
|
||||||
gesture.detection_count++;
|
gesture.detection_count++;
|
||||||
type = TouchType::Touch;
|
type = GestureType::Touch;
|
||||||
|
|
||||||
// New touch after cancel is not considered new
|
// New touch after cancel is not considered new
|
||||||
if (last_entry.type != TouchType::Cancel) {
|
if (last_entry.type != GestureType::Cancel) {
|
||||||
attributes.is_new_touch.Assign(1);
|
attributes.is_new_touch.Assign(1);
|
||||||
enable_press_and_tap = true;
|
enable_press_and_tap = true;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void Controller_Gesture::UpdateExistingGesture(GestureProperties& gesture, TouchType& type,
|
void Controller_Gesture::UpdateExistingGesture(GestureProperties& gesture, GestureType& type,
|
||||||
f32 time_difference) {
|
f32 time_difference) {
|
||||||
const auto& last_entry = GetLastGestureEntry();
|
const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
|
||||||
|
|
||||||
// Promote to pan type if touch moved
|
// Promote to pan type if touch moved
|
||||||
for (size_t id = 0; id < MAX_POINTS; id++) {
|
for (size_t id = 0; id < MAX_POINTS; id++) {
|
||||||
if (gesture.points[id] != last_gesture.points[id]) {
|
if (gesture.points[id] != last_gesture.points[id]) {
|
||||||
type = TouchType::Pan;
|
type = GestureType::Pan;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// Number of fingers changed cancel the last event and clear data
|
// Number of fingers changed cancel the last event and clear data
|
||||||
if (gesture.active_points != last_gesture.active_points) {
|
if (gesture.active_points != last_gesture.active_points) {
|
||||||
type = TouchType::Cancel;
|
type = GestureType::Cancel;
|
||||||
enable_press_and_tap = false;
|
enable_press_and_tap = false;
|
||||||
gesture.active_points = 0;
|
gesture.active_points = 0;
|
||||||
gesture.mid_point = {};
|
gesture.mid_point = {};
|
||||||
|
@ -189,41 +176,41 @@ void Controller_Gesture::UpdateExistingGesture(GestureProperties& gesture, Touch
|
||||||
}
|
}
|
||||||
|
|
||||||
// Calculate extra parameters of panning
|
// Calculate extra parameters of panning
|
||||||
if (type == TouchType::Pan) {
|
if (type == GestureType::Pan) {
|
||||||
UpdatePanEvent(gesture, last_gesture, type, time_difference);
|
UpdatePanEvent(gesture, last_gesture, type, time_difference);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
// Promote to press type
|
// Promote to press type
|
||||||
if (last_entry.type == TouchType::Touch) {
|
if (last_entry.type == GestureType::Touch) {
|
||||||
type = TouchType::Press;
|
type = GestureType::Press;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void Controller_Gesture::EndGesture(GestureProperties& gesture,
|
void Controller_Gesture::EndGesture(GestureProperties& gesture,
|
||||||
GestureProperties& last_gesture_props, TouchType& type,
|
GestureProperties& last_gesture_props, GestureType& type,
|
||||||
Attribute& attributes, f32 time_difference) {
|
GestureAttribute& attributes, f32 time_difference) {
|
||||||
const auto& last_entry = GetLastGestureEntry();
|
const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
|
||||||
|
|
||||||
if (last_gesture_props.active_points != 0) {
|
if (last_gesture_props.active_points != 0) {
|
||||||
switch (last_entry.type) {
|
switch (last_entry.type) {
|
||||||
case TouchType::Touch:
|
case GestureType::Touch:
|
||||||
if (enable_press_and_tap) {
|
if (enable_press_and_tap) {
|
||||||
SetTapEvent(gesture, last_gesture_props, type, attributes);
|
SetTapEvent(gesture, last_gesture_props, type, attributes);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
type = TouchType::Cancel;
|
type = GestureType::Cancel;
|
||||||
force_update = true;
|
force_update = true;
|
||||||
break;
|
break;
|
||||||
case TouchType::Press:
|
case GestureType::Press:
|
||||||
case TouchType::Tap:
|
case GestureType::Tap:
|
||||||
case TouchType::Swipe:
|
case GestureType::Swipe:
|
||||||
case TouchType::Pinch:
|
case GestureType::Pinch:
|
||||||
case TouchType::Rotate:
|
case GestureType::Rotate:
|
||||||
type = TouchType::Complete;
|
type = GestureType::Complete;
|
||||||
force_update = true;
|
force_update = true;
|
||||||
break;
|
break;
|
||||||
case TouchType::Pan:
|
case GestureType::Pan:
|
||||||
EndPanEvent(gesture, last_gesture_props, type, time_difference);
|
EndPanEvent(gesture, last_gesture_props, type, time_difference);
|
||||||
break;
|
break;
|
||||||
default:
|
default:
|
||||||
|
@ -231,15 +218,15 @@ void Controller_Gesture::EndGesture(GestureProperties& gesture,
|
||||||
}
|
}
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if (last_entry.type == TouchType::Complete || last_entry.type == TouchType::Cancel) {
|
if (last_entry.type == GestureType::Complete || last_entry.type == GestureType::Cancel) {
|
||||||
gesture.detection_count++;
|
gesture.detection_count++;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void Controller_Gesture::SetTapEvent(GestureProperties& gesture,
|
void Controller_Gesture::SetTapEvent(GestureProperties& gesture,
|
||||||
GestureProperties& last_gesture_props, TouchType& type,
|
GestureProperties& last_gesture_props, GestureType& type,
|
||||||
Attribute& attributes) {
|
GestureAttribute& attributes) {
|
||||||
type = TouchType::Tap;
|
type = GestureType::Tap;
|
||||||
gesture = last_gesture_props;
|
gesture = last_gesture_props;
|
||||||
force_update = true;
|
force_update = true;
|
||||||
f32 tap_time_difference =
|
f32 tap_time_difference =
|
||||||
|
@ -251,44 +238,42 @@ void Controller_Gesture::SetTapEvent(GestureProperties& gesture,
|
||||||
}
|
}
|
||||||
|
|
||||||
void Controller_Gesture::UpdatePanEvent(GestureProperties& gesture,
|
void Controller_Gesture::UpdatePanEvent(GestureProperties& gesture,
|
||||||
GestureProperties& last_gesture_props, TouchType& type,
|
GestureProperties& last_gesture_props, GestureType& type,
|
||||||
f32 time_difference) {
|
f32 time_difference) {
|
||||||
auto& cur_entry = shared_memory.gesture_states[shared_memory.header.last_entry_index];
|
const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
|
||||||
const auto& last_entry = GetLastGestureEntry();
|
|
||||||
|
|
||||||
cur_entry.delta = gesture.mid_point - last_entry.pos;
|
next_state.delta = gesture.mid_point - last_entry.pos;
|
||||||
cur_entry.vel_x = static_cast<f32>(cur_entry.delta.x) / time_difference;
|
next_state.vel_x = static_cast<f32>(next_state.delta.x) / time_difference;
|
||||||
cur_entry.vel_y = static_cast<f32>(cur_entry.delta.y) / time_difference;
|
next_state.vel_y = static_cast<f32>(next_state.delta.y) / time_difference;
|
||||||
last_pan_time_difference = time_difference;
|
last_pan_time_difference = time_difference;
|
||||||
|
|
||||||
// Promote to pinch type
|
// Promote to pinch type
|
||||||
if (std::abs(gesture.average_distance - last_gesture_props.average_distance) >
|
if (std::abs(gesture.average_distance - last_gesture_props.average_distance) >
|
||||||
pinch_threshold) {
|
pinch_threshold) {
|
||||||
type = TouchType::Pinch;
|
type = GestureType::Pinch;
|
||||||
cur_entry.scale = gesture.average_distance / last_gesture_props.average_distance;
|
next_state.scale = gesture.average_distance / last_gesture_props.average_distance;
|
||||||
}
|
}
|
||||||
|
|
||||||
const f32 angle_between_two_lines = std::atan((gesture.angle - last_gesture_props.angle) /
|
const f32 angle_between_two_lines = std::atan((gesture.angle - last_gesture_props.angle) /
|
||||||
(1 + (gesture.angle * last_gesture_props.angle)));
|
(1 + (gesture.angle * last_gesture_props.angle)));
|
||||||
// Promote to rotate type
|
// Promote to rotate type
|
||||||
if (std::abs(angle_between_two_lines) > angle_threshold) {
|
if (std::abs(angle_between_two_lines) > angle_threshold) {
|
||||||
type = TouchType::Rotate;
|
type = GestureType::Rotate;
|
||||||
cur_entry.scale = 0;
|
next_state.scale = 0;
|
||||||
cur_entry.rotation_angle = angle_between_two_lines * 180.0f / Common::PI;
|
next_state.rotation_angle = angle_between_two_lines * 180.0f / Common::PI;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void Controller_Gesture::EndPanEvent(GestureProperties& gesture,
|
void Controller_Gesture::EndPanEvent(GestureProperties& gesture,
|
||||||
GestureProperties& last_gesture_props, TouchType& type,
|
GestureProperties& last_gesture_props, GestureType& type,
|
||||||
f32 time_difference) {
|
f32 time_difference) {
|
||||||
auto& cur_entry = shared_memory.gesture_states[shared_memory.header.last_entry_index];
|
const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
|
||||||
const auto& last_entry = GetLastGestureEntry();
|
next_state.vel_x =
|
||||||
cur_entry.vel_x =
|
|
||||||
static_cast<f32>(last_entry.delta.x) / (last_pan_time_difference + time_difference);
|
static_cast<f32>(last_entry.delta.x) / (last_pan_time_difference + time_difference);
|
||||||
cur_entry.vel_y =
|
next_state.vel_y =
|
||||||
static_cast<f32>(last_entry.delta.y) / (last_pan_time_difference + time_difference);
|
static_cast<f32>(last_entry.delta.y) / (last_pan_time_difference + time_difference);
|
||||||
const f32 curr_vel =
|
const f32 curr_vel =
|
||||||
std::sqrt((cur_entry.vel_x * cur_entry.vel_x) + (cur_entry.vel_y * cur_entry.vel_y));
|
std::sqrt((next_state.vel_x * next_state.vel_x) + (next_state.vel_y * next_state.vel_y));
|
||||||
|
|
||||||
// Set swipe event with parameters
|
// Set swipe event with parameters
|
||||||
if (curr_vel > swipe_threshold) {
|
if (curr_vel > swipe_threshold) {
|
||||||
|
@ -297,93 +282,34 @@ void Controller_Gesture::EndPanEvent(GestureProperties& gesture,
|
||||||
}
|
}
|
||||||
|
|
||||||
// End panning without swipe
|
// End panning without swipe
|
||||||
type = TouchType::Complete;
|
type = GestureType::Complete;
|
||||||
cur_entry.vel_x = 0;
|
next_state.vel_x = 0;
|
||||||
cur_entry.vel_y = 0;
|
next_state.vel_y = 0;
|
||||||
force_update = true;
|
force_update = true;
|
||||||
}
|
}
|
||||||
|
|
||||||
void Controller_Gesture::SetSwipeEvent(GestureProperties& gesture,
|
void Controller_Gesture::SetSwipeEvent(GestureProperties& gesture,
|
||||||
GestureProperties& last_gesture_props, TouchType& type) {
|
GestureProperties& last_gesture_props, GestureType& type) {
|
||||||
auto& cur_entry = shared_memory.gesture_states[shared_memory.header.last_entry_index];
|
const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
|
||||||
const auto& last_entry = GetLastGestureEntry();
|
|
||||||
|
|
||||||
type = TouchType::Swipe;
|
type = GestureType::Swipe;
|
||||||
gesture = last_gesture_props;
|
gesture = last_gesture_props;
|
||||||
force_update = true;
|
force_update = true;
|
||||||
cur_entry.delta = last_entry.delta;
|
next_state.delta = last_entry.delta;
|
||||||
|
|
||||||
if (std::abs(cur_entry.delta.x) > std::abs(cur_entry.delta.y)) {
|
if (std::abs(next_state.delta.x) > std::abs(next_state.delta.y)) {
|
||||||
if (cur_entry.delta.x > 0) {
|
if (next_state.delta.x > 0) {
|
||||||
cur_entry.direction = Direction::Right;
|
next_state.direction = GestureDirection::Right;
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
cur_entry.direction = Direction::Left;
|
next_state.direction = GestureDirection::Left;
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if (cur_entry.delta.y > 0) {
|
if (next_state.delta.y > 0) {
|
||||||
cur_entry.direction = Direction::Down;
|
next_state.direction = GestureDirection::Down;
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
cur_entry.direction = Direction::Up;
|
next_state.direction = GestureDirection::Up;
|
||||||
}
|
|
||||||
|
|
||||||
void Controller_Gesture::OnLoadInputDevices() {
|
|
||||||
touch_mouse_device = Input::CreateDevice<Input::TouchDevice>("engine:emu_window");
|
|
||||||
touch_udp_device = Input::CreateDevice<Input::TouchDevice>("engine:cemuhookudp");
|
|
||||||
touch_btn_device = Input::CreateDevice<Input::TouchDevice>("engine:touch_from_button");
|
|
||||||
}
|
|
||||||
|
|
||||||
std::optional<std::size_t> Controller_Gesture::GetUnusedFingerID() const {
|
|
||||||
// Dont assign any touch input to a point if disabled
|
|
||||||
if (!Settings::values.touchscreen.enabled) {
|
|
||||||
return std::nullopt;
|
|
||||||
}
|
|
||||||
std::size_t first_free_id = 0;
|
|
||||||
while (first_free_id < MAX_POINTS) {
|
|
||||||
if (!fingers[first_free_id].pressed) {
|
|
||||||
return first_free_id;
|
|
||||||
} else {
|
|
||||||
first_free_id++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return std::nullopt;
|
|
||||||
}
|
|
||||||
|
|
||||||
Controller_Gesture::GestureState& Controller_Gesture::GetLastGestureEntry() {
|
|
||||||
return shared_memory.gesture_states[(shared_memory.header.last_entry_index + 16) % 17];
|
|
||||||
}
|
|
||||||
|
|
||||||
const Controller_Gesture::GestureState& Controller_Gesture::GetLastGestureEntry() const {
|
|
||||||
return shared_memory.gesture_states[(shared_memory.header.last_entry_index + 16) % 17];
|
|
||||||
}
|
|
||||||
|
|
||||||
std::size_t Controller_Gesture::UpdateTouchInputEvent(
|
|
||||||
const std::tuple<float, float, bool>& touch_input, std::size_t finger_id) {
|
|
||||||
const auto& [x, y, pressed] = touch_input;
|
|
||||||
if (finger_id > MAX_POINTS) {
|
|
||||||
LOG_ERROR(Service_HID, "Invalid finger id {}", finger_id);
|
|
||||||
return MAX_POINTS;
|
|
||||||
}
|
|
||||||
if (pressed) {
|
|
||||||
if (finger_id == MAX_POINTS) {
|
|
||||||
const auto first_free_id = GetUnusedFingerID();
|
|
||||||
if (!first_free_id) {
|
|
||||||
// Invalid finger id do nothing
|
|
||||||
return MAX_POINTS;
|
|
||||||
}
|
|
||||||
finger_id = first_free_id.value();
|
|
||||||
fingers[finger_id].pressed = true;
|
|
||||||
}
|
|
||||||
fingers[finger_id].pos = {x, y};
|
|
||||||
return finger_id;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (finger_id != MAX_POINTS) {
|
|
||||||
fingers[finger_id].pressed = false;
|
|
||||||
}
|
|
||||||
|
|
||||||
return MAX_POINTS;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
Controller_Gesture::GestureProperties Controller_Gesture::GetGestureProperties() {
|
Controller_Gesture::GestureProperties Controller_Gesture::GetGestureProperties() {
|
||||||
|
|
|
@ -8,8 +8,12 @@
|
||||||
#include "common/bit_field.h"
|
#include "common/bit_field.h"
|
||||||
#include "common/common_types.h"
|
#include "common/common_types.h"
|
||||||
#include "common/point.h"
|
#include "common/point.h"
|
||||||
#include "core/frontend/input.h"
|
|
||||||
#include "core/hle/service/hid/controllers/controller_base.h"
|
#include "core/hle/service/hid/controllers/controller_base.h"
|
||||||
|
#include "core/hle/service/hid/ring_lifo.h"
|
||||||
|
|
||||||
|
namespace Core::HID {
|
||||||
|
class EmulatedController;
|
||||||
|
} // namespace Core::HID
|
||||||
|
|
||||||
namespace Service::HID {
|
namespace Service::HID {
|
||||||
class Controller_Gesture final : public ControllerBase {
|
class Controller_Gesture final : public ControllerBase {
|
||||||
|
@ -26,14 +30,12 @@ public:
|
||||||
// When the controller is requesting an update for the shared memory
|
// When the controller is requesting an update for the shared memory
|
||||||
void OnUpdate(const Core::Timing::CoreTiming& core_timing, u8* data, size_t size) override;
|
void OnUpdate(const Core::Timing::CoreTiming& core_timing, u8* data, size_t size) override;
|
||||||
|
|
||||||
// Called when input devices should be loaded
|
|
||||||
void OnLoadInputDevices() override;
|
|
||||||
|
|
||||||
private:
|
private:
|
||||||
static constexpr size_t MAX_FINGERS = 16;
|
static constexpr size_t MAX_FINGERS = 16;
|
||||||
static constexpr size_t MAX_POINTS = 4;
|
static constexpr size_t MAX_POINTS = 4;
|
||||||
|
|
||||||
enum class TouchType : u32 {
|
// This is nn::hid::GestureType
|
||||||
|
enum class GestureType : u32 {
|
||||||
Idle, // Nothing touching the screen
|
Idle, // Nothing touching the screen
|
||||||
Complete, // Set at the end of a touch event
|
Complete, // Set at the end of a touch event
|
||||||
Cancel, // Set when the number of fingers change
|
Cancel, // Set when the number of fingers change
|
||||||
|
@ -46,7 +48,8 @@ private:
|
||||||
Rotate, // All points rotating from the midpoint
|
Rotate, // All points rotating from the midpoint
|
||||||
};
|
};
|
||||||
|
|
||||||
enum class Direction : u32 {
|
// This is nn::hid::GestureDirection
|
||||||
|
enum class GestureDirection : u32 {
|
||||||
None,
|
None,
|
||||||
Left,
|
Left,
|
||||||
Up,
|
Up,
|
||||||
|
@ -54,7 +57,8 @@ private:
|
||||||
Down,
|
Down,
|
||||||
};
|
};
|
||||||
|
|
||||||
struct Attribute {
|
// This is nn::hid::GestureAttribute
|
||||||
|
struct GestureAttribute {
|
||||||
union {
|
union {
|
||||||
u32_le raw{};
|
u32_le raw{};
|
||||||
|
|
||||||
|
@ -62,31 +66,25 @@ private:
|
||||||
BitField<8, 1, u32> is_double_tap;
|
BitField<8, 1, u32> is_double_tap;
|
||||||
};
|
};
|
||||||
};
|
};
|
||||||
static_assert(sizeof(Attribute) == 4, "Attribute is an invalid size");
|
static_assert(sizeof(GestureAttribute) == 4, "GestureAttribute is an invalid size");
|
||||||
|
|
||||||
|
// This is nn::hid::GestureState
|
||||||
struct GestureState {
|
struct GestureState {
|
||||||
s64_le sampling_number;
|
s64_le sampling_number;
|
||||||
s64_le sampling_number2;
|
|
||||||
s64_le detection_count;
|
s64_le detection_count;
|
||||||
TouchType type;
|
GestureType type;
|
||||||
Direction direction;
|
GestureDirection direction;
|
||||||
Common::Point<s32_le> pos;
|
Common::Point<s32_le> pos;
|
||||||
Common::Point<s32_le> delta;
|
Common::Point<s32_le> delta;
|
||||||
f32 vel_x;
|
f32 vel_x;
|
||||||
f32 vel_y;
|
f32 vel_y;
|
||||||
Attribute attributes;
|
GestureAttribute attributes;
|
||||||
f32 scale;
|
f32 scale;
|
||||||
f32 rotation_angle;
|
f32 rotation_angle;
|
||||||
s32_le point_count;
|
s32_le point_count;
|
||||||
std::array<Common::Point<s32_le>, 4> points;
|
std::array<Common::Point<s32_le>, 4> points;
|
||||||
};
|
};
|
||||||
static_assert(sizeof(GestureState) == 0x68, "GestureState is an invalid size");
|
static_assert(sizeof(GestureState) == 0x60, "GestureState is an invalid size");
|
||||||
|
|
||||||
struct SharedMemory {
|
|
||||||
CommonHeader header;
|
|
||||||
std::array<GestureState, 17> gesture_states;
|
|
||||||
};
|
|
||||||
static_assert(sizeof(SharedMemory) == 0x708, "SharedMemory is an invalid size");
|
|
||||||
|
|
||||||
struct Finger {
|
struct Finger {
|
||||||
Common::Point<f32> pos{};
|
Common::Point<f32> pos{};
|
||||||
|
@ -114,58 +112,42 @@ private:
|
||||||
f32 time_difference);
|
f32 time_difference);
|
||||||
|
|
||||||
// Initializes new gesture
|
// Initializes new gesture
|
||||||
void NewGesture(GestureProperties& gesture, TouchType& type, Attribute& attributes);
|
void NewGesture(GestureProperties& gesture, GestureType& type, GestureAttribute& attributes);
|
||||||
|
|
||||||
// Updates existing gesture state
|
// Updates existing gesture state
|
||||||
void UpdateExistingGesture(GestureProperties& gesture, TouchType& type, f32 time_difference);
|
void UpdateExistingGesture(GestureProperties& gesture, GestureType& type, f32 time_difference);
|
||||||
|
|
||||||
// Terminates exiting gesture
|
// Terminates exiting gesture
|
||||||
void EndGesture(GestureProperties& gesture, GestureProperties& last_gesture_props,
|
void EndGesture(GestureProperties& gesture, GestureProperties& last_gesture_props,
|
||||||
TouchType& type, Attribute& attributes, f32 time_difference);
|
GestureType& type, GestureAttribute& attributes, f32 time_difference);
|
||||||
|
|
||||||
// Set current event to a tap event
|
// Set current event to a tap event
|
||||||
void SetTapEvent(GestureProperties& gesture, GestureProperties& last_gesture_props,
|
void SetTapEvent(GestureProperties& gesture, GestureProperties& last_gesture_props,
|
||||||
TouchType& type, Attribute& attributes);
|
GestureType& type, GestureAttribute& attributes);
|
||||||
|
|
||||||
// Calculates and set the extra parameters related to a pan event
|
// Calculates and set the extra parameters related to a pan event
|
||||||
void UpdatePanEvent(GestureProperties& gesture, GestureProperties& last_gesture_props,
|
void UpdatePanEvent(GestureProperties& gesture, GestureProperties& last_gesture_props,
|
||||||
TouchType& type, f32 time_difference);
|
GestureType& type, f32 time_difference);
|
||||||
|
|
||||||
// Terminates the pan event
|
// Terminates the pan event
|
||||||
void EndPanEvent(GestureProperties& gesture, GestureProperties& last_gesture_props,
|
void EndPanEvent(GestureProperties& gesture, GestureProperties& last_gesture_props,
|
||||||
TouchType& type, f32 time_difference);
|
GestureType& type, f32 time_difference);
|
||||||
|
|
||||||
// Set current event to a swipe event
|
// Set current event to a swipe event
|
||||||
void SetSwipeEvent(GestureProperties& gesture, GestureProperties& last_gesture_props,
|
void SetSwipeEvent(GestureProperties& gesture, GestureProperties& last_gesture_props,
|
||||||
TouchType& type);
|
GestureType& type);
|
||||||
|
|
||||||
// Returns an unused finger id, if there is no fingers available std::nullopt is returned.
|
|
||||||
[[nodiscard]] std::optional<size_t> GetUnusedFingerID() const;
|
|
||||||
|
|
||||||
// Retrieves the last gesture entry, as indicated by shared memory indices.
|
|
||||||
[[nodiscard]] GestureState& GetLastGestureEntry();
|
|
||||||
[[nodiscard]] const GestureState& GetLastGestureEntry() const;
|
|
||||||
|
|
||||||
/**
|
|
||||||
* If the touch is new it tries to assign a new finger id, if there is no fingers available no
|
|
||||||
* changes will be made. Updates the coordinates if the finger id it's already set. If the touch
|
|
||||||
* ends delays the output by one frame to set the end_touch flag before finally freeing the
|
|
||||||
* finger id
|
|
||||||
*/
|
|
||||||
size_t UpdateTouchInputEvent(const std::tuple<float, float, bool>& touch_input,
|
|
||||||
size_t finger_id);
|
|
||||||
|
|
||||||
// Returns the average distance, angle and middle point of the active fingers
|
// Returns the average distance, angle and middle point of the active fingers
|
||||||
GestureProperties GetGestureProperties();
|
GestureProperties GetGestureProperties();
|
||||||
|
|
||||||
SharedMemory shared_memory{};
|
// This is nn::hid::detail::GestureLifo
|
||||||
std::unique_ptr<Input::TouchDevice> touch_mouse_device;
|
Lifo<GestureState> gesture_lifo{};
|
||||||
std::unique_ptr<Input::TouchDevice> touch_udp_device;
|
static_assert(sizeof(gesture_lifo) == 0x708, "gesture_lifo is an invalid size");
|
||||||
std::unique_ptr<Input::TouchDevice> touch_btn_device;
|
GestureState next_state{};
|
||||||
std::array<size_t, MAX_FINGERS> mouse_finger_id{};
|
|
||||||
std::array<size_t, MAX_FINGERS> keyboard_finger_id{};
|
|
||||||
std::array<size_t, MAX_FINGERS> udp_finger_id{};
|
|
||||||
std::array<Finger, MAX_POINTS> fingers{};
|
std::array<Finger, MAX_POINTS> fingers{};
|
||||||
|
Core::HID::EmulatedConsole* console;
|
||||||
|
|
||||||
GestureProperties last_gesture{};
|
GestureProperties last_gesture{};
|
||||||
s64_le last_update_timestamp{};
|
s64_le last_update_timestamp{};
|
||||||
s64_le last_tap_timestamp{};
|
s64_le last_tap_timestamp{};
|
||||||
|
|
|
@ -7,72 +7,79 @@
|
||||||
#include "common/common_types.h"
|
#include "common/common_types.h"
|
||||||
#include "common/logging/log.h"
|
#include "common/logging/log.h"
|
||||||
#include "common/settings.h"
|
#include "common/settings.h"
|
||||||
|
#include "core/core.h"
|
||||||
#include "core/core_timing.h"
|
#include "core/core_timing.h"
|
||||||
#include "core/frontend/emu_window.h"
|
#include "core/frontend/emu_window.h"
|
||||||
#include "core/frontend/input.h"
|
|
||||||
#include "core/hle/service/hid/controllers/touchscreen.h"
|
#include "core/hle/service/hid/controllers/touchscreen.h"
|
||||||
|
|
||||||
namespace Service::HID {
|
namespace Service::HID {
|
||||||
constexpr std::size_t SHARED_MEMORY_OFFSET = 0x400;
|
constexpr std::size_t SHARED_MEMORY_OFFSET = 0x400;
|
||||||
|
|
||||||
Controller_Touchscreen::Controller_Touchscreen(Core::System& system_) : ControllerBase{system_} {}
|
Controller_Touchscreen::Controller_Touchscreen(Core::System& system_) : ControllerBase{system_} {
|
||||||
|
console = system.HIDCore().GetEmulatedConsole();
|
||||||
|
}
|
||||||
|
|
||||||
Controller_Touchscreen::~Controller_Touchscreen() = default;
|
Controller_Touchscreen::~Controller_Touchscreen() = default;
|
||||||
|
|
||||||
void Controller_Touchscreen::OnInit() {
|
void Controller_Touchscreen::OnInit() {}
|
||||||
for (std::size_t id = 0; id < MAX_FINGERS; ++id) {
|
|
||||||
mouse_finger_id[id] = MAX_FINGERS;
|
|
||||||
keyboard_finger_id[id] = MAX_FINGERS;
|
|
||||||
udp_finger_id[id] = MAX_FINGERS;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void Controller_Touchscreen::OnRelease() {}
|
void Controller_Touchscreen::OnRelease() {}
|
||||||
|
|
||||||
void Controller_Touchscreen::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8* data,
|
void Controller_Touchscreen::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8* data,
|
||||||
std::size_t size) {
|
std::size_t size) {
|
||||||
shared_memory.header.timestamp = core_timing.GetCPUTicks();
|
touch_screen_lifo.timestamp = core_timing.GetCPUTicks();
|
||||||
shared_memory.header.total_entry_count = 17;
|
|
||||||
|
|
||||||
if (!IsControllerActivated()) {
|
if (!IsControllerActivated()) {
|
||||||
shared_memory.header.entry_count = 0;
|
touch_screen_lifo.entry_count = 0;
|
||||||
shared_memory.header.last_entry_index = 0;
|
touch_screen_lifo.last_entry_index = 0;
|
||||||
|
std::memcpy(data, &touch_screen_lifo, sizeof(touch_screen_lifo));
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
shared_memory.header.entry_count = 16;
|
|
||||||
|
|
||||||
const auto& last_entry =
|
const auto touch_status = console->GetTouch();
|
||||||
shared_memory.shared_memory_entries[shared_memory.header.last_entry_index];
|
for (std::size_t id = 0; id < MAX_FINGERS; id++) {
|
||||||
shared_memory.header.last_entry_index = (shared_memory.header.last_entry_index + 1) % 17;
|
const auto& current_touch = touch_status[id];
|
||||||
auto& cur_entry = shared_memory.shared_memory_entries[shared_memory.header.last_entry_index];
|
auto& finger = fingers[id];
|
||||||
|
finger.position = current_touch.position;
|
||||||
|
finger.id = current_touch.id;
|
||||||
|
|
||||||
cur_entry.sampling_number = last_entry.sampling_number + 1;
|
if (finger.attribute.start_touch) {
|
||||||
cur_entry.sampling_number2 = cur_entry.sampling_number;
|
finger.attribute.raw = 0;
|
||||||
|
continue;
|
||||||
const Input::TouchStatus& mouse_status = touch_mouse_device->GetStatus();
|
|
||||||
const Input::TouchStatus& udp_status = touch_udp_device->GetStatus();
|
|
||||||
for (std::size_t id = 0; id < mouse_status.size(); ++id) {
|
|
||||||
mouse_finger_id[id] = UpdateTouchInputEvent(mouse_status[id], mouse_finger_id[id]);
|
|
||||||
udp_finger_id[id] = UpdateTouchInputEvent(udp_status[id], udp_finger_id[id]);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
if (Settings::values.use_touch_from_button) {
|
if (finger.attribute.end_touch) {
|
||||||
const Input::TouchStatus& keyboard_status = touch_btn_device->GetStatus();
|
finger.attribute.raw = 0;
|
||||||
for (std::size_t id = 0; id < mouse_status.size(); ++id) {
|
finger.pressed = false;
|
||||||
keyboard_finger_id[id] =
|
continue;
|
||||||
UpdateTouchInputEvent(keyboard_status[id], keyboard_finger_id[id]);
|
}
|
||||||
|
|
||||||
|
if (!finger.pressed && current_touch.pressed) {
|
||||||
|
finger.attribute.start_touch.Assign(1);
|
||||||
|
finger.pressed = true;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (finger.pressed && !current_touch.pressed) {
|
||||||
|
finger.attribute.raw = 0;
|
||||||
|
finger.attribute.end_touch.Assign(1);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
std::array<Finger, 16> active_fingers;
|
std::array<Finger, MAX_FINGERS> active_fingers;
|
||||||
const auto end_iter = std::copy_if(fingers.begin(), fingers.end(), active_fingers.begin(),
|
const auto end_iter = std::copy_if(fingers.begin(), fingers.end(), active_fingers.begin(),
|
||||||
[](const auto& finger) { return finger.pressed; });
|
[](const auto& finger) { return finger.pressed; });
|
||||||
const auto active_fingers_count =
|
const auto active_fingers_count =
|
||||||
static_cast<std::size_t>(std::distance(active_fingers.begin(), end_iter));
|
static_cast<std::size_t>(std::distance(active_fingers.begin(), end_iter));
|
||||||
|
|
||||||
const u64 tick = core_timing.GetCPUTicks();
|
const u64 tick = core_timing.GetCPUTicks();
|
||||||
cur_entry.entry_count = static_cast<s32_le>(active_fingers_count);
|
const auto& last_entry = touch_screen_lifo.ReadCurrentEntry().state;
|
||||||
|
|
||||||
|
next_state.sampling_number = last_entry.sampling_number + 1;
|
||||||
|
next_state.entry_count = static_cast<s32_le>(active_fingers_count);
|
||||||
|
|
||||||
for (std::size_t id = 0; id < MAX_FINGERS; ++id) {
|
for (std::size_t id = 0; id < MAX_FINGERS; ++id) {
|
||||||
auto& touch_entry = cur_entry.states[id];
|
auto& touch_entry = next_state.states[id];
|
||||||
if (id < active_fingers_count) {
|
if (id < active_fingers_count) {
|
||||||
const auto& [active_x, active_y] = active_fingers[id].position;
|
const auto& [active_x, active_y] = active_fingers[id].position;
|
||||||
touch_entry.position = {
|
touch_entry.position = {
|
||||||
|
@ -97,66 +104,9 @@ void Controller_Touchscreen::OnUpdate(const Core::Timing::CoreTiming& core_timin
|
||||||
touch_entry.finger = 0;
|
touch_entry.finger = 0;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
std::memcpy(data + SHARED_MEMORY_OFFSET, &shared_memory, sizeof(TouchScreenSharedMemory));
|
|
||||||
}
|
|
||||||
|
|
||||||
void Controller_Touchscreen::OnLoadInputDevices() {
|
touch_screen_lifo.WriteNextEntry(next_state);
|
||||||
touch_mouse_device = Input::CreateDevice<Input::TouchDevice>("engine:emu_window");
|
std::memcpy(data + SHARED_MEMORY_OFFSET, &touch_screen_lifo, sizeof(touch_screen_lifo));
|
||||||
touch_udp_device = Input::CreateDevice<Input::TouchDevice>("engine:cemuhookudp");
|
|
||||||
touch_btn_device = Input::CreateDevice<Input::TouchDevice>("engine:touch_from_button");
|
|
||||||
}
|
|
||||||
|
|
||||||
std::optional<std::size_t> Controller_Touchscreen::GetUnusedFingerID() const {
|
|
||||||
// Dont assign any touch input to a finger if disabled
|
|
||||||
if (!Settings::values.touchscreen.enabled) {
|
|
||||||
return std::nullopt;
|
|
||||||
}
|
|
||||||
std::size_t first_free_id = 0;
|
|
||||||
while (first_free_id < MAX_FINGERS) {
|
|
||||||
if (!fingers[first_free_id].pressed) {
|
|
||||||
return first_free_id;
|
|
||||||
} else {
|
|
||||||
first_free_id++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return std::nullopt;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::size_t Controller_Touchscreen::UpdateTouchInputEvent(
|
|
||||||
const std::tuple<float, float, bool>& touch_input, std::size_t finger_id) {
|
|
||||||
const auto& [x, y, pressed] = touch_input;
|
|
||||||
if (finger_id > MAX_FINGERS) {
|
|
||||||
LOG_ERROR(Service_HID, "Invalid finger id {}", finger_id);
|
|
||||||
return MAX_FINGERS;
|
|
||||||
}
|
|
||||||
if (pressed) {
|
|
||||||
Attributes attribute{};
|
|
||||||
if (finger_id == MAX_FINGERS) {
|
|
||||||
const auto first_free_id = GetUnusedFingerID();
|
|
||||||
if (!first_free_id) {
|
|
||||||
// Invalid finger id do nothing
|
|
||||||
return MAX_FINGERS;
|
|
||||||
}
|
|
||||||
finger_id = first_free_id.value();
|
|
||||||
fingers[finger_id].pressed = true;
|
|
||||||
fingers[finger_id].id = static_cast<u32_le>(finger_id);
|
|
||||||
attribute.start_touch.Assign(1);
|
|
||||||
}
|
|
||||||
fingers[finger_id].position = {x, y};
|
|
||||||
fingers[finger_id].attribute = attribute;
|
|
||||||
return finger_id;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (finger_id != MAX_FINGERS) {
|
|
||||||
if (!fingers[finger_id].attribute.end_touch) {
|
|
||||||
fingers[finger_id].attribute.end_touch.Assign(1);
|
|
||||||
fingers[finger_id].attribute.start_touch.Assign(0);
|
|
||||||
return finger_id;
|
|
||||||
}
|
|
||||||
fingers[finger_id].pressed = false;
|
|
||||||
}
|
|
||||||
|
|
||||||
return MAX_FINGERS;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
} // namespace Service::HID
|
} // namespace Service::HID
|
||||||
|
|
|
@ -9,18 +9,22 @@
|
||||||
#include "common/common_types.h"
|
#include "common/common_types.h"
|
||||||
#include "common/point.h"
|
#include "common/point.h"
|
||||||
#include "common/swap.h"
|
#include "common/swap.h"
|
||||||
#include "core/frontend/input.h"
|
#include "core/hid/hid_core.h"
|
||||||
|
#include "core/hid/hid_types.h"
|
||||||
#include "core/hle/service/hid/controllers/controller_base.h"
|
#include "core/hle/service/hid/controllers/controller_base.h"
|
||||||
|
#include "core/hle/service/hid/ring_lifo.h"
|
||||||
|
|
||||||
namespace Service::HID {
|
namespace Service::HID {
|
||||||
class Controller_Touchscreen final : public ControllerBase {
|
class Controller_Touchscreen final : public ControllerBase {
|
||||||
public:
|
public:
|
||||||
|
// This is nn::hid::TouchScreenModeForNx
|
||||||
enum class TouchScreenModeForNx : u8 {
|
enum class TouchScreenModeForNx : u8 {
|
||||||
UseSystemSetting,
|
UseSystemSetting,
|
||||||
Finger,
|
Finger,
|
||||||
Heat2,
|
Heat2,
|
||||||
};
|
};
|
||||||
|
|
||||||
|
// This is nn::hid::TouchScreenConfigurationForNx
|
||||||
struct TouchScreenConfigurationForNx {
|
struct TouchScreenConfigurationForNx {
|
||||||
TouchScreenModeForNx mode;
|
TouchScreenModeForNx mode;
|
||||||
INSERT_PADDING_BYTES_NOINIT(0x7);
|
INSERT_PADDING_BYTES_NOINIT(0x7);
|
||||||
|
@ -41,73 +45,32 @@ public:
|
||||||
// When the controller is requesting an update for the shared memory
|
// When the controller is requesting an update for the shared memory
|
||||||
void OnUpdate(const Core::Timing::CoreTiming& core_timing, u8* data, std::size_t size) override;
|
void OnUpdate(const Core::Timing::CoreTiming& core_timing, u8* data, std::size_t size) override;
|
||||||
|
|
||||||
// Called when input devices should be loaded
|
|
||||||
void OnLoadInputDevices() override;
|
|
||||||
|
|
||||||
private:
|
private:
|
||||||
static constexpr std::size_t MAX_FINGERS = 16;
|
static constexpr std::size_t MAX_FINGERS = 16;
|
||||||
|
|
||||||
// Returns an unused finger id, if there is no fingers available std::nullopt will be returned
|
// This is nn::hid::TouchScreenState
|
||||||
std::optional<std::size_t> GetUnusedFingerID() const;
|
struct TouchScreenState {
|
||||||
|
|
||||||
// If the touch is new it tries to assing a new finger id, if there is no fingers avaliable no
|
|
||||||
// changes will be made. Updates the coordinates if the finger id it's already set. If the touch
|
|
||||||
// ends delays the output by one frame to set the end_touch flag before finally freeing the
|
|
||||||
// finger id
|
|
||||||
std::size_t UpdateTouchInputEvent(const std::tuple<float, float, bool>& touch_input,
|
|
||||||
std::size_t finger_id);
|
|
||||||
|
|
||||||
struct Attributes {
|
|
||||||
union {
|
|
||||||
u32 raw{};
|
|
||||||
BitField<0, 1, u32> start_touch;
|
|
||||||
BitField<1, 1, u32> end_touch;
|
|
||||||
};
|
|
||||||
};
|
|
||||||
static_assert(sizeof(Attributes) == 0x4, "Attributes is an invalid size");
|
|
||||||
|
|
||||||
struct TouchState {
|
|
||||||
u64_le delta_time;
|
|
||||||
Attributes attribute;
|
|
||||||
u32_le finger;
|
|
||||||
Common::Point<u32_le> position;
|
|
||||||
u32_le diameter_x;
|
|
||||||
u32_le diameter_y;
|
|
||||||
u32_le rotation_angle;
|
|
||||||
};
|
|
||||||
static_assert(sizeof(TouchState) == 0x28, "Touchstate is an invalid size");
|
|
||||||
|
|
||||||
struct TouchScreenEntry {
|
|
||||||
s64_le sampling_number;
|
s64_le sampling_number;
|
||||||
s64_le sampling_number2;
|
|
||||||
s32_le entry_count;
|
s32_le entry_count;
|
||||||
std::array<TouchState, MAX_FINGERS> states;
|
INSERT_PADDING_BYTES(4); // Reserved
|
||||||
|
std::array<Core::HID::TouchState, MAX_FINGERS> states;
|
||||||
};
|
};
|
||||||
static_assert(sizeof(TouchScreenEntry) == 0x298, "TouchScreenEntry is an invalid size");
|
static_assert(sizeof(TouchScreenState) == 0x290, "TouchScreenState is an invalid size");
|
||||||
|
|
||||||
struct TouchScreenSharedMemory {
|
|
||||||
CommonHeader header;
|
|
||||||
std::array<TouchScreenEntry, 17> shared_memory_entries{};
|
|
||||||
INSERT_PADDING_BYTES(0x3c8);
|
|
||||||
};
|
|
||||||
static_assert(sizeof(TouchScreenSharedMemory) == 0x3000,
|
|
||||||
"TouchScreenSharedMemory is an invalid size");
|
|
||||||
|
|
||||||
struct Finger {
|
struct Finger {
|
||||||
u64_le last_touch{};
|
u64_le last_touch{};
|
||||||
Common::Point<float> position;
|
Common::Point<float> position;
|
||||||
u32_le id{};
|
u32_le id{};
|
||||||
bool pressed{};
|
bool pressed{};
|
||||||
Attributes attribute;
|
Core::HID::TouchAttribute attribute;
|
||||||
};
|
};
|
||||||
|
|
||||||
TouchScreenSharedMemory shared_memory{};
|
// This is nn::hid::detail::TouchScreenLifo
|
||||||
std::unique_ptr<Input::TouchDevice> touch_mouse_device;
|
Lifo<TouchScreenState> touch_screen_lifo{};
|
||||||
std::unique_ptr<Input::TouchDevice> touch_udp_device;
|
static_assert(sizeof(touch_screen_lifo) == 0x2C38, "touch_screen_lifo is an invalid size");
|
||||||
std::unique_ptr<Input::TouchDevice> touch_btn_device;
|
TouchScreenState next_state{};
|
||||||
std::array<std::size_t, MAX_FINGERS> mouse_finger_id;
|
|
||||||
std::array<std::size_t, MAX_FINGERS> keyboard_finger_id;
|
|
||||||
std::array<std::size_t, MAX_FINGERS> udp_finger_id;
|
|
||||||
std::array<Finger, MAX_FINGERS> fingers;
|
std::array<Finger, MAX_FINGERS> fingers;
|
||||||
|
Core::HID::EmulatedConsole* console;
|
||||||
};
|
};
|
||||||
} // namespace Service::HID
|
} // namespace Service::HID
|
||||||
|
|
Loading…
Reference in a new issue