Browse Source
Merge pull request #2497 from wwylele/input-2
Merge pull request #2497 from wwylele/input-2
Refactor input emulation & add SDL gamepad supportnce_cpp
bunnei
9 years ago
committed by
GitHub
GitHub
40 changed files with 1244 additions and 574 deletions
-
1src/CMakeLists.txt
-
2src/citra/CMakeLists.txt
-
45src/citra/config.cpp
-
69src/citra/default_ini.h
-
21src/citra/emu_window/emu_window_sdl2.cpp
-
6src/citra/emu_window/emu_window_sdl2.h
-
2src/citra_qt/CMakeLists.txt
-
26src/citra_qt/bootmanager.cpp
-
6src/citra_qt/bootmanager.h
-
62src/citra_qt/config.cpp
-
5src/citra_qt/config.h
-
178src/citra_qt/configure_input.cpp
-
34src/citra_qt/configure_input.h
-
2src/common/CMakeLists.txt
-
1src/common/logging/backend.cpp
-
1src/common/logging/log.h
-
120src/common/param_package.cpp
-
40src/common/param_package.h
-
3src/core/CMakeLists.txt
-
26src/core/frontend/emu_window.cpp
-
54src/core/frontend/emu_window.h
-
110src/core/frontend/input.h
-
152src/core/frontend/key_map.cpp
-
93src/core/frontend/key_map.h
-
56src/core/hle/service/hid/hid.cpp
-
37src/core/hle/service/hid/hid.h
-
3src/core/settings.cpp
-
80src/core/settings.h
-
27src/input_common/CMakeLists.txt
-
58src/input_common/analog_from_button.cpp
-
31src/input_common/analog_from_button.h
-
82src/input_common/keyboard.cpp
-
45src/input_common/keyboard.h
-
63src/input_common/main.cpp
-
29src/input_common/main.h
-
202src/input_common/sdl/sdl.cpp
-
19src/input_common/sdl/sdl.h
-
1src/tests/CMakeLists.txt
-
25src/tests/common/param_package.cpp
-
1src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
@ -0,0 +1,120 @@ |
|||||
|
// Copyright 2017 Citra Emulator Project
|
||||
|
// Licensed under GPLv2 or any later version
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
#include <array>
|
||||
|
#include <vector>
|
||||
|
#include "common/logging/log.h"
|
||||
|
#include "common/param_package.h"
|
||||
|
#include "common/string_util.h"
|
||||
|
|
||||
|
namespace Common { |
||||
|
|
||||
|
constexpr char KEY_VALUE_SEPARATOR = ':'; |
||||
|
constexpr char PARAM_SEPARATOR = ','; |
||||
|
constexpr char ESCAPE_CHARACTER = '$'; |
||||
|
const std::string KEY_VALUE_SEPARATOR_ESCAPE{ESCAPE_CHARACTER, '0'}; |
||||
|
const std::string PARAM_SEPARATOR_ESCAPE{ESCAPE_CHARACTER, '1'}; |
||||
|
const std::string ESCAPE_CHARACTER_ESCAPE{ESCAPE_CHARACTER, '2'}; |
||||
|
|
||||
|
ParamPackage::ParamPackage(const std::string& serialized) { |
||||
|
std::vector<std::string> pairs; |
||||
|
Common::SplitString(serialized, PARAM_SEPARATOR, pairs); |
||||
|
|
||||
|
for (const std::string& pair : pairs) { |
||||
|
std::vector<std::string> key_value; |
||||
|
Common::SplitString(pair, KEY_VALUE_SEPARATOR, key_value); |
||||
|
if (key_value.size() != 2) { |
||||
|
LOG_ERROR(Common, "invalid key pair %s", pair.c_str()); |
||||
|
continue; |
||||
|
} |
||||
|
|
||||
|
for (std::string& part : key_value) { |
||||
|
part = Common::ReplaceAll(part, KEY_VALUE_SEPARATOR_ESCAPE, {KEY_VALUE_SEPARATOR}); |
||||
|
part = Common::ReplaceAll(part, PARAM_SEPARATOR_ESCAPE, {PARAM_SEPARATOR}); |
||||
|
part = Common::ReplaceAll(part, ESCAPE_CHARACTER_ESCAPE, {ESCAPE_CHARACTER}); |
||||
|
} |
||||
|
|
||||
|
Set(key_value[0], key_value[1]); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
ParamPackage::ParamPackage(std::initializer_list<DataType::value_type> list) : data(list) {} |
||||
|
|
||||
|
std::string ParamPackage::Serialize() const { |
||||
|
if (data.empty()) |
||||
|
return ""; |
||||
|
|
||||
|
std::string result; |
||||
|
|
||||
|
for (const auto& pair : data) { |
||||
|
std::array<std::string, 2> key_value{{pair.first, pair.second}}; |
||||
|
for (std::string& part : key_value) { |
||||
|
part = Common::ReplaceAll(part, {ESCAPE_CHARACTER}, ESCAPE_CHARACTER_ESCAPE); |
||||
|
part = Common::ReplaceAll(part, {PARAM_SEPARATOR}, PARAM_SEPARATOR_ESCAPE); |
||||
|
part = Common::ReplaceAll(part, {KEY_VALUE_SEPARATOR}, KEY_VALUE_SEPARATOR_ESCAPE); |
||||
|
} |
||||
|
result += key_value[0] + KEY_VALUE_SEPARATOR + key_value[1] + PARAM_SEPARATOR; |
||||
|
} |
||||
|
|
||||
|
result.pop_back(); // discard the trailing PARAM_SEPARATOR
|
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
std::string ParamPackage::Get(const std::string& key, const std::string& default_value) const { |
||||
|
auto pair = data.find(key); |
||||
|
if (pair == data.end()) { |
||||
|
LOG_DEBUG(Common, "key %s not found", key.c_str()); |
||||
|
return default_value; |
||||
|
} |
||||
|
|
||||
|
return pair->second; |
||||
|
} |
||||
|
|
||||
|
int ParamPackage::Get(const std::string& key, int default_value) const { |
||||
|
auto pair = data.find(key); |
||||
|
if (pair == data.end()) { |
||||
|
LOG_DEBUG(Common, "key %s not found", key.c_str()); |
||||
|
return default_value; |
||||
|
} |
||||
|
|
||||
|
try { |
||||
|
return std::stoi(pair->second); |
||||
|
} catch (const std::logic_error&) { |
||||
|
LOG_ERROR(Common, "failed to convert %s to int", pair->second.c_str()); |
||||
|
return default_value; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
float ParamPackage::Get(const std::string& key, float default_value) const { |
||||
|
auto pair = data.find(key); |
||||
|
if (pair == data.end()) { |
||||
|
LOG_DEBUG(Common, "key %s not found", key.c_str()); |
||||
|
return default_value; |
||||
|
} |
||||
|
|
||||
|
try { |
||||
|
return std::stof(pair->second); |
||||
|
} catch (const std::logic_error&) { |
||||
|
LOG_ERROR(Common, "failed to convert %s to float", pair->second.c_str()); |
||||
|
return default_value; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void ParamPackage::Set(const std::string& key, const std::string& value) { |
||||
|
data[key] = value; |
||||
|
} |
||||
|
|
||||
|
void ParamPackage::Set(const std::string& key, int value) { |
||||
|
data[key] = std::to_string(value); |
||||
|
} |
||||
|
|
||||
|
void ParamPackage::Set(const std::string& key, float value) { |
||||
|
data[key] = std::to_string(value); |
||||
|
} |
||||
|
|
||||
|
bool ParamPackage::Has(const std::string& key) const { |
||||
|
return data.find(key) != data.end(); |
||||
|
} |
||||
|
|
||||
|
} // namespace Common
|
||||
@ -0,0 +1,40 @@ |
|||||
|
// Copyright 2017 Citra Emulator Project |
||||
|
// Licensed under GPLv2 or any later version |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include <initializer_list> |
||||
|
#include <string> |
||||
|
#include <unordered_map> |
||||
|
|
||||
|
namespace Common { |
||||
|
|
||||
|
/// A string-based key-value container supporting serializing to and deserializing from a string |
||||
|
class ParamPackage { |
||||
|
public: |
||||
|
using DataType = std::unordered_map<std::string, std::string>; |
||||
|
|
||||
|
ParamPackage() = default; |
||||
|
explicit ParamPackage(const std::string& serialized); |
||||
|
ParamPackage(std::initializer_list<DataType::value_type> list); |
||||
|
ParamPackage(const ParamPackage& other) = default; |
||||
|
ParamPackage(ParamPackage&& other) = default; |
||||
|
|
||||
|
ParamPackage& operator=(const ParamPackage& other) = default; |
||||
|
ParamPackage& operator=(ParamPackage&& other) = default; |
||||
|
|
||||
|
std::string Serialize() const; |
||||
|
std::string Get(const std::string& key, const std::string& default_value) const; |
||||
|
int Get(const std::string& key, int default_value) const; |
||||
|
float Get(const std::string& key, float default_value) const; |
||||
|
void Set(const std::string& key, const std::string& value); |
||||
|
void Set(const std::string& key, int value); |
||||
|
void Set(const std::string& key, float value); |
||||
|
bool Has(const std::string& key) const; |
||||
|
|
||||
|
private: |
||||
|
DataType data; |
||||
|
}; |
||||
|
|
||||
|
} // namespace Common |
||||
@ -0,0 +1,110 @@ |
|||||
|
// Copyright 2017 Citra Emulator Project |
||||
|
// Licensed under GPLv2 or any later version |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include <memory> |
||||
|
#include <string> |
||||
|
#include <tuple> |
||||
|
#include <unordered_map> |
||||
|
#include <utility> |
||||
|
#include "common/logging/log.h" |
||||
|
#include "common/param_package.h" |
||||
|
|
||||
|
namespace Input { |
||||
|
|
||||
|
/// An abstract class template for an input device (a button, an analog input, etc.). |
||||
|
template <typename StatusType> |
||||
|
class InputDevice { |
||||
|
public: |
||||
|
virtual ~InputDevice() = default; |
||||
|
virtual StatusType GetStatus() const { |
||||
|
return {}; |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
/// An abstract class template for a factory that can create input devices. |
||||
|
template <typename InputDeviceType> |
||||
|
class Factory { |
||||
|
public: |
||||
|
virtual ~Factory() = default; |
||||
|
virtual std::unique_ptr<InputDeviceType> Create(const Common::ParamPackage&) = 0; |
||||
|
}; |
||||
|
|
||||
|
namespace Impl { |
||||
|
|
||||
|
template <typename InputDeviceType> |
||||
|
using FactoryListType = std::unordered_map<std::string, std::shared_ptr<Factory<InputDeviceType>>>; |
||||
|
|
||||
|
template <typename InputDeviceType> |
||||
|
struct FactoryList { |
||||
|
static FactoryListType<InputDeviceType> list; |
||||
|
}; |
||||
|
|
||||
|
template <typename InputDeviceType> |
||||
|
FactoryListType<InputDeviceType> FactoryList<InputDeviceType>::list; |
||||
|
|
||||
|
} // namespace Impl |
||||
|
|
||||
|
/** |
||||
|
* Registers an input device factory. |
||||
|
* @tparam InputDeviceType the type of input devices the factory can create |
||||
|
* @param name the name of the factory. Will be used to match the "engine" parameter when creating |
||||
|
* a device |
||||
|
* @param factory the factory object to register |
||||
|
*/ |
||||
|
template <typename InputDeviceType> |
||||
|
void RegisterFactory(const std::string& name, std::shared_ptr<Factory<InputDeviceType>> factory) { |
||||
|
auto pair = std::make_pair(name, std::move(factory)); |
||||
|
if (!Impl::FactoryList<InputDeviceType>::list.insert(std::move(pair)).second) { |
||||
|
LOG_ERROR(Input, "Factory %s already registered", name.c_str()); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Unregisters an input device factory. |
||||
|
* @tparam InputDeviceType the type of input devices the factory can create |
||||
|
* @param name the name of the factory to unregister |
||||
|
*/ |
||||
|
template <typename InputDeviceType> |
||||
|
void UnregisterFactory(const std::string& name) { |
||||
|
if (Impl::FactoryList<InputDeviceType>::list.erase(name) == 0) { |
||||
|
LOG_ERROR(Input, "Factory %s not registered", name.c_str()); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Create an input device from given paramters. |
||||
|
* @tparam InputDeviceType the type of input devices to create |
||||
|
* @param params a serialized ParamPackage string contains all parameters for creating the device |
||||
|
*/ |
||||
|
template <typename InputDeviceType> |
||||
|
std::unique_ptr<InputDeviceType> CreateDevice(const std::string& params) { |
||||
|
const Common::ParamPackage package(params); |
||||
|
const std::string engine = package.Get("engine", "null"); |
||||
|
const auto& factory_list = Impl::FactoryList<InputDeviceType>::list; |
||||
|
const auto pair = factory_list.find(engine); |
||||
|
if (pair == factory_list.end()) { |
||||
|
if (engine != "null") { |
||||
|
LOG_ERROR(Input, "Unknown engine name: %s", engine.c_str()); |
||||
|
} |
||||
|
return std::make_unique<InputDeviceType>(); |
||||
|
} |
||||
|
return pair->second->Create(package); |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* A button device is an input device that returns bool as status. |
||||
|
* true for pressed; false for released. |
||||
|
*/ |
||||
|
using ButtonDevice = InputDevice<bool>; |
||||
|
|
||||
|
/** |
||||
|
* An analog device is an input device that returns a tuple of x and y coordinates as status. The |
||||
|
* coordinates are within the unit circle. x+ is defined as right direction, and y+ is defined as up |
||||
|
* direction |
||||
|
*/ |
||||
|
using AnalogDevice = InputDevice<std::tuple<float, float>>; |
||||
|
|
||||
|
} // namespace Input |
||||
@ -1,152 +0,0 @@ |
|||||
// Copyright 2014 Citra Emulator Project
|
|
||||
// Licensed under GPLv2 or any later version
|
|
||||
// Refer to the license.txt file included.
|
|
||||
|
|
||||
#include <map>
|
|
||||
#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<KeyTarget, Settings::NativeInput::NUM_INPUTS> 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<HostDeviceKey, KeyTarget> 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; |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -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 <array> |
|
||||
#include <tuple> |
|
||||
#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<KeyTarget, Settings::NativeInput::NUM_INPUTS> 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); |
|
||||
} |
|
||||
@ -0,0 +1,27 @@ |
|||||
|
set(SRCS |
||||
|
analog_from_button.cpp |
||||
|
keyboard.cpp |
||||
|
main.cpp |
||||
|
) |
||||
|
|
||||
|
set(HEADERS |
||||
|
analog_from_button.h |
||||
|
keyboard.h |
||||
|
main.h |
||||
|
) |
||||
|
|
||||
|
if(SDL2_FOUND) |
||||
|
set(SRCS ${SRCS} sdl/sdl.cpp) |
||||
|
set(HEADERS ${HEADERS} sdl/sdl.h) |
||||
|
include_directories(${SDL2_INCLUDE_DIR}) |
||||
|
endif() |
||||
|
|
||||
|
create_directory_groups(${SRCS} ${HEADERS}) |
||||
|
|
||||
|
add_library(input_common STATIC ${SRCS} ${HEADERS}) |
||||
|
target_link_libraries(input_common common core) |
||||
|
|
||||
|
if(SDL2_FOUND) |
||||
|
target_link_libraries(input_common ${SDL2_LIBRARY}) |
||||
|
set_property(TARGET input_common APPEND PROPERTY COMPILE_DEFINITIONS HAVE_SDL2) |
||||
|
endif() |
||||
@ -0,0 +1,58 @@ |
|||||
|
// Copyright 2017 Citra Emulator Project
|
||||
|
// Licensed under GPLv2 or any later version
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
#include "input_common/analog_from_button.h"
|
||||
|
|
||||
|
namespace InputCommon { |
||||
|
|
||||
|
class Analog final : public Input::AnalogDevice { |
||||
|
public: |
||||
|
using Button = std::unique_ptr<Input::ButtonDevice>; |
||||
|
|
||||
|
Analog(Button up_, Button down_, Button left_, Button right_, Button modifier_, |
||||
|
float modifier_scale_) |
||||
|
: up(std::move(up_)), down(std::move(down_)), left(std::move(left_)), |
||||
|
right(std::move(right_)), modifier(std::move(modifier_)), |
||||
|
modifier_scale(modifier_scale_) {} |
||||
|
|
||||
|
std::tuple<float, float> GetStatus() const override { |
||||
|
constexpr float SQRT_HALF = 0.707106781f; |
||||
|
int x = 0, y = 0; |
||||
|
|
||||
|
if (right->GetStatus()) |
||||
|
++x; |
||||
|
if (left->GetStatus()) |
||||
|
--x; |
||||
|
if (up->GetStatus()) |
||||
|
++y; |
||||
|
if (down->GetStatus()) |
||||
|
--y; |
||||
|
|
||||
|
float coef = modifier->GetStatus() ? modifier_scale : 1.0f; |
||||
|
return std::make_tuple(x * coef * (y == 0 ? 1.0f : SQRT_HALF), |
||||
|
y * coef * (x == 0 ? 1.0f : SQRT_HALF)); |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
Button up; |
||||
|
Button down; |
||||
|
Button left; |
||||
|
Button right; |
||||
|
Button modifier; |
||||
|
float modifier_scale; |
||||
|
}; |
||||
|
|
||||
|
std::unique_ptr<Input::AnalogDevice> AnalogFromButton::Create(const Common::ParamPackage& params) { |
||||
|
const std::string null_engine = Common::ParamPackage{{"engine", "null"}}.Serialize(); |
||||
|
auto up = Input::CreateDevice<Input::ButtonDevice>(params.Get("up", null_engine)); |
||||
|
auto down = Input::CreateDevice<Input::ButtonDevice>(params.Get("down", null_engine)); |
||||
|
auto left = Input::CreateDevice<Input::ButtonDevice>(params.Get("left", null_engine)); |
||||
|
auto right = Input::CreateDevice<Input::ButtonDevice>(params.Get("right", null_engine)); |
||||
|
auto modifier = Input::CreateDevice<Input::ButtonDevice>(params.Get("modifier", null_engine)); |
||||
|
auto modifier_scale = params.Get("modifier_scale", 0.5f); |
||||
|
return std::make_unique<Analog>(std::move(up), std::move(down), std::move(left), |
||||
|
std::move(right), std::move(modifier), modifier_scale); |
||||
|
} |
||||
|
|
||||
|
} // namespace InputCommon
|
||||
@ -0,0 +1,31 @@ |
|||||
|
// Copyright 2017 Citra Emulator Project |
||||
|
// Licensed under GPLv2 or any later version |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include <memory> |
||||
|
#include "core/frontend/input.h" |
||||
|
|
||||
|
namespace InputCommon { |
||||
|
|
||||
|
/** |
||||
|
* An analog device factory that takes direction button devices and combines them into a analog |
||||
|
* device. |
||||
|
*/ |
||||
|
class AnalogFromButton final : public Input::Factory<Input::AnalogDevice> { |
||||
|
public: |
||||
|
/** |
||||
|
* Creates an analog device from direction button devices |
||||
|
* @param params contains parameters for creating the device: |
||||
|
* - "up": a serialized ParamPackage for creating a button device for up direction |
||||
|
* - "down": a serialized ParamPackage for creating a button device for down direction |
||||
|
* - "left": a serialized ParamPackage for creating a button device for left direction |
||||
|
* - "right": a serialized ParamPackage for creating a button device for right direction |
||||
|
* - "modifier": a serialized ParamPackage for creating a button device as the modifier |
||||
|
* - "modifier_scale": a float for the multiplier the modifier gives to the position |
||||
|
*/ |
||||
|
std::unique_ptr<Input::AnalogDevice> Create(const Common::ParamPackage& params) override; |
||||
|
}; |
||||
|
|
||||
|
} // namespace InputCommon |
||||
@ -0,0 +1,82 @@ |
|||||
|
// Copyright 2017 Citra Emulator Project
|
||||
|
// Licensed under GPLv2 or any later version
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
#include <atomic>
|
||||
|
#include <list>
|
||||
|
#include <mutex>
|
||||
|
#include "input_common/keyboard.h"
|
||||
|
|
||||
|
namespace InputCommon { |
||||
|
|
||||
|
class KeyButton final : public Input::ButtonDevice { |
||||
|
public: |
||||
|
explicit KeyButton(std::shared_ptr<KeyButtonList> key_button_list_) |
||||
|
: key_button_list(key_button_list_) {} |
||||
|
|
||||
|
~KeyButton(); |
||||
|
|
||||
|
bool GetStatus() const override { |
||||
|
return status.load(); |
||||
|
} |
||||
|
|
||||
|
friend class KeyButtonList; |
||||
|
|
||||
|
private: |
||||
|
std::shared_ptr<KeyButtonList> key_button_list; |
||||
|
std::atomic<bool> status{false}; |
||||
|
}; |
||||
|
|
||||
|
struct KeyButtonPair { |
||||
|
int key_code; |
||||
|
KeyButton* key_button; |
||||
|
}; |
||||
|
|
||||
|
class KeyButtonList { |
||||
|
public: |
||||
|
void AddKeyButton(int key_code, KeyButton* key_button) { |
||||
|
std::lock_guard<std::mutex> guard(mutex); |
||||
|
list.push_back(KeyButtonPair{key_code, key_button}); |
||||
|
} |
||||
|
|
||||
|
void RemoveKeyButton(const KeyButton* key_button) { |
||||
|
std::lock_guard<std::mutex> guard(mutex); |
||||
|
list.remove_if( |
||||
|
[key_button](const KeyButtonPair& pair) { return pair.key_button == key_button; }); |
||||
|
} |
||||
|
|
||||
|
void ChangeKeyStatus(int key_code, bool pressed) { |
||||
|
std::lock_guard<std::mutex> guard(mutex); |
||||
|
for (const KeyButtonPair& pair : list) { |
||||
|
if (pair.key_code == key_code) |
||||
|
pair.key_button->status.store(pressed); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
std::mutex mutex; |
||||
|
std::list<KeyButtonPair> list; |
||||
|
}; |
||||
|
|
||||
|
Keyboard::Keyboard() : key_button_list{std::make_shared<KeyButtonList>()} {} |
||||
|
|
||||
|
KeyButton::~KeyButton() { |
||||
|
key_button_list->RemoveKeyButton(this); |
||||
|
} |
||||
|
|
||||
|
std::unique_ptr<Input::ButtonDevice> Keyboard::Create(const Common::ParamPackage& params) { |
||||
|
int key_code = params.Get("code", 0); |
||||
|
std::unique_ptr<KeyButton> button = std::make_unique<KeyButton>(key_button_list); |
||||
|
key_button_list->AddKeyButton(key_code, button.get()); |
||||
|
return std::move(button); |
||||
|
} |
||||
|
|
||||
|
void Keyboard::PressKey(int key_code) { |
||||
|
key_button_list->ChangeKeyStatus(key_code, true); |
||||
|
} |
||||
|
|
||||
|
void Keyboard::ReleaseKey(int key_code) { |
||||
|
key_button_list->ChangeKeyStatus(key_code, false); |
||||
|
} |
||||
|
|
||||
|
} // namespace InputCommon
|
||||
@ -0,0 +1,45 @@ |
|||||
|
// Copyright 2017 Citra Emulator Project |
||||
|
// Licensed under GPLv2 or any later version |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include <memory> |
||||
|
#include "core/frontend/input.h" |
||||
|
|
||||
|
namespace InputCommon { |
||||
|
|
||||
|
class KeyButtonList; |
||||
|
|
||||
|
/** |
||||
|
* A button device factory representing a keyboard. It receives keyboard events and forward them |
||||
|
* to all button devices it created. |
||||
|
*/ |
||||
|
class Keyboard final : public Input::Factory<Input::ButtonDevice> { |
||||
|
public: |
||||
|
Keyboard(); |
||||
|
|
||||
|
/** |
||||
|
* Creates a button device from a keyboard key |
||||
|
* @param params contains parameters for creating the device: |
||||
|
* - "code": the code of the key to bind with the button |
||||
|
*/ |
||||
|
std::unique_ptr<Input::ButtonDevice> Create(const Common::ParamPackage& params) override; |
||||
|
|
||||
|
/** |
||||
|
* Sets the status of all buttons bound with the key to pressed |
||||
|
* @param key_code the code of the key to press |
||||
|
*/ |
||||
|
void PressKey(int key_code); |
||||
|
|
||||
|
/** |
||||
|
* Sets the status of all buttons bound with the key to released |
||||
|
* @param key_code the code of the key to release |
||||
|
*/ |
||||
|
void ReleaseKey(int key_code); |
||||
|
|
||||
|
private: |
||||
|
std::shared_ptr<KeyButtonList> key_button_list; |
||||
|
}; |
||||
|
|
||||
|
} // namespace InputCommon |
||||
@ -0,0 +1,63 @@ |
|||||
|
// Copyright 2017 Citra Emulator Project
|
||||
|
// Licensed under GPLv2 or any later version
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
#include <memory>
|
||||
|
#include "common/param_package.h"
|
||||
|
#include "input_common/analog_from_button.h"
|
||||
|
#include "input_common/keyboard.h"
|
||||
|
#include "input_common/main.h"
|
||||
|
#ifdef HAVE_SDL2
|
||||
|
#include "input_common/sdl/sdl.h"
|
||||
|
#endif
|
||||
|
|
||||
|
namespace InputCommon { |
||||
|
|
||||
|
static std::shared_ptr<Keyboard> keyboard; |
||||
|
|
||||
|
void Init() { |
||||
|
keyboard = std::make_shared<InputCommon::Keyboard>(); |
||||
|
Input::RegisterFactory<Input::ButtonDevice>("keyboard", keyboard); |
||||
|
Input::RegisterFactory<Input::AnalogDevice>("analog_from_button", |
||||
|
std::make_shared<InputCommon::AnalogFromButton>()); |
||||
|
#ifdef HAVE_SDL2
|
||||
|
SDL::Init(); |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
void Shutdown() { |
||||
|
Input::UnregisterFactory<Input::ButtonDevice>("keyboard"); |
||||
|
keyboard.reset(); |
||||
|
Input::UnregisterFactory<Input::AnalogDevice>("analog_from_button"); |
||||
|
|
||||
|
#ifdef HAVE_SDL2
|
||||
|
SDL::Shutdown(); |
||||
|
#endif
|
||||
|
} |
||||
|
|
||||
|
Keyboard* GetKeyboard() { |
||||
|
return keyboard.get(); |
||||
|
} |
||||
|
|
||||
|
std::string GenerateKeyboardParam(int key_code) { |
||||
|
Common::ParamPackage param{ |
||||
|
{"engine", "keyboard"}, {"code", std::to_string(key_code)}, |
||||
|
}; |
||||
|
return param.Serialize(); |
||||
|
} |
||||
|
|
||||
|
std::string GenerateAnalogParamFromKeys(int key_up, int key_down, int key_left, int key_right, |
||||
|
int key_modifier, float modifier_scale) { |
||||
|
Common::ParamPackage circle_pad_param{ |
||||
|
{"engine", "analog_from_button"}, |
||||
|
{"up", GenerateKeyboardParam(key_up)}, |
||||
|
{"down", GenerateKeyboardParam(key_down)}, |
||||
|
{"left", GenerateKeyboardParam(key_left)}, |
||||
|
{"right", GenerateKeyboardParam(key_right)}, |
||||
|
{"modifier", GenerateKeyboardParam(key_modifier)}, |
||||
|
{"modifier_scale", std::to_string(modifier_scale)}, |
||||
|
}; |
||||
|
return circle_pad_param.Serialize(); |
||||
|
} |
||||
|
|
||||
|
} // namespace InputCommon
|
||||
@ -0,0 +1,29 @@ |
|||||
|
// Copyright 2017 Citra Emulator Project |
||||
|
// Licensed under GPLv2 or any later version |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include <string> |
||||
|
|
||||
|
namespace InputCommon { |
||||
|
|
||||
|
/// Initializes and registers all built-in input device factories. |
||||
|
void Init(); |
||||
|
|
||||
|
/// Unresisters all build-in input device factories and shut them down. |
||||
|
void Shutdown(); |
||||
|
|
||||
|
class Keyboard; |
||||
|
|
||||
|
/// Gets the keyboard button device factory. |
||||
|
Keyboard* GetKeyboard(); |
||||
|
|
||||
|
/// Generates a serialized param package for creating a keyboard button device |
||||
|
std::string GenerateKeyboardParam(int key_code); |
||||
|
|
||||
|
/// Generates a serialized param package for creating an analog device taking input from keyboard |
||||
|
std::string GenerateAnalogParamFromKeys(int key_up, int key_down, int key_left, int key_right, |
||||
|
int key_modifier, float modifier_scale); |
||||
|
|
||||
|
} // namespace InputCommon |
||||
@ -0,0 +1,202 @@ |
|||||
|
// Copyright 2017 Citra Emulator Project
|
||||
|
// Licensed under GPLv2 or any later version
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
#include <cmath>
|
||||
|
#include <memory>
|
||||
|
#include <string>
|
||||
|
#include <tuple>
|
||||
|
#include <unordered_map>
|
||||
|
#include <SDL.h>
|
||||
|
#include "common/math_util.h"
|
||||
|
#include "input_common/sdl/sdl.h"
|
||||
|
|
||||
|
namespace InputCommon { |
||||
|
|
||||
|
namespace SDL { |
||||
|
|
||||
|
class SDLJoystick; |
||||
|
class SDLButtonFactory; |
||||
|
class SDLAnalogFactory; |
||||
|
static std::unordered_map<int, std::weak_ptr<SDLJoystick>> joystick_list; |
||||
|
static std::shared_ptr<SDLButtonFactory> button_factory; |
||||
|
static std::shared_ptr<SDLAnalogFactory> analog_factory; |
||||
|
|
||||
|
static bool initialized = false; |
||||
|
|
||||
|
class SDLJoystick { |
||||
|
public: |
||||
|
explicit SDLJoystick(int joystick_index) |
||||
|
: joystick{SDL_JoystickOpen(joystick_index), SDL_JoystickClose} { |
||||
|
if (!joystick) { |
||||
|
LOG_ERROR(Input, "failed to open joystick %d", joystick_index); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
bool GetButton(int button) const { |
||||
|
if (!joystick) |
||||
|
return {}; |
||||
|
SDL_JoystickUpdate(); |
||||
|
return SDL_JoystickGetButton(joystick.get(), button) == 1; |
||||
|
} |
||||
|
|
||||
|
std::tuple<float, float> GetAnalog(int axis_x, int axis_y) const { |
||||
|
if (!joystick) |
||||
|
return {}; |
||||
|
SDL_JoystickUpdate(); |
||||
|
float x = SDL_JoystickGetAxis(joystick.get(), axis_x) / 32767.0f; |
||||
|
float y = SDL_JoystickGetAxis(joystick.get(), axis_y) / 32767.0f; |
||||
|
y = -y; // 3DS uses an y-axis inverse from SDL
|
||||
|
|
||||
|
// Make sure the coordinates are in the unit circle,
|
||||
|
// otherwise normalize it.
|
||||
|
float r = x * x + y * y; |
||||
|
if (r > 1.0f) { |
||||
|
r = std::sqrt(r); |
||||
|
x /= r; |
||||
|
y /= r; |
||||
|
} |
||||
|
|
||||
|
return std::make_tuple(x, y); |
||||
|
} |
||||
|
|
||||
|
bool GetHatDirection(int hat, Uint8 direction) const { |
||||
|
return (SDL_JoystickGetHat(joystick.get(), hat) & direction) != 0; |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
std::unique_ptr<SDL_Joystick, decltype(&SDL_JoystickClose)> joystick; |
||||
|
}; |
||||
|
|
||||
|
class SDLButton final : public Input::ButtonDevice { |
||||
|
public: |
||||
|
explicit SDLButton(std::shared_ptr<SDLJoystick> joystick_, int button_) |
||||
|
: joystick(joystick_), button(button_) {} |
||||
|
|
||||
|
bool GetStatus() const override { |
||||
|
return joystick->GetButton(button); |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
std::shared_ptr<SDLJoystick> joystick; |
||||
|
int button; |
||||
|
}; |
||||
|
|
||||
|
class SDLDirectionButton final : public Input::ButtonDevice { |
||||
|
public: |
||||
|
explicit SDLDirectionButton(std::shared_ptr<SDLJoystick> joystick_, int hat_, Uint8 direction_) |
||||
|
: joystick(joystick_), hat(hat_), direction(direction_) {} |
||||
|
|
||||
|
bool GetStatus() const override { |
||||
|
return joystick->GetHatDirection(hat, direction); |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
std::shared_ptr<SDLJoystick> joystick; |
||||
|
int hat; |
||||
|
Uint8 direction; |
||||
|
}; |
||||
|
|
||||
|
class SDLAnalog final : public Input::AnalogDevice { |
||||
|
public: |
||||
|
SDLAnalog(std::shared_ptr<SDLJoystick> joystick_, int axis_x_, int axis_y_) |
||||
|
: joystick(joystick_), axis_x(axis_x_), axis_y(axis_y_) {} |
||||
|
|
||||
|
std::tuple<float, float> GetStatus() const override { |
||||
|
return joystick->GetAnalog(axis_x, axis_y); |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
std::shared_ptr<SDLJoystick> joystick; |
||||
|
int axis_x; |
||||
|
int axis_y; |
||||
|
}; |
||||
|
|
||||
|
static std::shared_ptr<SDLJoystick> GetJoystick(int joystick_index) { |
||||
|
std::shared_ptr<SDLJoystick> joystick = joystick_list[joystick_index].lock(); |
||||
|
if (!joystick) { |
||||
|
joystick = std::make_shared<SDLJoystick>(joystick_index); |
||||
|
joystick_list[joystick_index] = joystick; |
||||
|
} |
||||
|
return joystick; |
||||
|
} |
||||
|
|
||||
|
/// A button device factory that creates button devices from SDL joystick
|
||||
|
class SDLButtonFactory final : public Input::Factory<Input::ButtonDevice> { |
||||
|
public: |
||||
|
/**
|
||||
|
* Creates a button device from a joystick button |
||||
|
* @param params contains parameters for creating the device: |
||||
|
* - "joystick": the index of the joystick to bind |
||||
|
* - "button"(optional): the index of the button to bind |
||||
|
* - "hat"(optional): the index of the hat to bind as direction buttons |
||||
|
* - "direction"(only used for hat): the direction name of the hat to bind. Can be "up", |
||||
|
* "down", "left" or "right" |
||||
|
*/ |
||||
|
std::unique_ptr<Input::ButtonDevice> Create(const Common::ParamPackage& params) override { |
||||
|
const int joystick_index = params.Get("joystick", 0); |
||||
|
|
||||
|
if (params.Has("hat")) { |
||||
|
const int hat = params.Get("hat", 0); |
||||
|
const std::string direction_name = params.Get("direction", ""); |
||||
|
Uint8 direction; |
||||
|
if (direction_name == "up") { |
||||
|
direction = SDL_HAT_UP; |
||||
|
} else if (direction_name == "down") { |
||||
|
direction = SDL_HAT_DOWN; |
||||
|
} else if (direction_name == "left") { |
||||
|
direction = SDL_HAT_LEFT; |
||||
|
} else if (direction_name == "right") { |
||||
|
direction = SDL_HAT_RIGHT; |
||||
|
} else { |
||||
|
direction = 0; |
||||
|
} |
||||
|
return std::make_unique<SDLDirectionButton>(GetJoystick(joystick_index), hat, |
||||
|
direction); |
||||
|
} |
||||
|
|
||||
|
const int button = params.Get("button", 0); |
||||
|
return std::make_unique<SDLButton>(GetJoystick(joystick_index), button); |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
/// An analog device factory that creates analog devices from SDL joystick
|
||||
|
class SDLAnalogFactory final : public Input::Factory<Input::AnalogDevice> { |
||||
|
public: |
||||
|
/**
|
||||
|
* Creates analog device from joystick axes |
||||
|
* @param params contains parameters for creating the device: |
||||
|
* - "joystick": the index of the joystick to bind |
||||
|
* - "axis_x": the index of the axis to be bind as x-axis |
||||
|
* - "axis_y": the index of the axis to be bind as y-axis |
||||
|
*/ |
||||
|
std::unique_ptr<Input::AnalogDevice> Create(const Common::ParamPackage& params) override { |
||||
|
const int joystick_index = params.Get("joystick", 0); |
||||
|
const int axis_x = params.Get("axis_x", 0); |
||||
|
const int axis_y = params.Get("axis_y", 1); |
||||
|
return std::make_unique<SDLAnalog>(GetJoystick(joystick_index), axis_x, axis_y); |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
void Init() { |
||||
|
if (SDL_Init(SDL_INIT_JOYSTICK) < 0) { |
||||
|
LOG_CRITICAL(Input, "SDL_Init(SDL_INIT_JOYSTICK) failed with: %s", SDL_GetError()); |
||||
|
} else { |
||||
|
using namespace Input; |
||||
|
RegisterFactory<ButtonDevice>("sdl", std::make_shared<SDLButtonFactory>()); |
||||
|
RegisterFactory<AnalogDevice>("sdl", std::make_shared<SDLAnalogFactory>()); |
||||
|
initialized = true; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void Shutdown() { |
||||
|
if (initialized) { |
||||
|
using namespace Input; |
||||
|
UnregisterFactory<ButtonDevice>("sdl"); |
||||
|
UnregisterFactory<AnalogDevice>("sdl"); |
||||
|
SDL_QuitSubSystem(SDL_INIT_JOYSTICK); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
} // namespace SDL
|
||||
|
} // namespace InputCommon
|
||||
@ -0,0 +1,19 @@ |
|||||
|
// Copyright 2017 Citra Emulator Project |
||||
|
// Licensed under GPLv2 or any later version |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include "core/frontend/input.h" |
||||
|
|
||||
|
namespace InputCommon { |
||||
|
namespace SDL { |
||||
|
|
||||
|
/// Initializes and registers SDL device factories |
||||
|
void Init(); |
||||
|
|
||||
|
/// Unresisters SDL device factories and shut them down. |
||||
|
void Shutdown(); |
||||
|
|
||||
|
} // namespace SDL |
||||
|
} // namespace InputCommon |
||||
@ -0,0 +1,25 @@ |
|||||
|
// Copyright 2017 Citra Emulator Project
|
||||
|
// Licensed under GPLv2 or any later version
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
#include <catch.hpp>
|
||||
|
#include <math.h>
|
||||
|
#include "common/param_package.h"
|
||||
|
|
||||
|
namespace Common { |
||||
|
|
||||
|
TEST_CASE("ParamPackage", "[common]") { |
||||
|
ParamPackage original{ |
||||
|
{"abc", "xyz"}, {"def", "42"}, {"jkl", "$$:1:$2$,3"}, |
||||
|
}; |
||||
|
original.Set("ghi", 3.14f); |
||||
|
ParamPackage copy(original.Serialize()); |
||||
|
REQUIRE(copy.Get("abc", "") == "xyz"); |
||||
|
REQUIRE(copy.Get("def", 0) == 42); |
||||
|
REQUIRE(std::abs(copy.Get("ghi", 0.0f) - 3.14f) < 0.01f); |
||||
|
REQUIRE(copy.Get("jkl", "") == "$$:1:$2$,3"); |
||||
|
REQUIRE(copy.Get("mno", "uvw") == "uvw"); |
||||
|
REQUIRE(copy.Get("abc", 42) == 42); |
||||
|
} |
||||
|
|
||||
|
} // namespace Common
|
||||
Write
Preview
Loading…
Cancel
Save
Reference in new issue