summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/core/hle/service/hid/controllers/gesture.cpp274
-rw-r--r--src/core/hle/service/hid/controllers/gesture.h80
-rw-r--r--src/core/hle/service/hid/controllers/touchscreen.cpp136
-rw-r--r--src/core/hle/service/hid/controllers/touchscreen.h71
4 files changed, 191 insertions, 370 deletions
diff --git a/src/core/hle/service/hid/controllers/gesture.cpp b/src/core/hle/service/hid/controllers/gesture.cpp
index 764abb5b6..2f98cc54b 100644
--- a/src/core/hle/service/hid/controllers/gesture.cpp
+++ b/src/core/hle/service/hid/controllers/gesture.cpp
@@ -5,8 +5,10 @@
#include "common/logging/log.h"
#include "common/math_util.h"
#include "common/settings.h"
+#include "core/core.h"
#include "core/core_timing.h"
#include "core/frontend/emu_window.h"
+#include "core/hid/hid_core.h"
#include "core/hle/service/hid/controllers/gesture.h"
namespace Service::HID {
@@ -23,16 +25,15 @@ constexpr f32 Square(s32 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;
void Controller_Gesture::OnInit() {
- for (std::size_t id = 0; id < MAX_FINGERS; ++id) {
- mouse_finger_id[id] = MAX_POINTS;
- keyboard_finger_id[id] = MAX_POINTS;
- udp_finger_id[id] = MAX_POINTS;
- }
- shared_memory.header.entry_count = 0;
+ gesture_lifo.entry_count = 0;
+ gesture_lifo.last_entry_index = 0;
force_update = true;
}
@@ -40,50 +41,43 @@ void Controller_Gesture::OnRelease() {}
void Controller_Gesture::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8* data,
std::size_t size) {
- shared_memory.header.timestamp = core_timing.GetCPUTicks();
- shared_memory.header.total_entry_count = 17;
-
+ // TODO FIND WTF IS WRONG HERE!!!!!!!!
+ return;
if (!IsControllerActivated()) {
- shared_memory.header.entry_count = 0;
- shared_memory.header.last_entry_index = 0;
+ gesture_lifo.entry_count = 0;
+ gesture_lifo.last_entry_index = 0;
+ std::memcpy(data, &gesture_lifo, sizeof(gesture_lifo));
return;
}
ReadTouchInput();
GestureProperties gesture = GetGestureProperties();
- f32 time_difference = static_cast<f32>(shared_memory.header.timestamp - last_update_timestamp) /
- (1000 * 1000 * 1000);
+ f32 time_difference =
+ static_cast<f32>(gesture_lifo.timestamp - last_update_timestamp) / (1000 * 1000 * 1000);
// Only update if necesary
if (!ShouldUpdateGesture(gesture, time_difference)) {
return;
}
- last_update_timestamp = shared_memory.header.timestamp;
+ last_update_timestamp = gesture_lifo.timestamp;
UpdateGestureSharedMemory(data, size, gesture, time_difference);
}
void Controller_Gesture::ReadTouchInput() {
- 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) {
- 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]);
- }
+ const auto touch_status = console->GetTouch();
+ for (std::size_t id = 0; id < fingers.size(); ++id) {
+ const Core::HID::TouchFinger& status = touch_status[id];
+ Finger& finger = fingers[id];
+ finger.pos = status.position;
+ finger.pressed = status.pressed;
}
}
bool Controller_Gesture::ShouldUpdateGesture(const GestureProperties& gesture,
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) {
force_update = false;
return true;
@@ -97,7 +91,7 @@ bool Controller_Gesture::ShouldUpdateGesture(const GestureProperties& gesture,
}
// 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) {
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,
GestureProperties& gesture,
f32 time_difference) {
- TouchType type = TouchType::Idle;
- Attribute attributes{};
-
- 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];
+ GestureType type = GestureType::Idle;
+ GestureAttribute attributes{};
- 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;
+ const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
- // Reset values to default
- 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;
+ // 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;
if (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
- 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;
+ 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;
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,
- Attribute& attributes) {
- const auto& last_entry = GetLastGestureEntry();
+void Controller_Gesture::NewGesture(GestureProperties& gesture, GestureType& type,
+ GestureAttribute& attributes) {
+ const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
gesture.detection_count++;
- type = TouchType::Touch;
+ type = GestureType::Touch;
// 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);
enable_press_and_tap = true;
}
}
-void Controller_Gesture::UpdateExistingGesture(GestureProperties& gesture, TouchType& type,
+void Controller_Gesture::UpdateExistingGesture(GestureProperties& gesture, GestureType& type,
f32 time_difference) {
- const auto& last_entry = GetLastGestureEntry();
+ const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
// Promote to pan type if touch moved
for (size_t id = 0; id < MAX_POINTS; id++) {
if (gesture.points[id] != last_gesture.points[id]) {
- type = TouchType::Pan;
+ type = GestureType::Pan;
break;
}
}
// Number of fingers changed cancel the last event and clear data
if (gesture.active_points != last_gesture.active_points) {
- type = TouchType::Cancel;
+ type = GestureType::Cancel;
enable_press_and_tap = false;
gesture.active_points = 0;
gesture.mid_point = {};
@@ -189,41 +176,41 @@ void Controller_Gesture::UpdateExistingGesture(GestureProperties& gesture, Touch
}
// Calculate extra parameters of panning
- if (type == TouchType::Pan) {
+ if (type == GestureType::Pan) {
UpdatePanEvent(gesture, last_gesture, type, time_difference);
return;
}
// Promote to press type
- if (last_entry.type == TouchType::Touch) {
- type = TouchType::Press;
+ if (last_entry.type == GestureType::Touch) {
+ type = GestureType::Press;
}
}
void Controller_Gesture::EndGesture(GestureProperties& gesture,
- GestureProperties& last_gesture_props, TouchType& type,
- Attribute& attributes, f32 time_difference) {
- const auto& last_entry = GetLastGestureEntry();
+ GestureProperties& last_gesture_props, GestureType& type,
+ GestureAttribute& attributes, f32 time_difference) {
+ const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
if (last_gesture_props.active_points != 0) {
switch (last_entry.type) {
- case TouchType::Touch:
+ case GestureType::Touch:
if (enable_press_and_tap) {
SetTapEvent(gesture, last_gesture_props, type, attributes);
return;
}
- type = TouchType::Cancel;
+ type = GestureType::Cancel;
force_update = true;
break;
- case TouchType::Press:
- case TouchType::Tap:
- case TouchType::Swipe:
- case TouchType::Pinch:
- case TouchType::Rotate:
- type = TouchType::Complete;
+ case GestureType::Press:
+ case GestureType::Tap:
+ case GestureType::Swipe:
+ case GestureType::Pinch:
+ case GestureType::Rotate:
+ type = GestureType::Complete;
force_update = true;
break;
- case TouchType::Pan:
+ case GestureType::Pan:
EndPanEvent(gesture, last_gesture_props, type, time_difference);
break;
default:
@@ -231,15 +218,15 @@ void Controller_Gesture::EndGesture(GestureProperties& gesture,
}
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++;
}
}
void Controller_Gesture::SetTapEvent(GestureProperties& gesture,
- GestureProperties& last_gesture_props, TouchType& type,
- Attribute& attributes) {
- type = TouchType::Tap;
+ GestureProperties& last_gesture_props, GestureType& type,
+ GestureAttribute& attributes) {
+ type = GestureType::Tap;
gesture = last_gesture_props;
force_update = true;
f32 tap_time_difference =
@@ -251,44 +238,42 @@ void Controller_Gesture::SetTapEvent(GestureProperties& gesture,
}
void Controller_Gesture::UpdatePanEvent(GestureProperties& gesture,
- GestureProperties& last_gesture_props, TouchType& type,
+ GestureProperties& last_gesture_props, GestureType& type,
f32 time_difference) {
- auto& cur_entry = shared_memory.gesture_states[shared_memory.header.last_entry_index];
- const auto& last_entry = GetLastGestureEntry();
+ const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
- 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;
+ 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;
last_pan_time_difference = time_difference;
// Promote to pinch type
if (std::abs(gesture.average_distance - last_gesture_props.average_distance) >
pinch_threshold) {
- type = TouchType::Pinch;
- cur_entry.scale = gesture.average_distance / last_gesture_props.average_distance;
+ type = GestureType::Pinch;
+ 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) /
(1 + (gesture.angle * last_gesture_props.angle)));
// Promote to rotate type
if (std::abs(angle_between_two_lines) > angle_threshold) {
- type = TouchType::Rotate;
- cur_entry.scale = 0;
- cur_entry.rotation_angle = angle_between_two_lines * 180.0f / Common::PI;
+ type = GestureType::Rotate;
+ next_state.scale = 0;
+ next_state.rotation_angle = angle_between_two_lines * 180.0f / Common::PI;
}
}
void Controller_Gesture::EndPanEvent(GestureProperties& gesture,
- GestureProperties& last_gesture_props, TouchType& type,
+ GestureProperties& last_gesture_props, GestureType& type,
f32 time_difference) {
- auto& cur_entry = shared_memory.gesture_states[shared_memory.header.last_entry_index];
- const auto& last_entry = GetLastGestureEntry();
- cur_entry.vel_x =
+ const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
+ next_state.vel_x =
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);
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
if (curr_vel > swipe_threshold) {
@@ -297,93 +282,34 @@ void Controller_Gesture::EndPanEvent(GestureProperties& gesture,
}
// End panning without swipe
- type = TouchType::Complete;
- cur_entry.vel_x = 0;
- cur_entry.vel_y = 0;
+ type = GestureType::Complete;
+ next_state.vel_x = 0;
+ next_state.vel_y = 0;
force_update = true;
}
void Controller_Gesture::SetSwipeEvent(GestureProperties& gesture,
- GestureProperties& last_gesture_props, TouchType& type) {
- auto& cur_entry = shared_memory.gesture_states[shared_memory.header.last_entry_index];
- const auto& last_entry = GetLastGestureEntry();
+ GestureProperties& last_gesture_props, GestureType& type) {
+ const auto& last_entry = gesture_lifo.ReadCurrentEntry().state;
- type = TouchType::Swipe;
+ type = GestureType::Swipe;
gesture = last_gesture_props;
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 (cur_entry.delta.x > 0) {
- cur_entry.direction = Direction::Right;
+ if (std::abs(next_state.delta.x) > std::abs(next_state.delta.y)) {
+ if (next_state.delta.x > 0) {
+ next_state.direction = GestureDirection::Right;
return;
}
- cur_entry.direction = Direction::Left;
+ next_state.direction = GestureDirection::Left;
return;
}
- if (cur_entry.delta.y > 0) {
- cur_entry.direction = Direction::Down;
+ if (next_state.delta.y > 0) {
+ next_state.direction = GestureDirection::Down;
return;
}
- cur_entry.direction = Direction::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;
+ next_state.direction = GestureDirection::Up;
}
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 7e7ae6625..8e6f315a4 100644
--- a/src/core/hle/service/hid/controllers/gesture.h
+++ b/src/core/hle/service/hid/controllers/gesture.h
@@ -8,8 +8,12 @@
#include "common/bit_field.h"
#include "common/common_types.h"
#include "common/point.h"
-#include "core/frontend/input.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 {
class Controller_Gesture final : public ControllerBase {
@@ -26,14 +30,12 @@ public:
// 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;
- // Called when input devices should be loaded
- void OnLoadInputDevices() override;
-
private:
static constexpr size_t MAX_FINGERS = 16;
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
Complete, // Set at the end of a touch event
Cancel, // Set when the number of fingers change
@@ -46,7 +48,8 @@ private:
Rotate, // All points rotating from the midpoint
};
- enum class Direction : u32 {
+ // This is nn::hid::GestureDirection
+ enum class GestureDirection : u32 {
None,
Left,
Up,
@@ -54,7 +57,8 @@ private:
Down,
};
- struct Attribute {
+ // This is nn::hid::GestureAttribute
+ struct GestureAttribute {
union {
u32_le raw{};
@@ -62,31 +66,25 @@ private:
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 {
s64_le sampling_number;
- s64_le sampling_number2;
s64_le detection_count;
- TouchType type;
- Direction direction;
+ GestureType type;
+ GestureDirection direction;
Common::Point<s32_le> pos;
Common::Point<s32_le> delta;
f32 vel_x;
f32 vel_y;
- Attribute attributes;
+ GestureAttribute attributes;
f32 scale;
f32 rotation_angle;
s32_le point_count;
std::array<Common::Point<s32_le>, 4> points;
};
- static_assert(sizeof(GestureState) == 0x68, "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");
+ static_assert(sizeof(GestureState) == 0x60, "GestureState is an invalid size");
struct Finger {
Common::Point<f32> pos{};
@@ -114,58 +112,42 @@ private:
f32 time_difference);
// Initializes new gesture
- void NewGesture(GestureProperties& gesture, TouchType& type, Attribute& attributes);
+ void NewGesture(GestureProperties& gesture, GestureType& type, GestureAttribute& attributes);
// 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
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
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
void UpdatePanEvent(GestureProperties& gesture, GestureProperties& last_gesture_props,
- TouchType& type, f32 time_difference);
+ GestureType& type, f32 time_difference);
// Terminates the pan event
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
void SetSwipeEvent(GestureProperties& gesture, GestureProperties& last_gesture_props,
- TouchType& 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);
+ GestureType& type);
// Returns the average distance, angle and middle point of the active fingers
GestureProperties GetGestureProperties();
- SharedMemory shared_memory{};
- std::unique_ptr<Input::TouchDevice> touch_mouse_device;
- std::unique_ptr<Input::TouchDevice> touch_udp_device;
- std::unique_ptr<Input::TouchDevice> touch_btn_device;
- 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{};
+ // 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{};
+ Core::HID::EmulatedConsole* console;
+
GestureProperties last_gesture{};
s64_le last_update_timestamp{};
s64_le last_tap_timestamp{};
diff --git a/src/core/hle/service/hid/controllers/touchscreen.cpp b/src/core/hle/service/hid/controllers/touchscreen.cpp
index 6ef17acc5..e0a44d06b 100644
--- a/src/core/hle/service/hid/controllers/touchscreen.cpp
+++ b/src/core/hle/service/hid/controllers/touchscreen.cpp
@@ -7,72 +7,79 @@
#include "common/common_types.h"
#include "common/logging/log.h"
#include "common/settings.h"
+#include "core/core.h"
#include "core/core_timing.h"
#include "core/frontend/emu_window.h"
-#include "core/frontend/input.h"
#include "core/hle/service/hid/controllers/touchscreen.h"
namespace Service::HID {
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;
-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::OnInit() {}
void Controller_Touchscreen::OnRelease() {}
void Controller_Touchscreen::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8* data,
std::size_t size) {
- shared_memory.header.timestamp = core_timing.GetCPUTicks();
- shared_memory.header.total_entry_count = 17;
+ touch_screen_lifo.timestamp = core_timing.GetCPUTicks();
if (!IsControllerActivated()) {
- shared_memory.header.entry_count = 0;
- shared_memory.header.last_entry_index = 0;
+ touch_screen_lifo.entry_count = 0;
+ touch_screen_lifo.last_entry_index = 0;
+ std::memcpy(data, &touch_screen_lifo, sizeof(touch_screen_lifo));
return;
}
- shared_memory.header.entry_count = 16;
- const auto& last_entry =
- shared_memory.shared_memory_entries[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.shared_memory_entries[shared_memory.header.last_entry_index];
+ const auto touch_status = console->GetTouch();
+ for (std::size_t id = 0; id < MAX_FINGERS; id++) {
+ const auto& current_touch = touch_status[id];
+ auto& finger = fingers[id];
+ finger.position = current_touch.position;
+ finger.id = current_touch.id;
- cur_entry.sampling_number = last_entry.sampling_number + 1;
- cur_entry.sampling_number2 = cur_entry.sampling_number;
+ if (finger.attribute.start_touch) {
+ 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 (finger.attribute.end_touch) {
+ finger.attribute.raw = 0;
+ finger.pressed = false;
+ continue;
+ }
+
+ if (!finger.pressed && current_touch.pressed) {
+ finger.attribute.start_touch.Assign(1);
+ finger.pressed = true;
+ continue;
+ }
- 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]);
+ 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& finger) { return finger.pressed; });
const auto active_fingers_count =
static_cast<std::size_t>(std::distance(active_fingers.begin(), end_iter));
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) {
- auto& touch_entry = cur_entry.states[id];
+ auto& touch_entry = next_state.states[id];
if (id < active_fingers_count) {
const auto& [active_x, active_y] = active_fingers[id].position;
touch_entry.position = {
@@ -97,66 +104,9 @@ void Controller_Touchscreen::OnUpdate(const Core::Timing::CoreTiming& core_timin
touch_entry.finger = 0;
}
}
- std::memcpy(data + SHARED_MEMORY_OFFSET, &shared_memory, sizeof(TouchScreenSharedMemory));
-}
-
-void Controller_Touchscreen::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_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;
+ touch_screen_lifo.WriteNextEntry(next_state);
+ std::memcpy(data + SHARED_MEMORY_OFFSET, &touch_screen_lifo, sizeof(touch_screen_lifo));
}
} // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/touchscreen.h b/src/core/hle/service/hid/controllers/touchscreen.h
index 8e9b40c0a..bcf79237d 100644
--- a/src/core/hle/service/hid/controllers/touchscreen.h
+++ b/src/core/hle/service/hid/controllers/touchscreen.h
@@ -9,18 +9,22 @@
#include "common/common_types.h"
#include "common/point.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/ring_lifo.h"
namespace Service::HID {
class Controller_Touchscreen final : public ControllerBase {
public:
+ // This is nn::hid::TouchScreenModeForNx
enum class TouchScreenModeForNx : u8 {
UseSystemSetting,
Finger,
Heat2,
};
+ // This is nn::hid::TouchScreenConfigurationForNx
struct TouchScreenConfigurationForNx {
TouchScreenModeForNx mode;
INSERT_PADDING_BYTES_NOINIT(0x7);
@@ -41,73 +45,32 @@ public:
// 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;
- // Called when input devices should be loaded
- void OnLoadInputDevices() override;
-
private:
static constexpr std::size_t MAX_FINGERS = 16;
- // Returns an unused finger id, if there is no fingers available std::nullopt will be returned
- std::optional<std::size_t> GetUnusedFingerID() const;
-
- // 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 {
+ // This is nn::hid::TouchScreenState
+ struct TouchScreenState {
s64_le sampling_number;
- s64_le sampling_number2;
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");
-
- 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");
+ static_assert(sizeof(TouchScreenState) == 0x290, "TouchScreenState is an invalid size");
struct Finger {
u64_le last_touch{};
Common::Point<float> position;
u32_le id{};
bool pressed{};
- Attributes attribute;
+ Core::HID::TouchAttribute attribute;
};
- TouchScreenSharedMemory shared_memory{};
- std::unique_ptr<Input::TouchDevice> touch_mouse_device;
- std::unique_ptr<Input::TouchDevice> touch_udp_device;
- std::unique_ptr<Input::TouchDevice> touch_btn_device;
- 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;
+ // This is nn::hid::detail::TouchScreenLifo
+ Lifo<TouchScreenState> touch_screen_lifo{};
+ static_assert(sizeof(touch_screen_lifo) == 0x2C38, "touch_screen_lifo is an invalid size");
+ TouchScreenState next_state{};
+
std::array<Finger, MAX_FINGERS> fingers;
+ Core::HID::EmulatedConsole* console;
};
} // namespace Service::HID
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-23 08:38:55 +0100