mirror of
				https://github.com/PabloMK7/citra.git
				synced 2025-10-31 05:40:04 +00:00 
			
		
		
		
	Merge pull request #2899 from wwylele/touch-refactor
Refactor touch input into a TouchDevice
This commit is contained in:
		
						commit
						75cd28a7cc
					
				
					 8 changed files with 87 additions and 43 deletions
				
			
		|  | @ -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); | ||||
|  |  | |||
|  | @ -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) | ||||
|  |  | |||
|  | @ -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"); | ||||
|  |  | |||
|  | @ -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 "core/3ds.h" | ||||
| #include "core/core.h" | ||||
| #include <mutex> | ||||
| #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); | ||||
|     touch_state->touch_x = | ||||
|         static_cast<float>(framebuffer_x - framebuffer_layout.bottom_screen.left) / | ||||
|         (framebuffer_layout.bottom_screen.right - framebuffer_layout.bottom_screen.left); | ||||
|     touch_y = Core::kScreenBottomHeight * (framebuffer_y - framebuffer_layout.bottom_screen.top) / | ||||
|     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; | ||||
|     touch_x = 0; | ||||
|     touch_y = 0; | ||||
|     std::lock_guard<std::mutex> guard(touch_state->mutex); | ||||
|     touch_state->touch_pressed = false; | ||||
|     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)) | ||||
|  |  | |||
|  | @ -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() { | ||||
|         // TODO: Find a better place to set this.
 | ||||
|         config.min_client_area_size = std::make_pair(400u, 480u); | ||||
|         active_config = config; | ||||
|         touch_x = 0; | ||||
|         touch_y = 0; | ||||
|         touch_pressed = false; | ||||
|     } | ||||
|     virtual ~EmuWindow() {} | ||||
|     EmuWindow(); | ||||
|     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
 | ||||
| 
 | ||||
|     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)
 | ||||
|     class TouchState; | ||||
|     std::shared_ptr<TouchState> touch_state; | ||||
| 
 | ||||
|     /**
 | ||||
|      * Clip the provided coordinates to be inside the touchscreen area. | ||||
|  |  | |||
|  | @ -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
 | ||||
|  |  | |||
|  | @ -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; | ||||
| 
 | ||||
|     std::tie(touch_entry.x, touch_entry.y, pressed) = VideoCore::g_emu_window->GetTouchState(); | ||||
|     float x, y; | ||||
|     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
 | ||||
|  |  | |||
|  | @ -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; | ||||
|  |  | |||
		Loading…
	
	Add table
		Add a link
		
	
		Reference in a new issue