From 64f98f4d0f33b5c626d86a05ab9dd8060e160cc5 Mon Sep 17 00:00:00 2001 From: MerryMage Date: Fri, 23 Dec 2016 13:37:40 +0000 Subject: core: Move emu_window and key_map into core * Removes circular dependences (common should not depend on core) --- src/citra/emu_window/emu_window_sdl2.cpp | 2 +- src/citra/emu_window/emu_window_sdl2.h | 2 +- src/citra_qt/bootmanager.cpp | 2 +- src/citra_qt/bootmanager.h | 2 +- src/common/CMakeLists.txt | 4 - src/common/emu_window.cpp | 107 -------- src/common/emu_window.h | 290 --------------------- src/common/key_map.cpp | 152 ----------- src/common/key_map.h | 93 ------- src/core/CMakeLists.txt | 4 + src/core/frontend/emu_window.cpp | 107 ++++++++ src/core/frontend/emu_window.h | 290 +++++++++++++++++++++ src/core/frontend/key_map.cpp | 152 +++++++++++ src/core/frontend/key_map.h | 93 +++++++ src/core/hle/service/hid/hid.cpp | 2 +- src/core/settings.cpp | 2 +- .../renderer_opengl/gl_rasterizer_cache.cpp | 2 +- src/video_core/renderer_opengl/renderer_opengl.cpp | 2 +- 18 files changed, 654 insertions(+), 654 deletions(-) delete mode 100644 src/common/emu_window.cpp delete mode 100644 src/common/emu_window.h delete mode 100644 src/common/key_map.cpp delete mode 100644 src/common/key_map.h create mode 100644 src/core/frontend/emu_window.cpp create mode 100644 src/core/frontend/emu_window.h create mode 100644 src/core/frontend/key_map.cpp create mode 100644 src/core/frontend/key_map.h diff --git a/src/citra/emu_window/emu_window_sdl2.cpp b/src/citra/emu_window/emu_window_sdl2.cpp index 8abe48984..b0d82b670 100644 --- a/src/citra/emu_window/emu_window_sdl2.cpp +++ b/src/citra/emu_window/emu_window_sdl2.cpp @@ -9,10 +9,10 @@ #include #include #include "citra/emu_window/emu_window_sdl2.h" -#include "common/key_map.h" #include "common/logging/log.h" #include "common/scm_rev.h" #include "common/string_util.h" +#include "core/frontend/key_map.h" #include "core/hle/service/hid/hid.h" #include "core/settings.h" #include "video_core/video_core.h" diff --git a/src/citra/emu_window/emu_window_sdl2.h b/src/citra/emu_window/emu_window_sdl2.h index e4d14ef12..c8cd919c6 100644 --- a/src/citra/emu_window/emu_window_sdl2.h +++ b/src/citra/emu_window/emu_window_sdl2.h @@ -5,7 +5,7 @@ #pragma once #include -#include "common/emu_window.h" +#include "core/frontend/emu_window.h" struct SDL_Window; diff --git a/src/citra_qt/bootmanager.cpp b/src/citra_qt/bootmanager.cpp index bb75633b6..57fde6caa 100644 --- a/src/citra_qt/bootmanager.cpp +++ b/src/citra_qt/bootmanager.cpp @@ -9,11 +9,11 @@ #endif #include "citra_qt/bootmanager.h" -#include "common/key_map.h" #include "common/microprofile.h" #include "common/scm_rev.h" #include "common/string_util.h" #include "core/core.h" +#include "core/frontend/key_map.h" #include "video_core/debug_utils/debug_utils.h" #include "video_core/video_core.h" diff --git a/src/citra_qt/bootmanager.h b/src/citra_qt/bootmanager.h index af52f369b..43015390b 100644 --- a/src/citra_qt/bootmanager.h +++ b/src/citra_qt/bootmanager.h @@ -9,8 +9,8 @@ #include #include #include -#include "common/emu_window.h" #include "common/thread.h" +#include "core/frontend/emu_window.h" class QKeyEvent; class QScreen; diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt index e6c2ce335..5aecf6e6e 100644 --- a/src/common/CMakeLists.txt +++ b/src/common/CMakeLists.txt @@ -3,11 +3,9 @@ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.cpp.in" "${CMAKE_CURRENT_SOU set(SRCS break_points.cpp - emu_window.cpp file_util.cpp framebuffer_layout.cpp hash.cpp - key_map.cpp logging/filter.cpp logging/text_formatter.cpp logging/backend.cpp @@ -34,11 +32,9 @@ set(HEADERS common_funcs.h common_paths.h common_types.h - emu_window.h file_util.h framebuffer_layout.h hash.h - key_map.h linear_disk_cache.h logging/text_formatter.h logging/filter.h diff --git a/src/common/emu_window.cpp b/src/common/emu_window.cpp deleted file mode 100644 index e3a9e08e6..000000000 --- a/src/common/emu_window.cpp +++ /dev/null @@ -1,107 +0,0 @@ -// Copyright 2014 Citra Emulator Project -// Licensed under GPLv2 or any later version -// Refer to the license.txt file included. - -#include -#include -#include "common/assert.h" -#include "common/key_map.h" -#include "emu_window.h" -#include "video_core/video_core.h" - -void EmuWindow::ButtonPressed(Service::HID::PadState pad) { - pad_state.hex |= pad.hex; -} - -void EmuWindow::ButtonReleased(Service::HID::PadState pad) { - pad_state.hex &= ~pad.hex; -} - -void EmuWindow::CirclePadUpdated(float x, float y) { - constexpr int MAX_CIRCLEPAD_POS = 0x9C; // Max value for a circle pad position - - // Make sure the coordinates are in the unit circle, - // otherwise normalize it. - float r = x * x + y * y; - if (r > 1) { - r = std::sqrt(r); - x /= r; - y /= r; - } - - circle_pad_x = static_cast(x * MAX_CIRCLEPAD_POS); - circle_pad_y = static_cast(y * MAX_CIRCLEPAD_POS); -} - -/** - * 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 - * @param framebuffer_x Framebuffer x-coordinate to check - * @param framebuffer_y Framebuffer y-coordinate to check - * @return True if the coordinates are within the touchpad, otherwise false - */ -static bool IsWithinTouchscreen(const Layout::FramebufferLayout& layout, unsigned framebuffer_x, - unsigned framebuffer_y) { - return ( - framebuffer_y >= layout.bottom_screen.top && framebuffer_y < layout.bottom_screen.bottom && - framebuffer_x >= layout.bottom_screen.left && framebuffer_x < layout.bottom_screen.right); -} - -std::tuple EmuWindow::ClipToTouchScreen(unsigned new_x, unsigned new_y) { - new_x = std::max(new_x, framebuffer_layout.bottom_screen.left); - new_x = std::min(new_x, framebuffer_layout.bottom_screen.right - 1); - - new_y = std::max(new_y, framebuffer_layout.bottom_screen.top); - new_y = std::min(new_y, framebuffer_layout.bottom_screen.bottom - 1); - - return std::make_tuple(new_x, new_y); -} - -void EmuWindow::TouchPressed(unsigned framebuffer_x, unsigned framebuffer_y) { - if (!IsWithinTouchscreen(framebuffer_layout, framebuffer_x, framebuffer_y)) - return; - - touch_x = VideoCore::kScreenBottomWidth * - (framebuffer_x - framebuffer_layout.bottom_screen.left) / - (framebuffer_layout.bottom_screen.right - framebuffer_layout.bottom_screen.left); - touch_y = VideoCore::kScreenBottomHeight * - (framebuffer_y - framebuffer_layout.bottom_screen.top) / - (framebuffer_layout.bottom_screen.bottom - framebuffer_layout.bottom_screen.top); - - touch_pressed = true; - pad_state.touch.Assign(1); -} - -void EmuWindow::TouchReleased() { - touch_pressed = false; - touch_x = 0; - touch_y = 0; - pad_state.touch.Assign(0); -} - -void EmuWindow::TouchMoved(unsigned framebuffer_x, unsigned framebuffer_y) { - if (!touch_pressed) - return; - - if (!IsWithinTouchscreen(framebuffer_layout, framebuffer_x, framebuffer_y)) - std::tie(framebuffer_x, framebuffer_y) = ClipToTouchScreen(framebuffer_x, framebuffer_y); - - TouchPressed(framebuffer_x, framebuffer_y); -} - -void EmuWindow::UpdateCurrentFramebufferLayout(unsigned width, unsigned height) { - Layout::FramebufferLayout layout; - switch (Settings::values.layout_option) { - case Settings::LayoutOption::SingleScreen: - layout = Layout::SingleFrameLayout(width, height, Settings::values.swap_screen); - break; - case Settings::LayoutOption::LargeScreen: - layout = Layout::LargeFrameLayout(width, height, Settings::values.swap_screen); - break; - case Settings::LayoutOption::Default: - default: - layout = Layout::DefaultFrameLayout(width, height, Settings::values.swap_screen); - break; - } - NotifyFramebufferLayoutChanged(layout); -} diff --git a/src/common/emu_window.h b/src/common/emu_window.h deleted file mode 100644 index 835c4d500..000000000 --- a/src/common/emu_window.h +++ /dev/null @@ -1,290 +0,0 @@ -// Copyright 2014 Citra Emulator Project -// Licensed under GPLv2 or any later version -// Refer to the license.txt file included. - -#pragma once - -#include -#include -#include "common/common_types.h" -#include "common/framebuffer_layout.h" -#include "common/math_util.h" -#include "core/hle/service/hid/hid.h" - -/** - * Abstraction class used to provide an interface between emulation code and the frontend - * (e.g. SDL, QGLWidget, GLFW, etc...). - * - * Design notes on the interaction between EmuWindow and the emulation core: - * - Generally, decisions on anything visible to the user should be left up to the GUI. - * For example, the emulation core should not try to dictate some window title or size. - * This stuff is not the core's business and only causes problems with regards to thread-safety - * anyway. - * - Under certain circumstances, it may be desirable for the core to politely request the GUI - * to set e.g. a minimum window size. However, the GUI should always be free to ignore any - * such hints. - * - EmuWindow may expose some of its state as read-only to the emulation core, however care - * should be taken to make sure the provided information is self-consistent. This requires - * some sort of synchronization (most of this is still a TODO). - * - DO NOT TREAT THIS CLASS AS A GUI TOOLKIT ABSTRACTION LAYER. That's not what it is. Please - * re-read the upper points again and think about it if you don't see this. - */ -class EmuWindow { -public: - /// Data structure to store emuwindow configuration - struct WindowConfig { - bool fullscreen; - int res_width; - int res_height; - std::pair min_client_area_size; - }; - - /// Swap buffers to display the next frame - virtual void SwapBuffers() = 0; - - /// Polls window events - virtual void PollEvents() = 0; - - /// Makes the graphics context current for the caller thread - virtual void MakeCurrent() = 0; - - /// Releases (dunno if this is the "right" word) the GLFW context from the caller thread - virtual void DoneCurrent() = 0; - - virtual void ReloadSetKeymaps() = 0; - - /** - * Signals a button press action to the HID module. - * @param pad_state indicates which button to press - * @note only handles real buttons (A/B/X/Y/...), excluding analog inputs like the circle pad. - */ - void ButtonPressed(Service::HID::PadState pad_state); - - /** - * Signals a button release action to the HID module. - * @param pad_state indicates which button to press - * @note only handles real buttons (A/B/X/Y/...), excluding analog inputs like the circle pad. - */ - void ButtonReleased(Service::HID::PadState pad_state); - - /** - * Signals a circle pad change action to the HID module. - * @param x new x-coordinate of the circle pad, in the range [-1.0, 1.0] - * @param y new y-coordinate of the circle pad, in the range [-1.0, 1.0] - * @note the coordinates will be normalized if the radius is larger than 1 - */ - void CirclePadUpdated(float x, float y); - - /** - * Signal that a touch pressed event has occurred (e.g. mouse click pressed) - * @param framebuffer_x Framebuffer x-coordinate that was pressed - * @param framebuffer_y Framebuffer y-coordinate that was pressed - */ - void TouchPressed(unsigned framebuffer_x, unsigned framebuffer_y); - - /// Signal that a touch released event has occurred (e.g. mouse click released) - void TouchReleased(); - - /** - * Signal that a touch movement event has occurred (e.g. mouse was moved over the emu window) - * @param framebuffer_x Framebuffer x-coordinate - * @param framebuffer_y Framebuffer y-coordinate - */ - void TouchMoved(unsigned framebuffer_x, unsigned framebuffer_y); - - /** - * Gets the current pad state (which buttons are pressed). - * @note This should be called by the core emu thread to get a state set by the window thread. - * @note This doesn't include analog input like circle pad direction - * @todo Fix this function to be thread-safe. - * @return PadState object indicating the current pad state - */ - Service::HID::PadState GetPadState() const { - return pad_state; - } - - /** - * Gets the current circle pad state. - * @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), where `x` and `y` are the circle pad coordinates - */ - std::tuple GetCirclePadState() const { - return std::make_tuple(circle_pad_x, circle_pad_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 GetTouchState() const { - return std::make_tuple(touch_x, touch_y, touch_pressed); - } - - /** - * Gets the current accelerometer state (acceleration along each three axis). - * Axis explained: - * +x is the same direction as LEFT on D-pad. - * +y is normal to the touch screen, pointing outward. - * +z is the same direction as UP on D-pad. - * Units: - * 1 unit of return value = 1/512 g (measured by hw test), - * where g is the gravitational acceleration (9.8 m/sec2). - * @note This should be called by the core emu thread to get a state set by the window thread. - * @todo Implement accelerometer input in front-end. - * @return std::tuple of (x, y, z) - */ - std::tuple GetAccelerometerState() const { - // stubbed - return std::make_tuple(0, -512, 0); - } - - /** - * Gets the current gyroscope state (angular rates about each three axis). - * Axis explained: - * +x is the same direction as LEFT on D-pad. - * +y is normal to the touch screen, pointing outward. - * +z is the same direction as UP on D-pad. - * Orientation is determined by right-hand rule. - * Units: - * 1 unit of return value = (1/coef) deg/sec, - * where coef is the return value of GetGyroscopeRawToDpsCoefficient(). - * @note This should be called by the core emu thread to get a state set by the window thread. - * @todo Implement gyroscope input in front-end. - * @return std::tuple of (x, y, z) - */ - std::tuple GetGyroscopeState() const { - // stubbed - return std::make_tuple(0, 0, 0); - } - - /** - * Gets the coefficient for units conversion of gyroscope state. - * The conversion formula is r = coefficient * v, - * where v is angular rate in deg/sec, - * and r is the gyroscope state. - * @return float-type coefficient - */ - f32 GetGyroscopeRawToDpsCoefficient() const { - return 14.375f; // taken from hw test, and gyroscope's document - } - - /** - * Returns currently active configuration. - * @note Accesses to the returned object need not be consistent because it may be modified in - * another thread - */ - const WindowConfig& GetActiveConfig() const { - return active_config; - } - - /** - * Requests the internal configuration to be replaced by the specified argument at some point in - * the future. - * @note This method is thread-safe, because it delays configuration changes to the GUI event - * loop. Hence there is no guarantee on when the requested configuration will be active. - */ - void SetConfig(const WindowConfig& val) { - config = val; - } - - /** - * Gets the framebuffer layout (width, height, and screen regions) - * @note This method is thread-safe - */ - const Layout::FramebufferLayout& GetFramebufferLayout() const { - return framebuffer_layout; - } - - /** - * Convenience method to update the current frame layout - * Read from the current settings to determine which layout to use. - */ - 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; - pad_state.hex = 0; - touch_x = 0; - touch_y = 0; - circle_pad_x = 0; - circle_pad_y = 0; - touch_pressed = false; - } - virtual ~EmuWindow() {} - - /** - * Processes any pending configuration changes from the last SetConfig call. - * This method invokes OnMinimalClientAreaChangeRequest if the corresponding configuration - * field changed. - * @note Implementations will usually want to call this from the GUI thread. - * @todo Actually call this in existing implementations. - */ - void ProcessConfigurationChanges() { - // TODO: For proper thread safety, we should eventually implement a proper - // multiple-writer/single-reader queue... - - if (config.min_client_area_size != active_config.min_client_area_size) { - OnMinimalClientAreaChangeRequest(config.min_client_area_size); - config.min_client_area_size = active_config.min_client_area_size; - } - } - - /** - * Update framebuffer layout with the given parameter. - * @note EmuWindow implementations will usually use this in window resize event handlers. - */ - void NotifyFramebufferLayoutChanged(const Layout::FramebufferLayout& layout) { - framebuffer_layout = layout; - } - - /** - * Update internal client area size with the given parameter. - * @note EmuWindow implementations will usually use this in window resize event handlers. - */ - void NotifyClientAreaSizeChanged(const std::pair& size) { - client_area_width = size.first; - client_area_height = size.second; - } - -private: - /** - * Handler called when the minimal client area was requested to be changed via SetConfig. - * For the request to be honored, EmuWindow implementations will usually reimplement this - * function. - */ - virtual void OnMinimalClientAreaChangeRequest( - const std::pair& minimal_size) { - // By default, ignore this request and do nothing. - } - - Layout::FramebufferLayout framebuffer_layout; ///< Current framebuffer layout - - unsigned client_area_width; ///< Current client width, should be set by window impl. - unsigned client_area_height; ///< Current client height, should be set by window impl. - - WindowConfig config; ///< Internal configuration (changes pending for being applied in - /// 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) - - s16 circle_pad_x; ///< Circle pad X-position in native 3DS pixel coordinates (-156 - 156) - s16 circle_pad_y; ///< Circle pad Y-position in native 3DS pixel coordinates (-156 - 156) - - /** - * Clip the provided coordinates to be inside the touchscreen area. - */ - std::tuple ClipToTouchScreen(unsigned new_x, unsigned new_y); - - Service::HID::PadState pad_state; -}; diff --git a/src/common/key_map.cpp b/src/common/key_map.cpp deleted file mode 100644 index 97cafe9c9..000000000 --- a/src/common/key_map.cpp +++ /dev/null @@ -1,152 +0,0 @@ -// Copyright 2014 Citra Emulator Project -// Licensed under GPLv2 or any later version -// Refer to the license.txt file included. - -#include -#include "common/emu_window.h" -#include "common/key_map.h" - -namespace KeyMap { - -// TODO (wwylele): currently we treat c-stick as four direction buttons -// and map it directly to EmuWindow::ButtonPressed. -// It should go the analog input way like circle pad does. -const std::array mapping_targets = {{ - Service::HID::PAD_A, - Service::HID::PAD_B, - Service::HID::PAD_X, - Service::HID::PAD_Y, - Service::HID::PAD_L, - Service::HID::PAD_R, - Service::HID::PAD_ZL, - Service::HID::PAD_ZR, - Service::HID::PAD_START, - Service::HID::PAD_SELECT, - Service::HID::PAD_NONE, - Service::HID::PAD_UP, - Service::HID::PAD_DOWN, - Service::HID::PAD_LEFT, - Service::HID::PAD_RIGHT, - Service::HID::PAD_C_UP, - Service::HID::PAD_C_DOWN, - Service::HID::PAD_C_LEFT, - Service::HID::PAD_C_RIGHT, - - IndirectTarget::CirclePadUp, - IndirectTarget::CirclePadDown, - IndirectTarget::CirclePadLeft, - IndirectTarget::CirclePadRight, - IndirectTarget::CirclePadModifier, -}}; - -static std::map key_map; -static int next_device_id = 0; - -static bool circle_pad_up = false; -static bool circle_pad_down = false; -static bool circle_pad_left = false; -static bool circle_pad_right = false; -static bool circle_pad_modifier = false; - -static void UpdateCirclePad(EmuWindow& emu_window) { - constexpr float SQRT_HALF = 0.707106781f; - int x = 0, y = 0; - - if (circle_pad_right) - ++x; - if (circle_pad_left) - --x; - if (circle_pad_up) - ++y; - if (circle_pad_down) - --y; - - float modifier = circle_pad_modifier ? Settings::values.pad_circle_modifier_scale : 1.0f; - emu_window.CirclePadUpdated(x * modifier * (y == 0 ? 1.0f : SQRT_HALF), - y * modifier * (x == 0 ? 1.0f : SQRT_HALF)); -} - -int NewDeviceId() { - return next_device_id++; -} - -void SetKeyMapping(HostDeviceKey key, KeyTarget target) { - key_map[key] = target; -} - -void ClearKeyMapping(int device_id) { - auto iter = key_map.begin(); - while (iter != key_map.end()) { - if (iter->first.device_id == device_id) - key_map.erase(iter++); - else - ++iter; - } -} - -void PressKey(EmuWindow& emu_window, HostDeviceKey key) { - auto target = key_map.find(key); - if (target == key_map.end()) - return; - - if (target->second.direct) { - emu_window.ButtonPressed({{target->second.target.direct_target_hex}}); - } else { - switch (target->second.target.indirect_target) { - case IndirectTarget::CirclePadUp: - circle_pad_up = true; - UpdateCirclePad(emu_window); - break; - case IndirectTarget::CirclePadDown: - circle_pad_down = true; - UpdateCirclePad(emu_window); - break; - case IndirectTarget::CirclePadLeft: - circle_pad_left = true; - UpdateCirclePad(emu_window); - break; - case IndirectTarget::CirclePadRight: - circle_pad_right = true; - UpdateCirclePad(emu_window); - break; - case IndirectTarget::CirclePadModifier: - circle_pad_modifier = true; - UpdateCirclePad(emu_window); - break; - } - } -} - -void ReleaseKey(EmuWindow& emu_window, HostDeviceKey key) { - auto target = key_map.find(key); - if (target == key_map.end()) - return; - - if (target->second.direct) { - emu_window.ButtonReleased({{target->second.target.direct_target_hex}}); - } else { - switch (target->second.target.indirect_target) { - case IndirectTarget::CirclePadUp: - circle_pad_up = false; - UpdateCirclePad(emu_window); - break; - case IndirectTarget::CirclePadDown: - circle_pad_down = false; - UpdateCirclePad(emu_window); - break; - case IndirectTarget::CirclePadLeft: - circle_pad_left = false; - UpdateCirclePad(emu_window); - break; - case IndirectTarget::CirclePadRight: - circle_pad_right = false; - UpdateCirclePad(emu_window); - break; - case IndirectTarget::CirclePadModifier: - circle_pad_modifier = false; - UpdateCirclePad(emu_window); - break; - } - } -} -} diff --git a/src/common/key_map.h b/src/common/key_map.h deleted file mode 100644 index 040794578..000000000 --- a/src/common/key_map.h +++ /dev/null @@ -1,93 +0,0 @@ -// Copyright 2014 Citra Emulator Project -// Licensed under GPLv2 or any later version -// Refer to the license.txt file included. - -#pragma once - -#include -#include -#include "core/hle/service/hid/hid.h" - -class EmuWindow; - -namespace KeyMap { - -/** - * Represents key mapping targets that are not real 3DS buttons. - * They will be handled by KeyMap and translated to 3DS input. - */ -enum class IndirectTarget { - CirclePadUp, - CirclePadDown, - CirclePadLeft, - CirclePadRight, - CirclePadModifier, -}; - -/** - * Represents a key mapping target. It can be a PadState that represents real 3DS buttons, - * or an IndirectTarget. - */ -struct KeyTarget { - bool direct; - union { - u32 direct_target_hex; - IndirectTarget indirect_target; - } target; - - KeyTarget() : direct(true) { - target.direct_target_hex = 0; - } - - KeyTarget(Service::HID::PadState pad) : direct(true) { - target.direct_target_hex = pad.hex; - } - - KeyTarget(IndirectTarget i) : direct(false) { - target.indirect_target = i; - } -}; - -/** - * Represents a key for a specific host device. - */ -struct HostDeviceKey { - int key_code; - int device_id; ///< Uniquely identifies a host device - - bool operator<(const HostDeviceKey& other) const { - return std::tie(key_code, device_id) < std::tie(other.key_code, other.device_id); - } - - bool operator==(const HostDeviceKey& other) const { - return std::tie(key_code, device_id) == std::tie(other.key_code, other.device_id); - } -}; - -extern const std::array mapping_targets; - -/** - * Generates a new device id, which uniquely identifies a host device within KeyMap. - */ -int NewDeviceId(); - -/** - * Maps a device-specific key to a target (a PadState or an IndirectTarget). - */ -void SetKeyMapping(HostDeviceKey key, KeyTarget target); - -/** - * Clears all key mappings belonging to one device. - */ -void ClearKeyMapping(int device_id); - -/** - * Maps a key press action and call the corresponding function in EmuWindow - */ -void PressKey(EmuWindow& emu_window, HostDeviceKey key); - -/** - * Maps a key release action and call the corresponding function in EmuWindow - */ -void ReleaseKey(EmuWindow& emu_window, HostDeviceKey key); -} diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index ccbe7a9ce..3621449b3 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -29,6 +29,8 @@ set(SRCS file_sys/ivfc_archive.cpp file_sys/path_parser.cpp file_sys/savedata_archive.cpp + frontend/emu_window.cpp + frontend/key_map.cpp gdbstub/gdbstub.cpp hle/config_mem.cpp hle/applets/applet.cpp @@ -198,6 +200,8 @@ set(HEADERS file_sys/ivfc_archive.h file_sys/path_parser.h file_sys/savedata_archive.h + frontend/emu_window.h + frontend/key_map.h gdbstub/gdbstub.h hle/config_mem.h hle/function_wrappers.h diff --git a/src/core/frontend/emu_window.cpp b/src/core/frontend/emu_window.cpp new file mode 100644 index 000000000..f6f90f9e1 --- /dev/null +++ b/src/core/frontend/emu_window.cpp @@ -0,0 +1,107 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include +#include +#include "common/assert.h" +#include "core/frontend/emu_window.h" +#include "core/frontend/key_map.h" +#include "video_core/video_core.h" + +void EmuWindow::ButtonPressed(Service::HID::PadState pad) { + pad_state.hex |= pad.hex; +} + +void EmuWindow::ButtonReleased(Service::HID::PadState pad) { + pad_state.hex &= ~pad.hex; +} + +void EmuWindow::CirclePadUpdated(float x, float y) { + constexpr int MAX_CIRCLEPAD_POS = 0x9C; // Max value for a circle pad position + + // Make sure the coordinates are in the unit circle, + // otherwise normalize it. + float r = x * x + y * y; + if (r > 1) { + r = std::sqrt(r); + x /= r; + y /= r; + } + + circle_pad_x = static_cast(x * MAX_CIRCLEPAD_POS); + circle_pad_y = static_cast(y * MAX_CIRCLEPAD_POS); +} + +/** + * 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 + * @param framebuffer_x Framebuffer x-coordinate to check + * @param framebuffer_y Framebuffer y-coordinate to check + * @return True if the coordinates are within the touchpad, otherwise false + */ +static bool IsWithinTouchscreen(const Layout::FramebufferLayout& layout, unsigned framebuffer_x, + unsigned framebuffer_y) { + return ( + framebuffer_y >= layout.bottom_screen.top && framebuffer_y < layout.bottom_screen.bottom && + framebuffer_x >= layout.bottom_screen.left && framebuffer_x < layout.bottom_screen.right); +} + +std::tuple EmuWindow::ClipToTouchScreen(unsigned new_x, unsigned new_y) { + new_x = std::max(new_x, framebuffer_layout.bottom_screen.left); + new_x = std::min(new_x, framebuffer_layout.bottom_screen.right - 1); + + new_y = std::max(new_y, framebuffer_layout.bottom_screen.top); + new_y = std::min(new_y, framebuffer_layout.bottom_screen.bottom - 1); + + return std::make_tuple(new_x, new_y); +} + +void EmuWindow::TouchPressed(unsigned framebuffer_x, unsigned framebuffer_y) { + if (!IsWithinTouchscreen(framebuffer_layout, framebuffer_x, framebuffer_y)) + return; + + touch_x = VideoCore::kScreenBottomWidth * + (framebuffer_x - framebuffer_layout.bottom_screen.left) / + (framebuffer_layout.bottom_screen.right - framebuffer_layout.bottom_screen.left); + touch_y = VideoCore::kScreenBottomHeight * + (framebuffer_y - framebuffer_layout.bottom_screen.top) / + (framebuffer_layout.bottom_screen.bottom - framebuffer_layout.bottom_screen.top); + + touch_pressed = true; + pad_state.touch.Assign(1); +} + +void EmuWindow::TouchReleased() { + touch_pressed = false; + touch_x = 0; + touch_y = 0; + pad_state.touch.Assign(0); +} + +void EmuWindow::TouchMoved(unsigned framebuffer_x, unsigned framebuffer_y) { + if (!touch_pressed) + return; + + if (!IsWithinTouchscreen(framebuffer_layout, framebuffer_x, framebuffer_y)) + std::tie(framebuffer_x, framebuffer_y) = ClipToTouchScreen(framebuffer_x, framebuffer_y); + + TouchPressed(framebuffer_x, framebuffer_y); +} + +void EmuWindow::UpdateCurrentFramebufferLayout(unsigned width, unsigned height) { + Layout::FramebufferLayout layout; + switch (Settings::values.layout_option) { + case Settings::LayoutOption::SingleScreen: + layout = Layout::SingleFrameLayout(width, height, Settings::values.swap_screen); + break; + case Settings::LayoutOption::LargeScreen: + layout = Layout::LargeFrameLayout(width, height, Settings::values.swap_screen); + break; + case Settings::LayoutOption::Default: + default: + layout = Layout::DefaultFrameLayout(width, height, Settings::values.swap_screen); + break; + } + NotifyFramebufferLayoutChanged(layout); +} diff --git a/src/core/frontend/emu_window.h b/src/core/frontend/emu_window.h new file mode 100644 index 000000000..835c4d500 --- /dev/null +++ b/src/core/frontend/emu_window.h @@ -0,0 +1,290 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include +#include +#include "common/common_types.h" +#include "common/framebuffer_layout.h" +#include "common/math_util.h" +#include "core/hle/service/hid/hid.h" + +/** + * Abstraction class used to provide an interface between emulation code and the frontend + * (e.g. SDL, QGLWidget, GLFW, etc...). + * + * Design notes on the interaction between EmuWindow and the emulation core: + * - Generally, decisions on anything visible to the user should be left up to the GUI. + * For example, the emulation core should not try to dictate some window title or size. + * This stuff is not the core's business and only causes problems with regards to thread-safety + * anyway. + * - Under certain circumstances, it may be desirable for the core to politely request the GUI + * to set e.g. a minimum window size. However, the GUI should always be free to ignore any + * such hints. + * - EmuWindow may expose some of its state as read-only to the emulation core, however care + * should be taken to make sure the provided information is self-consistent. This requires + * some sort of synchronization (most of this is still a TODO). + * - DO NOT TREAT THIS CLASS AS A GUI TOOLKIT ABSTRACTION LAYER. That's not what it is. Please + * re-read the upper points again and think about it if you don't see this. + */ +class EmuWindow { +public: + /// Data structure to store emuwindow configuration + struct WindowConfig { + bool fullscreen; + int res_width; + int res_height; + std::pair min_client_area_size; + }; + + /// Swap buffers to display the next frame + virtual void SwapBuffers() = 0; + + /// Polls window events + virtual void PollEvents() = 0; + + /// Makes the graphics context current for the caller thread + virtual void MakeCurrent() = 0; + + /// Releases (dunno if this is the "right" word) the GLFW context from the caller thread + virtual void DoneCurrent() = 0; + + virtual void ReloadSetKeymaps() = 0; + + /** + * Signals a button press action to the HID module. + * @param pad_state indicates which button to press + * @note only handles real buttons (A/B/X/Y/...), excluding analog inputs like the circle pad. + */ + void ButtonPressed(Service::HID::PadState pad_state); + + /** + * Signals a button release action to the HID module. + * @param pad_state indicates which button to press + * @note only handles real buttons (A/B/X/Y/...), excluding analog inputs like the circle pad. + */ + void ButtonReleased(Service::HID::PadState pad_state); + + /** + * Signals a circle pad change action to the HID module. + * @param x new x-coordinate of the circle pad, in the range [-1.0, 1.0] + * @param y new y-coordinate of the circle pad, in the range [-1.0, 1.0] + * @note the coordinates will be normalized if the radius is larger than 1 + */ + void CirclePadUpdated(float x, float y); + + /** + * Signal that a touch pressed event has occurred (e.g. mouse click pressed) + * @param framebuffer_x Framebuffer x-coordinate that was pressed + * @param framebuffer_y Framebuffer y-coordinate that was pressed + */ + void TouchPressed(unsigned framebuffer_x, unsigned framebuffer_y); + + /// Signal that a touch released event has occurred (e.g. mouse click released) + void TouchReleased(); + + /** + * Signal that a touch movement event has occurred (e.g. mouse was moved over the emu window) + * @param framebuffer_x Framebuffer x-coordinate + * @param framebuffer_y Framebuffer y-coordinate + */ + void TouchMoved(unsigned framebuffer_x, unsigned framebuffer_y); + + /** + * Gets the current pad state (which buttons are pressed). + * @note This should be called by the core emu thread to get a state set by the window thread. + * @note This doesn't include analog input like circle pad direction + * @todo Fix this function to be thread-safe. + * @return PadState object indicating the current pad state + */ + Service::HID::PadState GetPadState() const { + return pad_state; + } + + /** + * Gets the current circle pad state. + * @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), where `x` and `y` are the circle pad coordinates + */ + std::tuple GetCirclePadState() const { + return std::make_tuple(circle_pad_x, circle_pad_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 GetTouchState() const { + return std::make_tuple(touch_x, touch_y, touch_pressed); + } + + /** + * Gets the current accelerometer state (acceleration along each three axis). + * Axis explained: + * +x is the same direction as LEFT on D-pad. + * +y is normal to the touch screen, pointing outward. + * +z is the same direction as UP on D-pad. + * Units: + * 1 unit of return value = 1/512 g (measured by hw test), + * where g is the gravitational acceleration (9.8 m/sec2). + * @note This should be called by the core emu thread to get a state set by the window thread. + * @todo Implement accelerometer input in front-end. + * @return std::tuple of (x, y, z) + */ + std::tuple GetAccelerometerState() const { + // stubbed + return std::make_tuple(0, -512, 0); + } + + /** + * Gets the current gyroscope state (angular rates about each three axis). + * Axis explained: + * +x is the same direction as LEFT on D-pad. + * +y is normal to the touch screen, pointing outward. + * +z is the same direction as UP on D-pad. + * Orientation is determined by right-hand rule. + * Units: + * 1 unit of return value = (1/coef) deg/sec, + * where coef is the return value of GetGyroscopeRawToDpsCoefficient(). + * @note This should be called by the core emu thread to get a state set by the window thread. + * @todo Implement gyroscope input in front-end. + * @return std::tuple of (x, y, z) + */ + std::tuple GetGyroscopeState() const { + // stubbed + return std::make_tuple(0, 0, 0); + } + + /** + * Gets the coefficient for units conversion of gyroscope state. + * The conversion formula is r = coefficient * v, + * where v is angular rate in deg/sec, + * and r is the gyroscope state. + * @return float-type coefficient + */ + f32 GetGyroscopeRawToDpsCoefficient() const { + return 14.375f; // taken from hw test, and gyroscope's document + } + + /** + * Returns currently active configuration. + * @note Accesses to the returned object need not be consistent because it may be modified in + * another thread + */ + const WindowConfig& GetActiveConfig() const { + return active_config; + } + + /** + * Requests the internal configuration to be replaced by the specified argument at some point in + * the future. + * @note This method is thread-safe, because it delays configuration changes to the GUI event + * loop. Hence there is no guarantee on when the requested configuration will be active. + */ + void SetConfig(const WindowConfig& val) { + config = val; + } + + /** + * Gets the framebuffer layout (width, height, and screen regions) + * @note This method is thread-safe + */ + const Layout::FramebufferLayout& GetFramebufferLayout() const { + return framebuffer_layout; + } + + /** + * Convenience method to update the current frame layout + * Read from the current settings to determine which layout to use. + */ + 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; + pad_state.hex = 0; + touch_x = 0; + touch_y = 0; + circle_pad_x = 0; + circle_pad_y = 0; + touch_pressed = false; + } + virtual ~EmuWindow() {} + + /** + * Processes any pending configuration changes from the last SetConfig call. + * This method invokes OnMinimalClientAreaChangeRequest if the corresponding configuration + * field changed. + * @note Implementations will usually want to call this from the GUI thread. + * @todo Actually call this in existing implementations. + */ + void ProcessConfigurationChanges() { + // TODO: For proper thread safety, we should eventually implement a proper + // multiple-writer/single-reader queue... + + if (config.min_client_area_size != active_config.min_client_area_size) { + OnMinimalClientAreaChangeRequest(config.min_client_area_size); + config.min_client_area_size = active_config.min_client_area_size; + } + } + + /** + * Update framebuffer layout with the given parameter. + * @note EmuWindow implementations will usually use this in window resize event handlers. + */ + void NotifyFramebufferLayoutChanged(const Layout::FramebufferLayout& layout) { + framebuffer_layout = layout; + } + + /** + * Update internal client area size with the given parameter. + * @note EmuWindow implementations will usually use this in window resize event handlers. + */ + void NotifyClientAreaSizeChanged(const std::pair& size) { + client_area_width = size.first; + client_area_height = size.second; + } + +private: + /** + * Handler called when the minimal client area was requested to be changed via SetConfig. + * For the request to be honored, EmuWindow implementations will usually reimplement this + * function. + */ + virtual void OnMinimalClientAreaChangeRequest( + const std::pair& minimal_size) { + // By default, ignore this request and do nothing. + } + + Layout::FramebufferLayout framebuffer_layout; ///< Current framebuffer layout + + unsigned client_area_width; ///< Current client width, should be set by window impl. + unsigned client_area_height; ///< Current client height, should be set by window impl. + + WindowConfig config; ///< Internal configuration (changes pending for being applied in + /// 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) + + s16 circle_pad_x; ///< Circle pad X-position in native 3DS pixel coordinates (-156 - 156) + s16 circle_pad_y; ///< Circle pad Y-position in native 3DS pixel coordinates (-156 - 156) + + /** + * Clip the provided coordinates to be inside the touchscreen area. + */ + std::tuple ClipToTouchScreen(unsigned new_x, unsigned new_y); + + Service::HID::PadState pad_state; +}; diff --git a/src/core/frontend/key_map.cpp b/src/core/frontend/key_map.cpp new file mode 100644 index 000000000..15f0e079c --- /dev/null +++ b/src/core/frontend/key_map.cpp @@ -0,0 +1,152 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include +#include "core/frontend/emu_window.h" +#include "core/frontend/key_map.h" + +namespace KeyMap { + +// TODO (wwylele): currently we treat c-stick as four direction buttons +// and map it directly to EmuWindow::ButtonPressed. +// It should go the analog input way like circle pad does. +const std::array mapping_targets = {{ + Service::HID::PAD_A, + Service::HID::PAD_B, + Service::HID::PAD_X, + Service::HID::PAD_Y, + Service::HID::PAD_L, + Service::HID::PAD_R, + Service::HID::PAD_ZL, + Service::HID::PAD_ZR, + Service::HID::PAD_START, + Service::HID::PAD_SELECT, + Service::HID::PAD_NONE, + Service::HID::PAD_UP, + Service::HID::PAD_DOWN, + Service::HID::PAD_LEFT, + Service::HID::PAD_RIGHT, + Service::HID::PAD_C_UP, + Service::HID::PAD_C_DOWN, + Service::HID::PAD_C_LEFT, + Service::HID::PAD_C_RIGHT, + + IndirectTarget::CirclePadUp, + IndirectTarget::CirclePadDown, + IndirectTarget::CirclePadLeft, + IndirectTarget::CirclePadRight, + IndirectTarget::CirclePadModifier, +}}; + +static std::map key_map; +static int next_device_id = 0; + +static bool circle_pad_up = false; +static bool circle_pad_down = false; +static bool circle_pad_left = false; +static bool circle_pad_right = false; +static bool circle_pad_modifier = false; + +static void UpdateCirclePad(EmuWindow& emu_window) { + constexpr float SQRT_HALF = 0.707106781f; + int x = 0, y = 0; + + if (circle_pad_right) + ++x; + if (circle_pad_left) + --x; + if (circle_pad_up) + ++y; + if (circle_pad_down) + --y; + + float modifier = circle_pad_modifier ? Settings::values.pad_circle_modifier_scale : 1.0f; + emu_window.CirclePadUpdated(x * modifier * (y == 0 ? 1.0f : SQRT_HALF), + y * modifier * (x == 0 ? 1.0f : SQRT_HALF)); +} + +int NewDeviceId() { + return next_device_id++; +} + +void SetKeyMapping(HostDeviceKey key, KeyTarget target) { + key_map[key] = target; +} + +void ClearKeyMapping(int device_id) { + auto iter = key_map.begin(); + while (iter != key_map.end()) { + if (iter->first.device_id == device_id) + key_map.erase(iter++); + else + ++iter; + } +} + +void PressKey(EmuWindow& emu_window, HostDeviceKey key) { + auto target = key_map.find(key); + if (target == key_map.end()) + return; + + if (target->second.direct) { + emu_window.ButtonPressed({{target->second.target.direct_target_hex}}); + } else { + switch (target->second.target.indirect_target) { + case IndirectTarget::CirclePadUp: + circle_pad_up = true; + UpdateCirclePad(emu_window); + break; + case IndirectTarget::CirclePadDown: + circle_pad_down = true; + UpdateCirclePad(emu_window); + break; + case IndirectTarget::CirclePadLeft: + circle_pad_left = true; + UpdateCirclePad(emu_window); + break; + case IndirectTarget::CirclePadRight: + circle_pad_right = true; + UpdateCirclePad(emu_window); + break; + case IndirectTarget::CirclePadModifier: + circle_pad_modifier = true; + UpdateCirclePad(emu_window); + break; + } + } +} + +void ReleaseKey(EmuWindow& emu_window, HostDeviceKey key) { + auto target = key_map.find(key); + if (target == key_map.end()) + return; + + if (target->second.direct) { + emu_window.ButtonReleased({{target->second.target.direct_target_hex}}); + } else { + switch (target->second.target.indirect_target) { + case IndirectTarget::CirclePadUp: + circle_pad_up = false; + UpdateCirclePad(emu_window); + break; + case IndirectTarget::CirclePadDown: + circle_pad_down = false; + UpdateCirclePad(emu_window); + break; + case IndirectTarget::CirclePadLeft: + circle_pad_left = false; + UpdateCirclePad(emu_window); + break; + case IndirectTarget::CirclePadRight: + circle_pad_right = false; + UpdateCirclePad(emu_window); + break; + case IndirectTarget::CirclePadModifier: + circle_pad_modifier = false; + UpdateCirclePad(emu_window); + break; + } + } +} +} diff --git a/src/core/frontend/key_map.h b/src/core/frontend/key_map.h new file mode 100644 index 000000000..040794578 --- /dev/null +++ b/src/core/frontend/key_map.h @@ -0,0 +1,93 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include +#include +#include "core/hle/service/hid/hid.h" + +class EmuWindow; + +namespace KeyMap { + +/** + * Represents key mapping targets that are not real 3DS buttons. + * They will be handled by KeyMap and translated to 3DS input. + */ +enum class IndirectTarget { + CirclePadUp, + CirclePadDown, + CirclePadLeft, + CirclePadRight, + CirclePadModifier, +}; + +/** + * Represents a key mapping target. It can be a PadState that represents real 3DS buttons, + * or an IndirectTarget. + */ +struct KeyTarget { + bool direct; + union { + u32 direct_target_hex; + IndirectTarget indirect_target; + } target; + + KeyTarget() : direct(true) { + target.direct_target_hex = 0; + } + + KeyTarget(Service::HID::PadState pad) : direct(true) { + target.direct_target_hex = pad.hex; + } + + KeyTarget(IndirectTarget i) : direct(false) { + target.indirect_target = i; + } +}; + +/** + * Represents a key for a specific host device. + */ +struct HostDeviceKey { + int key_code; + int device_id; ///< Uniquely identifies a host device + + bool operator<(const HostDeviceKey& other) const { + return std::tie(key_code, device_id) < std::tie(other.key_code, other.device_id); + } + + bool operator==(const HostDeviceKey& other) const { + return std::tie(key_code, device_id) == std::tie(other.key_code, other.device_id); + } +}; + +extern const std::array mapping_targets; + +/** + * Generates a new device id, which uniquely identifies a host device within KeyMap. + */ +int NewDeviceId(); + +/** + * Maps a device-specific key to a target (a PadState or an IndirectTarget). + */ +void SetKeyMapping(HostDeviceKey key, KeyTarget target); + +/** + * Clears all key mappings belonging to one device. + */ +void ClearKeyMapping(int device_id); + +/** + * Maps a key press action and call the corresponding function in EmuWindow + */ +void PressKey(EmuWindow& emu_window, HostDeviceKey key); + +/** + * Maps a key release action and call the corresponding function in EmuWindow + */ +void ReleaseKey(EmuWindow& emu_window, HostDeviceKey key); +} diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp index 18a1b6a16..676154bd4 100644 --- a/src/core/hle/service/hid/hid.cpp +++ b/src/core/hle/service/hid/hid.cpp @@ -3,9 +3,9 @@ // Refer to the license.txt file included. #include -#include "common/emu_window.h" #include "common/logging/log.h" #include "core/core_timing.h" +#include "core/frontend/emu_window.h" #include "core/hle/kernel/event.h" #include "core/hle/kernel/shared_memory.h" #include "core/hle/service/hid/hid.h" diff --git a/src/core/settings.cpp b/src/core/settings.cpp index 626e06cd9..5d23c52f9 100644 --- a/src/core/settings.cpp +++ b/src/core/settings.cpp @@ -7,7 +7,7 @@ #include "settings.h" #include "video_core/video_core.h" -#include "common/emu_window.h" +#include "core/frontend/emu_window.h" namespace Settings { diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp index 0b2e48407..85aa06cd5 100644 --- a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp +++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp @@ -11,11 +11,11 @@ #include #include #include "common/bit_field.h" -#include "common/emu_window.h" #include "common/logging/log.h" #include "common/math_util.h" #include "common/microprofile.h" #include "common/vector_math.h" +#include "core/frontend/emu_window.h" #include "core/memory.h" #include "video_core/debug_utils/debug_utils.h" #include "video_core/pica_state.h" diff --git a/src/video_core/renderer_opengl/renderer_opengl.cpp b/src/video_core/renderer_opengl/renderer_opengl.cpp index 93f0ac105..2aa90e5c1 100644 --- a/src/video_core/renderer_opengl/renderer_opengl.cpp +++ b/src/video_core/renderer_opengl/renderer_opengl.cpp @@ -9,10 +9,10 @@ #include #include "common/assert.h" #include "common/bit_field.h" -#include "common/emu_window.h" #include "common/logging/log.h" #include "common/profiler_reporting.h" #include "common/synchronized_wrapper.h" +#include "core/frontend/emu_window.h" #include "core/hw/gpu.h" #include "core/hw/hw.h" #include "core/hw/lcd.h" -- cgit v1.2.3