Merge pull request #2899 from wwylele/touch-refactor

Refactor touch input into a TouchDevice

src/citra/config.cpp

@@ -78,6 +78,8 @@ void Config::ReadValues() {
 
     Settings::values.motion_device = sdl2_config->Get(
         "Controls", "motion_device", "engine:motion_emu,update_period:100,sensitivity:0.01");
+    Settings::values.touch_device =
+        sdl2_config->Get("Controls", "touch_device", "engine:emu_window");
 
     // Core
     Settings::values.use_cpu_jit = sdl2_config->GetBoolean("Core", "use_cpu_jit", true);

src/citra/default_ini.h

@@ -62,6 +62,10 @@ c_stick=
 #      - "sensitivity": the coefficient converting mouse movement to tilting angle (default to 0.01)
 motion_device=
 
+# for touch input, the following devices are available:
+#  - "emu_window" (default) for emulating touch input from mouse input to the emulation window. No parameters required
+touch_device=
+
 [Core]
 # Whether to use the Just-In-Time (JIT) compiler for CPU emulation
 # 0: Interpreter (slow), 1 (default): JIT (fast)

src/citra_qt/configuration/config.cpp

@@ -61,6 +61,8 @@ void Config::ReadValues() {
         qt_config->value("motion_device", "engine:motion_emu,update_period:100,sensitivity:0.01")
             .toString()
             .toStdString();
+    Settings::values.touch_device =
+        qt_config->value("touch_device", "engine:emu_window").toString().toStdString();
 
     qt_config->endGroup();
 
@@ -213,6 +215,7 @@ void Config::SaveValues() {
                             QString::fromStdString(Settings::values.analogs[i]));
     }
     qt_config->setValue("motion_device", QString::fromStdString(Settings::values.motion_device));
+    qt_config->setValue("touch_device", QString::fromStdString(Settings::values.touch_device));
     qt_config->endGroup();
 
     qt_config->beginGroup("Core");

src/core/frontend/emu_window.cpp

@@ -2,14 +2,55 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <algorithm>
 #include <cmath>
-#include "common/assert.h"
+#include <mutex>
-#include "core/3ds.h"
-#include "core/core.h"
 #include "core/frontend/emu_window.h"
+#include "core/frontend/input.h"
 #include "core/settings.h"
 
+class EmuWindow::TouchState : public Input::Factory<Input::TouchDevice>,
+                              public std::enable_shared_from_this<TouchState> {
+public:
+    std::unique_ptr<Input::TouchDevice> Create(const Common::ParamPackage&) override {
+        return std::make_unique<Device>(shared_from_this());
+    }
+
+    std::mutex mutex;
+
+    bool touch_pressed = false; ///< True if touchpad area is currently pressed, otherwise false
+
+    float touch_x = 0.0f; ///< Touchpad X-position
+    float touch_y = 0.0f; ///< Touchpad Y-position
+
+private:
+    class Device : public Input::TouchDevice {
+    public:
+        explicit Device(std::weak_ptr<TouchState>&& touch_state) : touch_state(touch_state) {}
+        std::tuple<float, float, bool> GetStatus() const override {
+            if (auto state = touch_state.lock()) {
+                std::lock_guard<std::mutex> guard(state->mutex);
+                return std::make_tuple(state->touch_x, state->touch_y, state->touch_pressed);
+            }
+            return std::make_tuple(0.0f, 0.0f, false);
+        }
+
+    private:
+        std::weak_ptr<TouchState> touch_state;
+    };
+};
+
+EmuWindow::EmuWindow() {
+    // TODO: Find a better place to set this.
+    config.min_client_area_size = std::make_pair(400u, 480u);
+    active_config = config;
+    touch_state = std::make_shared<TouchState>();
+    Input::RegisterFactory<Input::TouchDevice>("emu_window", touch_state);
+}
+
+EmuWindow::~EmuWindow() {
+    Input::UnregisterFactory<Input::TouchDevice>("emu_window");
+}
+
 /**
  * Check if the given x/y coordinates are within the touchpad specified by the framebuffer layout
  * @param layout FramebufferLayout object describing the framebuffer size and screen positions
@@ -38,22 +79,26 @@ void EmuWindow::TouchPressed(unsigned framebuffer_x, unsigned framebuffer_y) {
     if (!IsWithinTouchscreen(framebuffer_layout, framebuffer_x, framebuffer_y))
         return;
 
-    touch_x = Core::kScreenBottomWidth * (framebuffer_x - framebuffer_layout.bottom_screen.left) /
+    std::lock_guard<std::mutex> guard(touch_state->mutex);
-              (framebuffer_layout.bottom_screen.right - framebuffer_layout.bottom_screen.left);
+    touch_state->touch_x =
-    touch_y = Core::kScreenBottomHeight * (framebuffer_y - framebuffer_layout.bottom_screen.top) /
+        static_cast<float>(framebuffer_x - framebuffer_layout.bottom_screen.left) /
-              (framebuffer_layout.bottom_screen.bottom - framebuffer_layout.bottom_screen.top);
+        (framebuffer_layout.bottom_screen.right - framebuffer_layout.bottom_screen.left);
+    touch_state->touch_y =
+        static_cast<float>(framebuffer_y - framebuffer_layout.bottom_screen.top) /
+        (framebuffer_layout.bottom_screen.bottom - framebuffer_layout.bottom_screen.top);
 
-    touch_pressed = true;
+    touch_state->touch_pressed = true;
 }
 
 void EmuWindow::TouchReleased() {
-    touch_pressed = false;
+    std::lock_guard<std::mutex> guard(touch_state->mutex);
-    touch_x = 0;
+    touch_state->touch_pressed = false;
-    touch_y = 0;
+    touch_state->touch_x = 0;
+    touch_state->touch_y = 0;
 }
 
 void EmuWindow::TouchMoved(unsigned framebuffer_x, unsigned framebuffer_y) {
-    if (!touch_pressed)
+    if (!touch_state->touch_pressed)
         return;
 
     if (!IsWithinTouchscreen(framebuffer_layout, framebuffer_x, framebuffer_y))

src/core/frontend/emu_window.h

@@ -4,11 +4,10 @@
 
 #pragma once
 
-#include <mutex>
+#include <memory>
 #include <tuple>
 #include <utility>
 #include "common/common_types.h"
-#include "common/math_util.h"
 #include "core/frontend/framebuffer_layout.h"
 
 /**
@@ -68,17 +67,6 @@ public:
      */
     void TouchMoved(unsigned framebuffer_x, unsigned framebuffer_y);
 
-    /**
-     * Gets the current touch screen state (touch X/Y coordinates and whether or not it is pressed).
-     * @note This should be called by the core emu thread to get a state set by the window thread.
-     * @todo Fix this function to be thread-safe.
-     * @return std::tuple of (x, y, pressed) where `x` and `y` are the touch coordinates and
-     *         `pressed` is true if the touch screen is currently being pressed
-     */
-    std::tuple<u16, u16, bool> GetTouchState() const {
-        return std::make_tuple(touch_x, touch_y, touch_pressed);
-    }
-
     /**
      * Returns currently active configuration.
      * @note Accesses to the returned object need not be consistent because it may be modified in
@@ -113,15 +101,8 @@ public:
     void UpdateCurrentFramebufferLayout(unsigned width, unsigned height);
 
 protected:
-    EmuWindow() {
+    EmuWindow();
-        // TODO: Find a better place to set this.
+    virtual ~EmuWindow();
-        config.min_client_area_size = std::make_pair(400u, 480u);
-        active_config = config;
-        touch_x = 0;
-        touch_y = 0;
-        touch_pressed = false;
-    }
-    virtual ~EmuWindow() {}
 
     /**
      * Processes any pending configuration changes from the last SetConfig call.
@@ -177,10 +158,8 @@ private:
                                 /// ProcessConfigurationChanges)
     WindowConfig active_config; ///< Internal active configuration
 
-    bool touch_pressed; ///< True if touchpad area is currently pressed, otherwise false
+    class TouchState;
-
+    std::shared_ptr<TouchState> touch_state;
-    u16 touch_x; ///< Touchpad X-position in native 3DS pixel coordinates (0-320)
-    u16 touch_y; ///< Touchpad Y-position in native 3DS pixel coordinates (0-240)
 
     /**
      * Clip the provided coordinates to be inside the touchscreen area.

src/core/frontend/input.h

@@ -126,4 +126,10 @@ using AnalogDevice = InputDevice<std::tuple<float, float>>;
  */
 using MotionDevice = InputDevice<std::tuple<Math::Vec3<float>, Math::Vec3<float>>>;
 
+/**
+ * A touch device is an input device that returns a tuple of two floats and a bool. The floats are
+ * x and y coordinates in the range 0.0 - 1.0, and the bool indicates whether it is pressed.
+ */
+using TouchDevice = InputDevice<std::tuple<float, float, bool>>;
+
 } // namespace Input

src/core/hle/service/hid/hid.cpp

@@ -7,9 +7,9 @@
 #include <cmath>
 #include <memory>
 #include "common/logging/log.h"
+#include "core/3ds.h"
 #include "core/core.h"
 #include "core/core_timing.h"
-#include "core/frontend/emu_window.h"
 #include "core/frontend/input.h"
 #include "core/hle/ipc.h"
 #include "core/hle/kernel/event.h"
@@ -19,7 +19,6 @@
 #include "core/hle/service/hid/hid_spvr.h"
 #include "core/hle/service/hid/hid_user.h"
 #include "core/hle/service/service.h"
-#include "video_core/video_core.h"
 
 namespace Service {
 namespace HID {
@@ -59,6 +58,7 @@ static std::array<std::unique_ptr<Input::ButtonDevice>, Settings::NativeButton::
     buttons;
 static std::unique_ptr<Input::AnalogDevice> circle_pad;
 static std::unique_ptr<Input::MotionDevice> motion_device;
+static std::unique_ptr<Input::TouchDevice> touch_device;
 
 DirectionState GetStickDirectionState(s16 circle_pad_x, s16 circle_pad_y) {
     // 30 degree and 60 degree are angular thresholds for directions
@@ -96,6 +96,7 @@ static void LoadInputDevices() {
     circle_pad = Input::CreateDevice<Input::AnalogDevice>(
         Settings::values.analogs[Settings::NativeAnalog::CirclePad]);
     motion_device = Input::CreateDevice<Input::MotionDevice>(Settings::values.motion_device);
+    touch_device = Input::CreateDevice<Input::TouchDevice>(Settings::values.touch_device);
 }
 
 static void UnloadInputDevices() {
@@ -104,6 +105,7 @@ static void UnloadInputDevices() {
     }
     circle_pad.reset();
     motion_device.reset();
+    touch_device.reset();
 }
 
 static void UpdatePadCallback(u64 userdata, int cycles_late) {
@@ -172,8 +174,10 @@ static void UpdatePadCallback(u64 userdata, int cycles_late) {
     // Get the current touch entry
     TouchDataEntry& touch_entry = mem->touch.entries[mem->touch.index];
     bool pressed = false;
-
+    float x, y;
-    std::tie(touch_entry.x, touch_entry.y, pressed) = VideoCore::g_emu_window->GetTouchState();
+    std::tie(x, y, pressed) = touch_device->GetStatus();
+    touch_entry.x = static_cast<u16>(x * Core::kScreenBottomWidth);
+    touch_entry.y = static_cast<u16>(y * Core::kScreenBottomHeight);
     touch_entry.valid.Assign(pressed ? 1 : 0);
 
     // TODO(bunnei): We're not doing anything with offset 0xA8 + 0x18 of HID SharedMemory, which

src/core/settings.h

@@ -81,6 +81,7 @@ struct Values {
     std::array<std::string, NativeButton::NumButtons> buttons;
     std::array<std::string, NativeAnalog::NumAnalogs> analogs;
     std::string motion_device;
+    std::string touch_device;
 
     // Core
     bool use_cpu_jit;