diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/citra_qt/bootmanager.cpp | 1 | ||||
| -rw-r--r-- | src/core/CMakeLists.txt | 2 | ||||
| -rw-r--r-- | src/core/frontend/emu_window.cpp | 26 | ||||
| -rw-r--r-- | src/core/frontend/emu_window.h | 52 | ||||
| -rw-r--r-- | src/core/frontend/key_map.cpp | 152 | ||||
| -rw-r--r-- | src/core/frontend/key_map.h | 93 | ||||
| -rw-r--r-- | src/core/hle/service/hid/hid.h | 34 | ||||
| -rw-r--r-- | src/core/settings.h | 54 | ||||
| -rw-r--r-- | src/video_core/renderer_opengl/gl_rasterizer_cache.cpp | 1 |
9 files changed, 3 insertions, 412 deletions
diff --git a/src/citra_qt/bootmanager.cpp b/src/citra_qt/bootmanager.cpp index 66c883d9a..28264df9a 100644 --- a/src/citra_qt/bootmanager.cpp +++ b/src/citra_qt/bootmanager.cpp | |||
| @@ -13,6 +13,7 @@ | |||
| 13 | #include "common/scm_rev.h" | 13 | #include "common/scm_rev.h" |
| 14 | #include "common/string_util.h" | 14 | #include "common/string_util.h" |
| 15 | #include "core/core.h" | 15 | #include "core/core.h" |
| 16 | #include "core/settings.h" | ||
| 16 | #include "input_common/keyboard.h" | 17 | #include "input_common/keyboard.h" |
| 17 | #include "input_common/main.h" | 18 | #include "input_common/main.h" |
| 18 | #include "video_core/debug_utils/debug_utils.h" | 19 | #include "video_core/debug_utils/debug_utils.h" |
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index dd9f6df41..61a0b1cc3 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt | |||
| @@ -34,7 +34,6 @@ set(SRCS | |||
| 34 | frontend/camera/factory.cpp | 34 | frontend/camera/factory.cpp |
| 35 | frontend/camera/interface.cpp | 35 | frontend/camera/interface.cpp |
| 36 | frontend/emu_window.cpp | 36 | frontend/emu_window.cpp |
| 37 | frontend/key_map.cpp | ||
| 38 | frontend/motion_emu.cpp | 37 | frontend/motion_emu.cpp |
| 39 | gdbstub/gdbstub.cpp | 38 | gdbstub/gdbstub.cpp |
| 40 | hle/config_mem.cpp | 39 | hle/config_mem.cpp |
| @@ -219,7 +218,6 @@ set(HEADERS | |||
| 219 | frontend/camera/interface.h | 218 | frontend/camera/interface.h |
| 220 | frontend/emu_window.h | 219 | frontend/emu_window.h |
| 221 | frontend/input.h | 220 | frontend/input.h |
| 222 | frontend/key_map.h | ||
| 223 | frontend/motion_emu.h | 221 | frontend/motion_emu.h |
| 224 | gdbstub/gdbstub.h | 222 | gdbstub/gdbstub.h |
| 225 | hle/config_mem.h | 223 | hle/config_mem.h |
diff --git a/src/core/frontend/emu_window.cpp b/src/core/frontend/emu_window.cpp index a155b657d..73a44bfe7 100644 --- a/src/core/frontend/emu_window.cpp +++ b/src/core/frontend/emu_window.cpp | |||
| @@ -7,33 +7,9 @@ | |||
| 7 | #include "common/assert.h" | 7 | #include "common/assert.h" |
| 8 | #include "core/core.h" | 8 | #include "core/core.h" |
| 9 | #include "core/frontend/emu_window.h" | 9 | #include "core/frontend/emu_window.h" |
| 10 | #include "core/frontend/key_map.h" | 10 | #include "core/settings.h" |
| 11 | #include "video_core/video_core.h" | 11 | #include "video_core/video_core.h" |
| 12 | 12 | ||
| 13 | void EmuWindow::ButtonPressed(Service::HID::PadState pad) { | ||
| 14 | pad_state.hex |= pad.hex; | ||
| 15 | } | ||
| 16 | |||
| 17 | void EmuWindow::ButtonReleased(Service::HID::PadState pad) { | ||
| 18 | pad_state.hex &= ~pad.hex; | ||
| 19 | } | ||
| 20 | |||
| 21 | void EmuWindow::CirclePadUpdated(float x, float y) { | ||
| 22 | constexpr int MAX_CIRCLEPAD_POS = 0x9C; // Max value for a circle pad position | ||
| 23 | |||
| 24 | // Make sure the coordinates are in the unit circle, | ||
| 25 | // otherwise normalize it. | ||
| 26 | float r = x * x + y * y; | ||
| 27 | if (r > 1) { | ||
| 28 | r = std::sqrt(r); | ||
| 29 | x /= r; | ||
| 30 | y /= r; | ||
| 31 | } | ||
| 32 | |||
| 33 | circle_pad_x = static_cast<s16>(x * MAX_CIRCLEPAD_POS); | ||
| 34 | circle_pad_y = static_cast<s16>(y * MAX_CIRCLEPAD_POS); | ||
| 35 | } | ||
| 36 | |||
| 37 | /** | 13 | /** |
| 38 | * Check if the given x/y coordinates are within the touchpad specified by the framebuffer layout | 14 | * Check if the given x/y coordinates are within the touchpad specified by the framebuffer layout |
| 39 | * @param layout FramebufferLayout object describing the framebuffer size and screen positions | 15 | * @param layout FramebufferLayout object describing the framebuffer size and screen positions |
diff --git a/src/core/frontend/emu_window.h b/src/core/frontend/emu_window.h index de9b64953..36f2667fa 100644 --- a/src/core/frontend/emu_window.h +++ b/src/core/frontend/emu_window.h | |||
| @@ -10,7 +10,6 @@ | |||
| 10 | #include "common/common_types.h" | 10 | #include "common/common_types.h" |
| 11 | #include "common/framebuffer_layout.h" | 11 | #include "common/framebuffer_layout.h" |
| 12 | #include "common/math_util.h" | 12 | #include "common/math_util.h" |
| 13 | #include "core/hle/service/hid/hid.h" | ||
| 14 | 13 | ||
| 15 | /** | 14 | /** |
| 16 | * Abstraction class used to provide an interface between emulation code and the frontend | 15 | * Abstraction class used to provide an interface between emulation code and the frontend |
| @@ -53,28 +52,6 @@ public: | |||
| 53 | virtual void DoneCurrent() = 0; | 52 | virtual void DoneCurrent() = 0; |
| 54 | 53 | ||
| 55 | /** | 54 | /** |
| 56 | * Signals a button press action to the HID module. | ||
| 57 | * @param pad_state indicates which button to press | ||
| 58 | * @note only handles real buttons (A/B/X/Y/...), excluding analog inputs like the circle pad. | ||
| 59 | */ | ||
| 60 | void ButtonPressed(Service::HID::PadState pad_state); | ||
| 61 | |||
| 62 | /** | ||
| 63 | * Signals a button release action to the HID module. | ||
| 64 | * @param pad_state indicates which button to press | ||
| 65 | * @note only handles real buttons (A/B/X/Y/...), excluding analog inputs like the circle pad. | ||
| 66 | */ | ||
| 67 | void ButtonReleased(Service::HID::PadState pad_state); | ||
| 68 | |||
| 69 | /** | ||
| 70 | * Signals a circle pad change action to the HID module. | ||
| 71 | * @param x new x-coordinate of the circle pad, in the range [-1.0, 1.0] | ||
| 72 | * @param y new y-coordinate of the circle pad, in the range [-1.0, 1.0] | ||
| 73 | * @note the coordinates will be normalized if the radius is larger than 1 | ||
| 74 | */ | ||
| 75 | void CirclePadUpdated(float x, float y); | ||
| 76 | |||
| 77 | /** | ||
| 78 | * Signal that a touch pressed event has occurred (e.g. mouse click pressed) | 55 | * Signal that a touch pressed event has occurred (e.g. mouse click pressed) |
| 79 | * @param framebuffer_x Framebuffer x-coordinate that was pressed | 56 | * @param framebuffer_x Framebuffer x-coordinate that was pressed |
| 80 | * @param framebuffer_y Framebuffer y-coordinate that was pressed | 57 | * @param framebuffer_y Framebuffer y-coordinate that was pressed |
| @@ -113,27 +90,6 @@ public: | |||
| 113 | void GyroscopeChanged(float x, float y, float z); | 90 | void GyroscopeChanged(float x, float y, float z); |
| 114 | 91 | ||
| 115 | /** | 92 | /** |
| 116 | * Gets the current pad state (which buttons are pressed). | ||
| 117 | * @note This should be called by the core emu thread to get a state set by the window thread. | ||
| 118 | * @note This doesn't include analog input like circle pad direction | ||
| 119 | * @todo Fix this function to be thread-safe. | ||
| 120 | * @return PadState object indicating the current pad state | ||
| 121 | */ | ||
| 122 | Service::HID::PadState GetPadState() const { | ||
| 123 | return pad_state; | ||
| 124 | } | ||
| 125 | |||
| 126 | /** | ||
| 127 | * Gets the current circle pad state. | ||
| 128 | * @note This should be called by the core emu thread to get a state set by the window thread. | ||
| 129 | * @todo Fix this function to be thread-safe. | ||
| 130 | * @return std::tuple of (x, y), where `x` and `y` are the circle pad coordinates | ||
| 131 | */ | ||
| 132 | std::tuple<s16, s16> GetCirclePadState() const { | ||
| 133 | return std::make_tuple(circle_pad_x, circle_pad_y); | ||
| 134 | } | ||
| 135 | |||
| 136 | /** | ||
| 137 | * Gets the current touch screen state (touch X/Y coordinates and whether or not it is pressed). | 93 | * Gets the current touch screen state (touch X/Y coordinates and whether or not it is pressed). |
| 138 | * @note This should be called by the core emu thread to get a state set by the window thread. | 94 | * @note This should be called by the core emu thread to get a state set by the window thread. |
| 139 | * @todo Fix this function to be thread-safe. | 95 | * @todo Fix this function to be thread-safe. |
| @@ -228,11 +184,8 @@ protected: | |||
| 228 | // TODO: Find a better place to set this. | 184 | // TODO: Find a better place to set this. |
| 229 | config.min_client_area_size = std::make_pair(400u, 480u); | 185 | config.min_client_area_size = std::make_pair(400u, 480u); |
| 230 | active_config = config; | 186 | active_config = config; |
| 231 | pad_state.hex = 0; | ||
| 232 | touch_x = 0; | 187 | touch_x = 0; |
| 233 | touch_y = 0; | 188 | touch_y = 0; |
| 234 | circle_pad_x = 0; | ||
| 235 | circle_pad_y = 0; | ||
| 236 | touch_pressed = false; | 189 | touch_pressed = false; |
| 237 | accel_x = 0; | 190 | accel_x = 0; |
| 238 | accel_y = -512; | 191 | accel_y = -512; |
| @@ -302,9 +255,6 @@ private: | |||
| 302 | u16 touch_x; ///< Touchpad X-position in native 3DS pixel coordinates (0-320) | 255 | u16 touch_x; ///< Touchpad X-position in native 3DS pixel coordinates (0-320) |
| 303 | u16 touch_y; ///< Touchpad Y-position in native 3DS pixel coordinates (0-240) | 256 | u16 touch_y; ///< Touchpad Y-position in native 3DS pixel coordinates (0-240) |
| 304 | 257 | ||
| 305 | s16 circle_pad_x; ///< Circle pad X-position in native 3DS pixel coordinates (-156 - 156) | ||
| 306 | s16 circle_pad_y; ///< Circle pad Y-position in native 3DS pixel coordinates (-156 - 156) | ||
| 307 | |||
| 308 | std::mutex accel_mutex; | 258 | std::mutex accel_mutex; |
| 309 | s16 accel_x; ///< Accelerometer X-axis value in native 3DS units | 259 | s16 accel_x; ///< Accelerometer X-axis value in native 3DS units |
| 310 | s16 accel_y; ///< Accelerometer Y-axis value in native 3DS units | 260 | s16 accel_y; ///< Accelerometer Y-axis value in native 3DS units |
| @@ -319,6 +269,4 @@ private: | |||
| 319 | * Clip the provided coordinates to be inside the touchscreen area. | 269 | * Clip the provided coordinates to be inside the touchscreen area. |
| 320 | */ | 270 | */ |
| 321 | std::tuple<unsigned, unsigned> ClipToTouchScreen(unsigned new_x, unsigned new_y); | 271 | std::tuple<unsigned, unsigned> ClipToTouchScreen(unsigned new_x, unsigned new_y); |
| 322 | |||
| 323 | Service::HID::PadState pad_state; | ||
| 324 | }; | 272 | }; |
diff --git a/src/core/frontend/key_map.cpp b/src/core/frontend/key_map.cpp deleted file mode 100644 index 15f0e079c..000000000 --- a/src/core/frontend/key_map.cpp +++ /dev/null | |||
| @@ -1,152 +0,0 @@ | |||
| 1 | // Copyright 2014 Citra Emulator Project | ||
| 2 | // Licensed under GPLv2 or any later version | ||
| 3 | // Refer to the license.txt file included. | ||
| 4 | |||
| 5 | #include <map> | ||
| 6 | #include "core/frontend/emu_window.h" | ||
| 7 | #include "core/frontend/key_map.h" | ||
| 8 | |||
| 9 | namespace KeyMap { | ||
| 10 | |||
| 11 | // TODO (wwylele): currently we treat c-stick as four direction buttons | ||
| 12 | // and map it directly to EmuWindow::ButtonPressed. | ||
| 13 | // It should go the analog input way like circle pad does. | ||
| 14 | const std::array<KeyTarget, Settings::NativeInput::NUM_INPUTS> mapping_targets = {{ | ||
| 15 | Service::HID::PAD_A, | ||
| 16 | Service::HID::PAD_B, | ||
| 17 | Service::HID::PAD_X, | ||
| 18 | Service::HID::PAD_Y, | ||
| 19 | Service::HID::PAD_L, | ||
| 20 | Service::HID::PAD_R, | ||
| 21 | Service::HID::PAD_ZL, | ||
| 22 | Service::HID::PAD_ZR, | ||
| 23 | Service::HID::PAD_START, | ||
| 24 | Service::HID::PAD_SELECT, | ||
| 25 | Service::HID::PAD_NONE, | ||
| 26 | Service::HID::PAD_UP, | ||
| 27 | Service::HID::PAD_DOWN, | ||
| 28 | Service::HID::PAD_LEFT, | ||
| 29 | Service::HID::PAD_RIGHT, | ||
| 30 | Service::HID::PAD_C_UP, | ||
| 31 | Service::HID::PAD_C_DOWN, | ||
| 32 | Service::HID::PAD_C_LEFT, | ||
| 33 | Service::HID::PAD_C_RIGHT, | ||
| 34 | |||
| 35 | IndirectTarget::CirclePadUp, | ||
| 36 | IndirectTarget::CirclePadDown, | ||
| 37 | IndirectTarget::CirclePadLeft, | ||
| 38 | IndirectTarget::CirclePadRight, | ||
| 39 | IndirectTarget::CirclePadModifier, | ||
| 40 | }}; | ||
| 41 | |||
| 42 | static std::map<HostDeviceKey, KeyTarget> key_map; | ||
| 43 | static int next_device_id = 0; | ||
| 44 | |||
| 45 | static bool circle_pad_up = false; | ||
| 46 | static bool circle_pad_down = false; | ||
| 47 | static bool circle_pad_left = false; | ||
| 48 | static bool circle_pad_right = false; | ||
| 49 | static bool circle_pad_modifier = false; | ||
| 50 | |||
| 51 | static void UpdateCirclePad(EmuWindow& emu_window) { | ||
| 52 | constexpr float SQRT_HALF = 0.707106781f; | ||
| 53 | int x = 0, y = 0; | ||
| 54 | |||
| 55 | if (circle_pad_right) | ||
| 56 | ++x; | ||
| 57 | if (circle_pad_left) | ||
| 58 | --x; | ||
| 59 | if (circle_pad_up) | ||
| 60 | ++y; | ||
| 61 | if (circle_pad_down) | ||
| 62 | --y; | ||
| 63 | |||
| 64 | float modifier = circle_pad_modifier ? Settings::values.pad_circle_modifier_scale : 1.0f; | ||
| 65 | emu_window.CirclePadUpdated(x * modifier * (y == 0 ? 1.0f : SQRT_HALF), | ||
| 66 | y * modifier * (x == 0 ? 1.0f : SQRT_HALF)); | ||
| 67 | } | ||
| 68 | |||
| 69 | int NewDeviceId() { | ||
| 70 | return next_device_id++; | ||
| 71 | } | ||
| 72 | |||
| 73 | void SetKeyMapping(HostDeviceKey key, KeyTarget target) { | ||
| 74 | key_map[key] = target; | ||
| 75 | } | ||
| 76 | |||
| 77 | void ClearKeyMapping(int device_id) { | ||
| 78 | auto iter = key_map.begin(); | ||
| 79 | while (iter != key_map.end()) { | ||
| 80 | if (iter->first.device_id == device_id) | ||
| 81 | key_map.erase(iter++); | ||
| 82 | else | ||
| 83 | ++iter; | ||
| 84 | } | ||
| 85 | } | ||
| 86 | |||
| 87 | void PressKey(EmuWindow& emu_window, HostDeviceKey key) { | ||
| 88 | auto target = key_map.find(key); | ||
| 89 | if (target == key_map.end()) | ||
| 90 | return; | ||
| 91 | |||
| 92 | if (target->second.direct) { | ||
| 93 | emu_window.ButtonPressed({{target->second.target.direct_target_hex}}); | ||
| 94 | } else { | ||
| 95 | switch (target->second.target.indirect_target) { | ||
| 96 | case IndirectTarget::CirclePadUp: | ||
| 97 | circle_pad_up = true; | ||
| 98 | UpdateCirclePad(emu_window); | ||
| 99 | break; | ||
| 100 | case IndirectTarget::CirclePadDown: | ||
| 101 | circle_pad_down = true; | ||
| 102 | UpdateCirclePad(emu_window); | ||
| 103 | break; | ||
| 104 | case IndirectTarget::CirclePadLeft: | ||
| 105 | circle_pad_left = true; | ||
| 106 | UpdateCirclePad(emu_window); | ||
| 107 | break; | ||
| 108 | case IndirectTarget::CirclePadRight: | ||
| 109 | circle_pad_right = true; | ||
| 110 | UpdateCirclePad(emu_window); | ||
| 111 | break; | ||
| 112 | case IndirectTarget::CirclePadModifier: | ||
| 113 | circle_pad_modifier = true; | ||
| 114 | UpdateCirclePad(emu_window); | ||
| 115 | break; | ||
| 116 | } | ||
| 117 | } | ||
| 118 | } | ||
| 119 | |||
| 120 | void ReleaseKey(EmuWindow& emu_window, HostDeviceKey key) { | ||
| 121 | auto target = key_map.find(key); | ||
| 122 | if (target == key_map.end()) | ||
| 123 | return; | ||
| 124 | |||
| 125 | if (target->second.direct) { | ||
| 126 | emu_window.ButtonReleased({{target->second.target.direct_target_hex}}); | ||
| 127 | } else { | ||
| 128 | switch (target->second.target.indirect_target) { | ||
| 129 | case IndirectTarget::CirclePadUp: | ||
| 130 | circle_pad_up = false; | ||
| 131 | UpdateCirclePad(emu_window); | ||
| 132 | break; | ||
| 133 | case IndirectTarget::CirclePadDown: | ||
| 134 | circle_pad_down = false; | ||
| 135 | UpdateCirclePad(emu_window); | ||
| 136 | break; | ||
| 137 | case IndirectTarget::CirclePadLeft: | ||
| 138 | circle_pad_left = false; | ||
| 139 | UpdateCirclePad(emu_window); | ||
| 140 | break; | ||
| 141 | case IndirectTarget::CirclePadRight: | ||
| 142 | circle_pad_right = false; | ||
| 143 | UpdateCirclePad(emu_window); | ||
| 144 | break; | ||
| 145 | case IndirectTarget::CirclePadModifier: | ||
| 146 | circle_pad_modifier = false; | ||
| 147 | UpdateCirclePad(emu_window); | ||
| 148 | break; | ||
| 149 | } | ||
| 150 | } | ||
| 151 | } | ||
| 152 | } | ||
diff --git a/src/core/frontend/key_map.h b/src/core/frontend/key_map.h deleted file mode 100644 index 040794578..000000000 --- a/src/core/frontend/key_map.h +++ /dev/null | |||
| @@ -1,93 +0,0 @@ | |||
| 1 | // Copyright 2014 Citra Emulator Project | ||
| 2 | // Licensed under GPLv2 or any later version | ||
| 3 | // Refer to the license.txt file included. | ||
| 4 | |||
| 5 | #pragma once | ||
| 6 | |||
| 7 | #include <array> | ||
| 8 | #include <tuple> | ||
| 9 | #include "core/hle/service/hid/hid.h" | ||
| 10 | |||
| 11 | class EmuWindow; | ||
| 12 | |||
| 13 | namespace KeyMap { | ||
| 14 | |||
| 15 | /** | ||
| 16 | * Represents key mapping targets that are not real 3DS buttons. | ||
| 17 | * They will be handled by KeyMap and translated to 3DS input. | ||
| 18 | */ | ||
| 19 | enum class IndirectTarget { | ||
| 20 | CirclePadUp, | ||
| 21 | CirclePadDown, | ||
| 22 | CirclePadLeft, | ||
| 23 | CirclePadRight, | ||
| 24 | CirclePadModifier, | ||
| 25 | }; | ||
| 26 | |||
| 27 | /** | ||
| 28 | * Represents a key mapping target. It can be a PadState that represents real 3DS buttons, | ||
| 29 | * or an IndirectTarget. | ||
| 30 | */ | ||
| 31 | struct KeyTarget { | ||
| 32 | bool direct; | ||
| 33 | union { | ||
| 34 | u32 direct_target_hex; | ||
| 35 | IndirectTarget indirect_target; | ||
| 36 | } target; | ||
| 37 | |||
| 38 | KeyTarget() : direct(true) { | ||
| 39 | target.direct_target_hex = 0; | ||
| 40 | } | ||
| 41 | |||
| 42 | KeyTarget(Service::HID::PadState pad) : direct(true) { | ||
| 43 | target.direct_target_hex = pad.hex; | ||
| 44 | } | ||
| 45 | |||
| 46 | KeyTarget(IndirectTarget i) : direct(false) { | ||
| 47 | target.indirect_target = i; | ||
| 48 | } | ||
| 49 | }; | ||
| 50 | |||
| 51 | /** | ||
| 52 | * Represents a key for a specific host device. | ||
| 53 | */ | ||
| 54 | struct HostDeviceKey { | ||
| 55 | int key_code; | ||
| 56 | int device_id; ///< Uniquely identifies a host device | ||
| 57 | |||
| 58 | bool operator<(const HostDeviceKey& other) const { | ||
| 59 | return std::tie(key_code, device_id) < std::tie(other.key_code, other.device_id); | ||
| 60 | } | ||
| 61 | |||
| 62 | bool operator==(const HostDeviceKey& other) const { | ||
| 63 | return std::tie(key_code, device_id) == std::tie(other.key_code, other.device_id); | ||
| 64 | } | ||
| 65 | }; | ||
| 66 | |||
| 67 | extern const std::array<KeyTarget, Settings::NativeInput::NUM_INPUTS> mapping_targets; | ||
| 68 | |||
| 69 | /** | ||
| 70 | * Generates a new device id, which uniquely identifies a host device within KeyMap. | ||
| 71 | */ | ||
| 72 | int NewDeviceId(); | ||
| 73 | |||
| 74 | /** | ||
| 75 | * Maps a device-specific key to a target (a PadState or an IndirectTarget). | ||
| 76 | */ | ||
| 77 | void SetKeyMapping(HostDeviceKey key, KeyTarget target); | ||
| 78 | |||
| 79 | /** | ||
| 80 | * Clears all key mappings belonging to one device. | ||
| 81 | */ | ||
| 82 | void ClearKeyMapping(int device_id); | ||
| 83 | |||
| 84 | /** | ||
| 85 | * Maps a key press action and call the corresponding function in EmuWindow | ||
| 86 | */ | ||
| 87 | void PressKey(EmuWindow& emu_window, HostDeviceKey key); | ||
| 88 | |||
| 89 | /** | ||
| 90 | * Maps a key release action and call the corresponding function in EmuWindow | ||
| 91 | */ | ||
| 92 | void ReleaseKey(EmuWindow& emu_window, HostDeviceKey key); | ||
| 93 | } | ||
diff --git a/src/core/hle/service/hid/hid.h b/src/core/hle/service/hid/hid.h index b828abe4b..b505cdcd5 100644 --- a/src/core/hle/service/hid/hid.h +++ b/src/core/hle/service/hid/hid.h | |||
| @@ -39,13 +39,6 @@ struct PadState { | |||
| 39 | BitField<10, 1, u32> x; | 39 | BitField<10, 1, u32> x; |
| 40 | BitField<11, 1, u32> y; | 40 | BitField<11, 1, u32> y; |
| 41 | 41 | ||
| 42 | BitField<14, 1, u32> zl; | ||
| 43 | BitField<15, 1, u32> zr; | ||
| 44 | |||
| 45 | BitField<24, 1, u32> c_right; | ||
| 46 | BitField<25, 1, u32> c_left; | ||
| 47 | BitField<26, 1, u32> c_up; | ||
| 48 | BitField<27, 1, u32> c_down; | ||
| 49 | BitField<28, 1, u32> circle_right; | 42 | BitField<28, 1, u32> circle_right; |
| 50 | BitField<29, 1, u32> circle_left; | 43 | BitField<29, 1, u32> circle_left; |
| 51 | BitField<30, 1, u32> circle_up; | 44 | BitField<30, 1, u32> circle_up; |
| @@ -183,33 +176,6 @@ ASSERT_REG_POSITION(touch.index_reset_ticks, 0x2A); | |||
| 183 | #undef ASSERT_REG_POSITION | 176 | #undef ASSERT_REG_POSITION |
| 184 | #endif // !defined(_MSC_VER) | 177 | #endif // !defined(_MSC_VER) |
| 185 | 178 | ||
| 186 | // Pre-defined PadStates for single button presses | ||
| 187 | const PadState PAD_NONE = {{0}}; | ||
| 188 | const PadState PAD_A = {{1u << 0}}; | ||
| 189 | const PadState PAD_B = {{1u << 1}}; | ||
| 190 | const PadState PAD_SELECT = {{1u << 2}}; | ||
| 191 | const PadState PAD_START = {{1u << 3}}; | ||
| 192 | const PadState PAD_RIGHT = {{1u << 4}}; | ||
| 193 | const PadState PAD_LEFT = {{1u << 5}}; | ||
| 194 | const PadState PAD_UP = {{1u << 6}}; | ||
| 195 | const PadState PAD_DOWN = {{1u << 7}}; | ||
| 196 | const PadState PAD_R = {{1u << 8}}; | ||
| 197 | const PadState PAD_L = {{1u << 9}}; | ||
| 198 | const PadState PAD_X = {{1u << 10}}; | ||
| 199 | const PadState PAD_Y = {{1u << 11}}; | ||
| 200 | |||
| 201 | const PadState PAD_ZL = {{1u << 14}}; | ||
| 202 | const PadState PAD_ZR = {{1u << 15}}; | ||
| 203 | |||
| 204 | const PadState PAD_C_RIGHT = {{1u << 24}}; | ||
| 205 | const PadState PAD_C_LEFT = {{1u << 25}}; | ||
| 206 | const PadState PAD_C_UP = {{1u << 26}}; | ||
| 207 | const PadState PAD_C_DOWN = {{1u << 27}}; | ||
| 208 | const PadState PAD_CIRCLE_RIGHT = {{1u << 28}}; | ||
| 209 | const PadState PAD_CIRCLE_LEFT = {{1u << 29}}; | ||
| 210 | const PadState PAD_CIRCLE_UP = {{1u << 30}}; | ||
| 211 | const PadState PAD_CIRCLE_DOWN = {{1u << 31}}; | ||
| 212 | |||
| 213 | /** | 179 | /** |
| 214 | * HID::GetIPCHandles service function | 180 | * HID::GetIPCHandles service function |
| 215 | * Inputs: | 181 | * Inputs: |
diff --git a/src/core/settings.h b/src/core/settings.h index 4f83d285c..d1a9f0da8 100644 --- a/src/core/settings.h +++ b/src/core/settings.h | |||
| @@ -18,57 +18,6 @@ enum class LayoutOption { | |||
| 18 | Custom, | 18 | Custom, |
| 19 | }; | 19 | }; |
| 20 | 20 | ||
| 21 | namespace NativeInput { | ||
| 22 | |||
| 23 | enum Values { | ||
| 24 | // directly mapped keys | ||
| 25 | A, | ||
| 26 | B, | ||
| 27 | X, | ||
| 28 | Y, | ||
| 29 | L, | ||
| 30 | R, | ||
| 31 | ZL, | ||
| 32 | ZR, | ||
| 33 | START, | ||
| 34 | SELECT, | ||
| 35 | HOME, | ||
| 36 | DUP, | ||
| 37 | DDOWN, | ||
| 38 | DLEFT, | ||
| 39 | DRIGHT, | ||
| 40 | CUP, | ||
| 41 | CDOWN, | ||
| 42 | CLEFT, | ||
| 43 | CRIGHT, | ||
| 44 | |||
| 45 | // indirectly mapped keys | ||
| 46 | CIRCLE_UP, | ||
| 47 | CIRCLE_DOWN, | ||
| 48 | CIRCLE_LEFT, | ||
| 49 | CIRCLE_RIGHT, | ||
| 50 | CIRCLE_MODIFIER, | ||
| 51 | |||
| 52 | NUM_INPUTS | ||
| 53 | }; | ||
| 54 | |||
| 55 | static const std::array<const char*, NUM_INPUTS> Mapping = {{ | ||
| 56 | // directly mapped keys | ||
| 57 | "pad_a", "pad_b", "pad_x", "pad_y", "pad_l", "pad_r", "pad_zl", "pad_zr", "pad_start", | ||
| 58 | "pad_select", "pad_home", "pad_dup", "pad_ddown", "pad_dleft", "pad_dright", "pad_cup", | ||
| 59 | "pad_cdown", "pad_cleft", "pad_cright", | ||
| 60 | |||
| 61 | // indirectly mapped keys | ||
| 62 | "pad_circle_up", "pad_circle_down", "pad_circle_left", "pad_circle_right", | ||
| 63 | "pad_circle_modifier", | ||
| 64 | }}; | ||
| 65 | static const std::array<Values, NUM_INPUTS> All = {{ | ||
| 66 | A, B, X, Y, L, R, ZL, ZR, | ||
| 67 | START, SELECT, HOME, DUP, DDOWN, DLEFT, DRIGHT, CUP, | ||
| 68 | CDOWN, CLEFT, CRIGHT, CIRCLE_UP, CIRCLE_DOWN, CIRCLE_LEFT, CIRCLE_RIGHT, CIRCLE_MODIFIER, | ||
| 69 | }}; | ||
| 70 | } | ||
| 71 | |||
| 72 | namespace NativeButton { | 21 | namespace NativeButton { |
| 73 | enum Values { | 22 | enum Values { |
| 74 | A, | 23 | A, |
| @@ -129,9 +78,6 @@ struct Values { | |||
| 129 | bool is_new_3ds; | 78 | bool is_new_3ds; |
| 130 | 79 | ||
| 131 | // Controls | 80 | // Controls |
| 132 | std::array<int, NativeInput::NUM_INPUTS> input_mappings; | ||
| 133 | float pad_circle_modifier_scale; | ||
| 134 | |||
| 135 | std::array<std::string, NativeButton::NumButtons> buttons; | 81 | std::array<std::string, NativeButton::NumButtons> buttons; |
| 136 | std::array<std::string, NativeAnalog::NumAnalogs> analogs; | 82 | std::array<std::string, NativeAnalog::NumAnalogs> analogs; |
| 137 | 83 | ||
diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp index 0818a87b3..456443e86 100644 --- a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp +++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp | |||
| @@ -17,6 +17,7 @@ | |||
| 17 | #include "common/vector_math.h" | 17 | #include "common/vector_math.h" |
| 18 | #include "core/frontend/emu_window.h" | 18 | #include "core/frontend/emu_window.h" |
| 19 | #include "core/memory.h" | 19 | #include "core/memory.h" |
| 20 | #include "core/settings.h" | ||
| 20 | #include "video_core/pica_state.h" | 21 | #include "video_core/pica_state.h" |
| 21 | #include "video_core/renderer_opengl/gl_rasterizer_cache.h" | 22 | #include "video_core/renderer_opengl/gl_rasterizer_cache.h" |
| 22 | #include "video_core/renderer_opengl/gl_state.h" | 23 | #include "video_core/renderer_opengl/gl_state.h" |