summaryrefslogtreecommitdiffstats
path: root/src/core
diff options
context:
space:
mode:
Diffstat (limited to 'src/core')
-rw-r--r--src/core/hid/emulated_console.cpp57
-rw-r--r--src/core/hid/emulated_console.h3
-rw-r--r--src/core/hid/emulated_controller.cpp4
-rw-r--r--src/core/hle/service/hid/controllers/gesture.cpp124
-rw-r--r--src/core/hle/service/hid/controllers/gesture.h29
5 files changed, 129 insertions, 88 deletions
diff --git a/src/core/hid/emulated_console.cpp b/src/core/hid/emulated_console.cpp
index 7f7c8fd59..e82cf5990 100644
--- a/src/core/hid/emulated_console.cpp
+++ b/src/core/hid/emulated_console.cpp
@@ -20,27 +20,21 @@ void EmulatedConsole::ReloadFromSettings() {
ReloadInput();
}
-void EmulatedConsole::ReloadInput() {
- motion_devices = Input::CreateDevice<Input::InputDevice>(motion_params);
- if (motion_devices) {
- Input::InputCallback motion_callback{
- [this](Input::CallbackStatus callback) { SetMotion(callback); }};
- motion_devices->SetCallback(motion_callback);
- }
-
- // TODO: Fix this mess
+void EmulatedConsole::SetTouchParams() {
+ // TODO(german77): Support any number of fingers
std::size_t index = 0;
- const std::string mouse_device_string =
- fmt::format("engine:mouse,axis_x:10,axis_y:11,button:{}", index);
- touch_devices[index] = Input::CreateDeviceFromString<Input::InputDevice>(mouse_device_string);
- Input::InputCallback trigger_callbackk{
- [this, index](Input::CallbackStatus callback) { SetTouch(callback, index); }};
- touch_devices[index]->SetCallback(trigger_callbackk);
-
- index++;
+
+ // Hardcode mouse, touchscreen and cemuhook parameters
+ touch_params[index++] = Common::ParamPackage{"engine:mouse,axis_x:10,axis_y:11,button:0"};
+ touch_params[index++] = Common::ParamPackage{"engine:touch,axis_x:0,axis_y:1,button:0"};
+ touch_params[index++] = Common::ParamPackage{"engine:touch,axis_x:2,axis_y:3,button:1"};
+ touch_params[index++] = Common::ParamPackage{"engine:cemuhookudp,axis_x:0,axis_y:1,button:0"};
+ touch_params[index++] = Common::ParamPackage{"engine:cemuhookudp,axis_x:2,axis_y:3,button:1"};
+
const auto button_index =
static_cast<u64>(Settings::values.touch_from_button_map_index.GetValue());
const auto& touch_buttons = Settings::values.touch_from_button_maps[button_index].buttons;
+
for (const auto& config_entry : touch_buttons) {
Common::ParamPackage params{config_entry};
Common::ParamPackage touch_button_params;
@@ -53,15 +47,32 @@ void EmulatedConsole::ReloadInput() {
touch_button_params.Set("x", x);
touch_button_params.Set("y", y);
touch_button_params.Set("touch_id", static_cast<int>(index));
- touch_devices[index] =
- Input::CreateDeviceFromString<Input::InputDevice>(touch_button_params.Serialize());
- if (!touch_devices[index]) {
- continue;
+ touch_params[index] = touch_button_params;
+ index++;
+ if (index >= touch_params.size()) {
+ return;
}
+ }
+}
- Input::InputCallback trigger_callback{
+void EmulatedConsole::ReloadInput() {
+ SetTouchParams();
+ motion_devices = Input::CreateDevice<Input::InputDevice>(motion_params);
+ if (motion_devices) {
+ Input::InputCallback motion_callback{
+ [this](Input::CallbackStatus callback) { SetMotion(callback); }};
+ motion_devices->SetCallback(motion_callback);
+ }
+
+ std::size_t index = 0;
+ for (auto& touch_device : touch_devices) {
+ touch_device = Input::CreateDevice<Input::InputDevice>(touch_params[index]);
+ if (!touch_device) {
+ continue;
+ }
+ Input::InputCallback touch_callback{
[this, index](Input::CallbackStatus callback) { SetTouch(callback, index); }};
- touch_devices[index]->SetCallback(trigger_callback);
+ touch_device->SetCallback(touch_callback);
index++;
}
}
diff --git a/src/core/hid/emulated_console.h b/src/core/hid/emulated_console.h
index 7d6cf9506..c48d25794 100644
--- a/src/core/hid/emulated_console.h
+++ b/src/core/hid/emulated_console.h
@@ -144,6 +144,9 @@ public:
void DeleteCallback(int key);
private:
+ /// Creates and stores the touch params
+ void SetTouchParams();
+
/**
* Updates the motion status of the console
* @param A CallbackStatus containing gyro and accelerometer data
diff --git a/src/core/hid/emulated_controller.cpp b/src/core/hid/emulated_controller.cpp
index 662260327..1ff3022c5 100644
--- a/src/core/hid/emulated_controller.cpp
+++ b/src/core/hid/emulated_controller.cpp
@@ -705,7 +705,6 @@ void EmulatedController::Connect() {
}
is_connected = true;
}
- LOG_ERROR(Service_HID, "Connected controller {}", NpadIdTypeToIndex(npad_id_type));
TriggerOnChange(ControllerTriggerType::Connected, true);
}
@@ -714,8 +713,6 @@ void EmulatedController::Disconnect() {
std::lock_guard lock{mutex};
if (is_configuring) {
temporary_is_connected = false;
- LOG_ERROR(Service_HID, "Disconnected temporal controller {}",
- NpadIdTypeToIndex(npad_id_type));
TriggerOnChange(ControllerTriggerType::Disconnected, false);
return;
}
@@ -725,7 +722,6 @@ void EmulatedController::Disconnect() {
}
is_connected = false;
}
- LOG_ERROR(Service_HID, "Disconnected controller {}", NpadIdTypeToIndex(npad_id_type));
TriggerOnChange(ControllerTriggerType::Disconnected, true);
}
diff --git a/src/core/hle/service/hid/controllers/gesture.cpp b/src/core/hle/service/hid/controllers/gesture.cpp
index 2f98cc54b..a26ce5383 100644
--- a/src/core/hle/service/hid/controllers/gesture.cpp
+++ b/src/core/hle/service/hid/controllers/gesture.cpp
@@ -28,12 +28,10 @@ constexpr f32 Square(s32 num) {
Controller_Gesture::Controller_Gesture(Core::System& system_) : ControllerBase(system_) {
console = system.HIDCore().GetEmulatedConsole();
}
-
Controller_Gesture::~Controller_Gesture() = default;
void Controller_Gesture::OnInit() {
- gesture_lifo.entry_count = 0;
- gesture_lifo.last_entry_index = 0;
+ shared_memory.header.entry_count = 0;
force_update = true;
}
@@ -41,27 +39,27 @@ void Controller_Gesture::OnRelease() {}
void Controller_Gesture::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8* data,
std::size_t size) {
- // TODO FIND WTF IS WRONG HERE!!!!!!!!
- return;
+ shared_memory.header.timestamp = core_timing.GetCPUTicks();
+ shared_memory.header.total_entry_count = 17;
+
if (!IsControllerActivated()) {
- gesture_lifo.entry_count = 0;
- gesture_lifo.last_entry_index = 0;
- std::memcpy(data, &gesture_lifo, sizeof(gesture_lifo));
+ shared_memory.header.entry_count = 0;
+ shared_memory.header.last_entry_index = 0;
return;
}
ReadTouchInput();
GestureProperties gesture = GetGestureProperties();
- f32 time_difference =
- static_cast<f32>(gesture_lifo.timestamp - last_update_timestamp) / (1000 * 1000 * 1000);
+ f32 time_difference = static_cast<f32>(shared_memory.header.timestamp - last_update_timestamp) /
+ (1000 * 1000 * 1000);
// Only update if necesary
if (!ShouldUpdateGesture(gesture, time_difference)) {
return;
}
- last_update_timestamp = gesture_lifo.timestamp;
+ last_update_timestamp = shared_memory.header.timestamp;
UpdateGestureSharedMemory(data, size, gesture, time_difference);
}
@@ -77,7 +75,7 @@ void Controller_Gesture::ReadTouchInput() {
bool Controller_Gesture::ShouldUpdateGesture(const GestureProperties& gesture,
f32 time_difference) {
- const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
+ const auto& last_entry = shared_memory.gesture_states[shared_memory.header.last_entry_index];
if (force_update) {
force_update = false;
return true;
@@ -105,16 +103,24 @@ void Controller_Gesture::UpdateGestureSharedMemory(u8* data, std::size_t size,
GestureType type = GestureType::Idle;
GestureAttribute attributes{};
- const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
+ const auto& last_entry = shared_memory.gesture_states[shared_memory.header.last_entry_index];
+ 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) {
+ shared_memory.header.entry_count++;
+ }
+
+ cur_entry.sampling_number = last_entry.sampling_number + 1;
+ cur_entry.sampling_number2 = cur_entry.sampling_number;
- // Reset next state to default
- next_state.sampling_number = last_entry.sampling_number + 1;
- next_state.delta = {};
- next_state.vel_x = 0;
- next_state.vel_y = 0;
- next_state.direction = GestureDirection::None;
- next_state.rotation_angle = 0;
- next_state.scale = 0;
+ // Reset values to default
+ cur_entry.delta = {};
+ cur_entry.vel_x = 0;
+ cur_entry.vel_y = 0;
+ cur_entry.direction = GestureDirection::None;
+ cur_entry.rotation_angle = 0;
+ cur_entry.scale = 0;
if (gesture.active_points > 0) {
if (last_gesture.active_points == 0) {
@@ -127,21 +133,20 @@ void Controller_Gesture::UpdateGestureSharedMemory(u8* data, std::size_t size,
}
// Apply attributes
- next_state.detection_count = gesture.detection_count;
- next_state.type = type;
- next_state.attributes = attributes;
- next_state.pos = gesture.mid_point;
- next_state.point_count = static_cast<s32>(gesture.active_points);
- next_state.points = gesture.points;
+ cur_entry.detection_count = gesture.detection_count;
+ cur_entry.type = type;
+ cur_entry.attributes = attributes;
+ cur_entry.pos = gesture.mid_point;
+ cur_entry.point_count = static_cast<s32>(gesture.active_points);
+ cur_entry.points = gesture.points;
last_gesture = gesture;
- gesture_lifo.WriteNextEntry(next_state);
- std::memcpy(data + SHARED_MEMORY_OFFSET, &gesture_lifo, sizeof(gesture_lifo));
+ std::memcpy(data + SHARED_MEMORY_OFFSET, &shared_memory, sizeof(SharedMemory));
}
void Controller_Gesture::NewGesture(GestureProperties& gesture, GestureType& type,
GestureAttribute& attributes) {
- const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
+ const auto& last_entry = GetLastGestureEntry();
gesture.detection_count++;
type = GestureType::Touch;
@@ -155,7 +160,7 @@ void Controller_Gesture::NewGesture(GestureProperties& gesture, GestureType& typ
void Controller_Gesture::UpdateExistingGesture(GestureProperties& gesture, GestureType& type,
f32 time_difference) {
- const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
+ const auto& last_entry = GetLastGestureEntry();
// Promote to pan type if touch moved
for (size_t id = 0; id < MAX_POINTS; id++) {
@@ -190,7 +195,7 @@ void Controller_Gesture::UpdateExistingGesture(GestureProperties& gesture, Gestu
void Controller_Gesture::EndGesture(GestureProperties& gesture,
GestureProperties& last_gesture_props, GestureType& type,
GestureAttribute& attributes, f32 time_difference) {
- const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
+ const auto& last_entry = GetLastGestureEntry();
if (last_gesture_props.active_points != 0) {
switch (last_entry.type) {
@@ -240,18 +245,19 @@ void Controller_Gesture::SetTapEvent(GestureProperties& gesture,
void Controller_Gesture::UpdatePanEvent(GestureProperties& gesture,
GestureProperties& last_gesture_props, GestureType& type,
f32 time_difference) {
- const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
+ auto& cur_entry = shared_memory.gesture_states[shared_memory.header.last_entry_index];
+ const auto& last_entry = GetLastGestureEntry();
- next_state.delta = gesture.mid_point - last_entry.pos;
- next_state.vel_x = static_cast<f32>(next_state.delta.x) / time_difference;
- next_state.vel_y = static_cast<f32>(next_state.delta.y) / time_difference;
+ cur_entry.delta = gesture.mid_point - last_entry.pos;
+ cur_entry.vel_x = static_cast<f32>(cur_entry.delta.x) / time_difference;
+ cur_entry.vel_y = static_cast<f32>(cur_entry.delta.y) / time_difference;
last_pan_time_difference = time_difference;
// Promote to pinch type
if (std::abs(gesture.average_distance - last_gesture_props.average_distance) >
pinch_threshold) {
type = GestureType::Pinch;
- next_state.scale = gesture.average_distance / last_gesture_props.average_distance;
+ cur_entry.scale = gesture.average_distance / last_gesture_props.average_distance;
}
const f32 angle_between_two_lines = std::atan((gesture.angle - last_gesture_props.angle) /
@@ -259,21 +265,22 @@ void Controller_Gesture::UpdatePanEvent(GestureProperties& gesture,
// Promote to rotate type
if (std::abs(angle_between_two_lines) > angle_threshold) {
type = GestureType::Rotate;
- next_state.scale = 0;
- next_state.rotation_angle = angle_between_two_lines * 180.0f / Common::PI;
+ cur_entry.scale = 0;
+ cur_entry.rotation_angle = angle_between_two_lines * 180.0f / Common::PI;
}
}
void Controller_Gesture::EndPanEvent(GestureProperties& gesture,
GestureProperties& last_gesture_props, GestureType& type,
f32 time_difference) {
- const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
- next_state.vel_x =
+ auto& cur_entry = shared_memory.gesture_states[shared_memory.header.last_entry_index];
+ const auto& last_entry = GetLastGestureEntry();
+ cur_entry.vel_x =
static_cast<f32>(last_entry.delta.x) / (last_pan_time_difference + time_difference);
- next_state.vel_y =
+ cur_entry.vel_y =
static_cast<f32>(last_entry.delta.y) / (last_pan_time_difference + time_difference);
const f32 curr_vel =
- std::sqrt((next_state.vel_x * next_state.vel_x) + (next_state.vel_y * next_state.vel_y));
+ std::sqrt((cur_entry.vel_x * cur_entry.vel_x) + (cur_entry.vel_y * cur_entry.vel_y));
// Set swipe event with parameters
if (curr_vel > swipe_threshold) {
@@ -283,33 +290,42 @@ void Controller_Gesture::EndPanEvent(GestureProperties& gesture,
// End panning without swipe
type = GestureType::Complete;
- next_state.vel_x = 0;
- next_state.vel_y = 0;
+ cur_entry.vel_x = 0;
+ cur_entry.vel_y = 0;
force_update = true;
}
void Controller_Gesture::SetSwipeEvent(GestureProperties& gesture,
GestureProperties& last_gesture_props, GestureType& type) {
- const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
+ auto& cur_entry = shared_memory.gesture_states[shared_memory.header.last_entry_index];
+ const auto& last_entry = GetLastGestureEntry();
type = GestureType::Swipe;
gesture = last_gesture_props;
force_update = true;
- next_state.delta = last_entry.delta;
+ cur_entry.delta = last_entry.delta;
- if (std::abs(next_state.delta.x) > std::abs(next_state.delta.y)) {
- if (next_state.delta.x > 0) {
- next_state.direction = GestureDirection::Right;
+ if (std::abs(cur_entry.delta.x) > std::abs(cur_entry.delta.y)) {
+ if (cur_entry.delta.x > 0) {
+ cur_entry.direction = GestureDirection::Right;
return;
}
- next_state.direction = GestureDirection::Left;
+ cur_entry.direction = GestureDirection::Left;
return;
}
- if (next_state.delta.y > 0) {
- next_state.direction = GestureDirection::Down;
+ if (cur_entry.delta.y > 0) {
+ cur_entry.direction = GestureDirection::Down;
return;
}
- next_state.direction = GestureDirection::Up;
+ cur_entry.direction = GestureDirection::Up;
+}
+
+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];
}
Controller_Gesture::GestureProperties Controller_Gesture::GetGestureProperties() {
diff --git a/src/core/hle/service/hid/controllers/gesture.h b/src/core/hle/service/hid/controllers/gesture.h
index 8e6f315a4..6128fb0ad 100644
--- a/src/core/hle/service/hid/controllers/gesture.h
+++ b/src/core/hle/service/hid/controllers/gesture.h
@@ -71,6 +71,7 @@ private:
// This is nn::hid::GestureState
struct GestureState {
s64_le sampling_number;
+ s64_le sampling_number2;
s64_le detection_count;
GestureType type;
GestureDirection direction;
@@ -84,7 +85,21 @@ private:
s32_le point_count;
std::array<Common::Point<s32_le>, 4> points;
};
- static_assert(sizeof(GestureState) == 0x60, "GestureState is an invalid size");
+ static_assert(sizeof(GestureState) == 0x68, "GestureState is an invalid size");
+
+ struct CommonHeader {
+ s64_le timestamp;
+ s64_le total_entry_count;
+ s64_le last_entry_index;
+ s64_le entry_count;
+ };
+ static_assert(sizeof(CommonHeader) == 0x20, "CommonHeader 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 {
Common::Point<f32> pos{};
@@ -137,17 +152,17 @@ private:
void SetSwipeEvent(GestureProperties& gesture, GestureProperties& last_gesture_props,
GestureType& type);
+ // Retrieves the last gesture entry, as indicated by shared memory indices.
+ [[nodiscard]] GestureState& GetLastGestureEntry();
+ [[nodiscard]] const GestureState& GetLastGestureEntry() const;
+
// Returns the average distance, angle and middle point of the active fingers
GestureProperties GetGestureProperties();
- // This is nn::hid::detail::GestureLifo
- Lifo<GestureState> gesture_lifo{};
- static_assert(sizeof(gesture_lifo) == 0x708, "gesture_lifo is an invalid size");
- GestureState next_state{};
-
- std::array<Finger, MAX_POINTS> fingers{};
+ SharedMemory shared_memory{};
Core::HID::EmulatedConsole* console;
+ std::array<Finger, MAX_POINTS> fingers{};
GestureProperties last_gesture{};
s64_le last_update_timestamp{};
s64_le last_tap_timestamp{};
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-23 14:13:26 +0100