Impaczus/rpcs3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

input: simplify mmjoy handler

Browse Source
This commit is contained in:
Megamouse
2026-03-15 11:17:23 +01:00
parent 433816148a
commit 74fbca8c80
21 changed files with 325 additions and 356 deletions
Download Patch File Download Diff File Expand all files Collapse all files
rpcs3/Emu/Io/PadHandler.cpp
+94 -53
View File
@@ -11,17 +11,69 @@ PadHandlerBase::PadHandlerBase(pad_handler type) : m_type(type)
{ {
} }
std::set<u32> PadHandlerBase::narrow_set(const std::set<u64>& src) std::set<u32> PadHandlerBase::FindKeyCodes(const std::unordered_map<u32, std::string>& map, const cfg::string& cfg_string, bool fallback)
{ {
if (src.empty()) std::set<u32> key_codes;
return {};
std::set<u32> dst; const std::string& def = cfg_string.def;
for (const u64& s : src) const std::vector<std::string> names = cfg_pad::get_buttons(cfg_string.to_string());
u32 def_code = umax;
for (const std::string& nam : names)
{ {
dst.insert(::narrow<u32>(s)); for (const auto& [code, name] : map)
{
if (name == nam)
{
key_codes.insert(code);
}
if (fallback && name == def)
def_code = code;
}
} }
return dst;
if (!key_codes.empty())
{
return key_codes;
}
if (fallback)
{
if (!names.empty())
input_log.error("FindKeyCode for [name = %s] returned with [def_code = %d] for [def = %s]", cfg_string.to_string(), def_code, def);
if (def_code != umax)
{
return { def_code };
}
}
return {};
}
std::set<u32> PadHandlerBase::FindKeyCodes(const std::unordered_map<u32, std::string>& map, const std::vector<std::string>& names)
{
std::set<u32> key_codes;
for (const std::string& name : names)
{
for (const auto& [code, nam] : map)
{
if (nam == name)
{
key_codes.insert(code);
break;
}
}
}
if (!key_codes.empty())
{
return key_codes;
}
return {};
} }
s32 PadHandlerBase::MultipliedInput(s32 raw_value, s32 multiplier) s32 PadHandlerBase::MultipliedInput(s32 raw_value, s32 multiplier)
@@ -396,7 +448,7 @@ void PadHandlerBase::convert_stick_values(u16& x_out, u16& y_out, s32 x_in, s32
} }
// Update the pad button values based on their type and thresholds. With this you can use axis or triggers as buttons or vice versa // Update the pad button values based on their type and thresholds. With this you can use axis or triggers as buttons or vice versa
void PadHandlerBase::TranslateButtonPress(const std::shared_ptr<PadDevice>& device, u64 keyCode, bool& pressed, u16& val, bool use_stick_multipliers, bool ignore_stick_threshold, bool ignore_trigger_threshold) void PadHandlerBase::TranslateButtonPress(const std::shared_ptr<PadDevice>& device, u32 keyCode, bool& pressed, u16& val, bool use_stick_multipliers, bool ignore_stick_threshold, bool ignore_trigger_threshold)
{ {
if (!device || !device->config) if (!device || !device->config)
{ {
@@ -556,63 +608,52 @@ std::array<std::set<u32>, PadHandlerBase::button::button_count> PadHandlerBase::
if (!device || !cfg) if (!device || !cfg)
return mapping; return mapping;
device->trigger_code_left = FindKeyCodes<u32, u64>(button_list, cfg->l2); mapping[button::up] = FindKeyCodes(button_list, cfg->up);
device->trigger_code_right = FindKeyCodes<u32, u64>(button_list, cfg->r2); mapping[button::down] = FindKeyCodes(button_list, cfg->down);
device->axis_code_left[0] = FindKeyCodes<u32, u64>(button_list, cfg->ls_left); mapping[button::left] = FindKeyCodes(button_list, cfg->left);
device->axis_code_left[1] = FindKeyCodes<u32, u64>(button_list, cfg->ls_right); mapping[button::right] = FindKeyCodes(button_list, cfg->right);
device->axis_code_left[2] = FindKeyCodes<u32, u64>(button_list, cfg->ls_down); mapping[button::cross] = FindKeyCodes(button_list, cfg->cross);
device->axis_code_left[3] = FindKeyCodes<u32, u64>(button_list, cfg->ls_up); mapping[button::square] = FindKeyCodes(button_list, cfg->square);
device->axis_code_right[0] = FindKeyCodes<u32, u64>(button_list, cfg->rs_left); mapping[button::circle] = FindKeyCodes(button_list, cfg->circle);
device->axis_code_right[1] = FindKeyCodes<u32, u64>(button_list, cfg->rs_right); mapping[button::triangle] = FindKeyCodes(button_list, cfg->triangle);
device->axis_code_right[2] = FindKeyCodes<u32, u64>(button_list, cfg->rs_down); mapping[button::start] = FindKeyCodes(button_list, cfg->start);
device->axis_code_right[3] = FindKeyCodes<u32, u64>(button_list, cfg->rs_up); mapping[button::select] = FindKeyCodes(button_list, cfg->select);
mapping[button::l1] = FindKeyCodes(button_list, cfg->l1);
mapping[button::l2] = FindKeyCodes(button_list, cfg->l2);
mapping[button::l3] = FindKeyCodes(button_list, cfg->l3);
mapping[button::r1] = FindKeyCodes(button_list, cfg->r1);
mapping[button::r2] = FindKeyCodes(button_list, cfg->r2);
mapping[button::r3] = FindKeyCodes(button_list, cfg->r3);
mapping[button::ls_left] = FindKeyCodes(button_list, cfg->ls_left);
mapping[button::ls_right] = FindKeyCodes(button_list, cfg->ls_right);
mapping[button::ls_down] = FindKeyCodes(button_list, cfg->ls_down);
mapping[button::ls_up] = FindKeyCodes(button_list, cfg->ls_up);
mapping[button::rs_left] = FindKeyCodes(button_list, cfg->rs_left);
mapping[button::rs_right] = FindKeyCodes(button_list, cfg->rs_right);
mapping[button::rs_down] = FindKeyCodes(button_list, cfg->rs_down);
mapping[button::rs_up] = FindKeyCodes(button_list, cfg->rs_up);
mapping[button::ps] = FindKeyCodes(button_list, cfg->ps);
mapping[button::up] = FindKeyCodes<u32, u32>(button_list, cfg->up); mapping[button::skateboard_ir_nose] = FindKeyCodes(button_list, cfg->ir_nose);
mapping[button::down] = FindKeyCodes<u32, u32>(button_list, cfg->down); mapping[button::skateboard_ir_tail] = FindKeyCodes(button_list, cfg->ir_tail);
mapping[button::left] = FindKeyCodes<u32, u32>(button_list, cfg->left); mapping[button::skateboard_ir_left] = FindKeyCodes(button_list, cfg->ir_left);
mapping[button::right] = FindKeyCodes<u32, u32>(button_list, cfg->right); mapping[button::skateboard_ir_right] = FindKeyCodes(button_list, cfg->ir_right);
mapping[button::cross] = FindKeyCodes<u32, u32>(button_list, cfg->cross); mapping[button::skateboard_tilt_left] = FindKeyCodes(button_list, cfg->tilt_left);
mapping[button::square] = FindKeyCodes<u32, u32>(button_list, cfg->square); mapping[button::skateboard_tilt_right] = FindKeyCodes(button_list, cfg->tilt_right);
mapping[button::circle] = FindKeyCodes<u32, u32>(button_list, cfg->circle);
mapping[button::triangle] = FindKeyCodes<u32, u32>(button_list, cfg->triangle);
mapping[button::start] = FindKeyCodes<u32, u32>(button_list, cfg->start);
mapping[button::select] = FindKeyCodes<u32, u32>(button_list, cfg->select);
mapping[button::l1] = FindKeyCodes<u32, u32>(button_list, cfg->l1);
mapping[button::l2] = narrow_set(device->trigger_code_left);
mapping[button::l3] = FindKeyCodes<u32, u32>(button_list, cfg->l3);
mapping[button::r1] = FindKeyCodes<u32, u32>(button_list, cfg->r1);
mapping[button::r2] = narrow_set(device->trigger_code_right);
mapping[button::r3] = FindKeyCodes<u32, u32>(button_list, cfg->r3);
mapping[button::ls_left] = narrow_set(device->axis_code_left[0]);
mapping[button::ls_right] = narrow_set(device->axis_code_left[1]);
mapping[button::ls_down] = narrow_set(device->axis_code_left[2]);
mapping[button::ls_up] = narrow_set(device->axis_code_left[3]);
mapping[button::rs_left] = narrow_set(device->axis_code_right[0]);
mapping[button::rs_right] = narrow_set(device->axis_code_right[1]);
mapping[button::rs_down] = narrow_set(device->axis_code_right[2]);
mapping[button::rs_up] = narrow_set(device->axis_code_right[3]);
mapping[button::ps] = FindKeyCodes<u32, u32>(button_list, cfg->ps);
mapping[button::skateboard_ir_nose] = FindKeyCodes<u32, u32>(button_list, cfg->ir_nose);
mapping[button::skateboard_ir_tail] = FindKeyCodes<u32, u32>(button_list, cfg->ir_tail);
mapping[button::skateboard_ir_left] = FindKeyCodes<u32, u32>(button_list, cfg->ir_left);
mapping[button::skateboard_ir_right] = FindKeyCodes<u32, u32>(button_list, cfg->ir_right);
mapping[button::skateboard_tilt_left] = FindKeyCodes<u32, u32>(button_list, cfg->tilt_left);
mapping[button::skateboard_tilt_right] = FindKeyCodes<u32, u32>(button_list, cfg->tilt_right);
if (b_has_pressure_intensity_button) if (b_has_pressure_intensity_button)
{ {
mapping[button::pressure_intensity_button] = FindKeyCodes<u32, u32>(button_list, cfg->pressure_intensity_button); mapping[button::pressure_intensity_button] = FindKeyCodes(button_list, cfg->pressure_intensity_button);
} }
if (b_has_analog_limiter_button) if (b_has_analog_limiter_button)
{ {
mapping[button::analog_limiter_button] = FindKeyCodes<u32, u32>(button_list, cfg->analog_limiter_button); mapping[button::analog_limiter_button] = FindKeyCodes(button_list, cfg->analog_limiter_button);
} }
if (b_has_orientation) if (b_has_orientation)
{ {
mapping[button::orientation_reset_button] = FindKeyCodes<u32, u32>(button_list, cfg->orientation_reset_button); mapping[button::orientation_reset_button] = FindKeyCodes(button_list, cfg->orientation_reset_button);
} }
return mapping; return mapping;
rpcs3/Emu/Io/PadHandler.h
+11 -80
View File
@@ -36,10 +36,6 @@ public:
u8 small_motor{0}; u8 small_motor{0};
bool new_output_data{true}; bool new_output_data{true};
steady_clock::time_point last_output; steady_clock::time_point last_output;
std::set<u64> trigger_code_left{};
std::set<u64> trigger_code_right{};
std::array<std::set<u64>, 4> axis_code_left{};
std::array<std::set<u64>, 4> axis_code_right{};
struct color struct color
{ {
@@ -196,76 +192,11 @@ protected:
std::shared_ptr<Pad> m_pad_for_pad_settings; std::shared_ptr<Pad> m_pad_for_pad_settings;
static std::set<u32> narrow_set(const std::set<u64>& src); // Search an unordered map for a string value and return found keycode
static std::set<u32> FindKeyCodes(const std::unordered_map<u32, std::string>& map, const cfg::string& cfg_string, bool fallback = true);
// Search an unordered map for a string value and return found keycode // Search an unordered map for a string value and return found keycode
template <typename S, typename T> static std::set<u32> FindKeyCodes(const std::unordered_map<u32, std::string>& map, const std::vector<std::string>& names);
static std::set<T> FindKeyCodes(const std::unordered_map<S, std::string>& map, const cfg::string& cfg_string, bool fallback = true)
{
std::set<T> key_codes;
const std::string& def = cfg_string.def;
const std::vector<std::string> names = cfg_pad::get_buttons(cfg_string.to_string());
T def_code = umax;
for (const std::string& nam : names)
{
for (const auto& [code, name] : map)
{
if (name == nam)
{
key_codes.insert(static_cast<T>(code));
}
if (fallback && name == def)
def_code = static_cast<T>(code);
}
}
if (!key_codes.empty())
{
return key_codes;
}
if (fallback)
{
if (!names.empty())
input_log.error("FindKeyCode for [name = %s] returned with [def_code = %d] for [def = %s]", cfg_string.to_string(), def_code, def);
if (def_code != umax)
{
return { def_code };
}
}
return {};
}
// Search an unordered map for a string value and return found keycode
template <typename S, typename T>
static std::set<T> FindKeyCodes(const std::unordered_map<S, std::string>& map, const std::vector<std::string>& names)
{
std::set<T> key_codes;
for (const std::string& name : names)
{
for (const auto& [code, nam] : map)
{
if (nam == name)
{
key_codes.insert(static_cast<T>(code));
break;
}
}
}
if (!key_codes.empty())
{
return key_codes;
}
return {};
}
// Get normalized trigger value based on the range defined by a threshold // Get normalized trigger value based on the range defined by a threshold
u16 NormalizeTriggerInput(u16 value, u32 threshold) const; u16 NormalizeTriggerInput(u16 value, u32 threshold) const;
@@ -375,23 +306,23 @@ public:
private: private:
virtual std::shared_ptr<PadDevice> get_device(const std::string& /*device*/) { return nullptr; } virtual std::shared_ptr<PadDevice> get_device(const std::string& /*device*/) { return nullptr; }
virtual bool get_is_left_trigger(const std::shared_ptr<PadDevice>& /*device*/, u64 /*keyCode*/) { return false; } virtual bool get_is_left_trigger(const std::shared_ptr<PadDevice>& /*device*/, u32 /*keyCode*/) { return false; }
virtual bool get_is_right_trigger(const std::shared_ptr<PadDevice>& /*device*/, u64 /*keyCode*/) { return false; } virtual bool get_is_right_trigger(const std::shared_ptr<PadDevice>& /*device*/, u32 /*keyCode*/) { return false; }
virtual bool get_is_left_stick(const std::shared_ptr<PadDevice>& /*device*/, u64 /*keyCode*/) { return false; } virtual bool get_is_left_stick(const std::shared_ptr<PadDevice>& /*device*/, u32 /*keyCode*/) { return false; }
virtual bool get_is_right_stick(const std::shared_ptr<PadDevice>& /*device*/, u64 /*keyCode*/) { return false; } virtual bool get_is_right_stick(const std::shared_ptr<PadDevice>& /*device*/, u32 /*keyCode*/) { return false; }
virtual bool get_is_touch_pad_motion(const std::shared_ptr<PadDevice>& /*device*/, u64 /*keyCode*/) { return false; } virtual bool get_is_touch_pad_motion(const std::shared_ptr<PadDevice>& /*device*/, u32 /*keyCode*/) { return false; }
virtual PadHandlerBase::connection update_connection(const std::shared_ptr<PadDevice>& /*device*/) { return connection::disconnected; } virtual PadHandlerBase::connection update_connection(const std::shared_ptr<PadDevice>& /*device*/) { return connection::disconnected; }
virtual void get_extended_info(const pad_ensemble& /*binding*/) {} virtual void get_extended_info(const pad_ensemble& /*binding*/) {}
virtual void apply_pad_data(const pad_ensemble& /*binding*/) {} virtual void apply_pad_data(const pad_ensemble& /*binding*/) {}
virtual std::unordered_map<u64, u16> get_button_values(const std::shared_ptr<PadDevice>& /*device*/) { return {}; } virtual std::unordered_map<u32, u16> get_button_values(const std::shared_ptr<PadDevice>& /*device*/) { return {}; }
virtual pad_preview_values get_preview_values(const std::unordered_map<u64, u16>& /*data*/) { return {}; } virtual pad_preview_values get_preview_values(const std::unordered_map<u32, u16>& /*data*/) { return {}; }
void get_orientation(const pad_ensemble& binding) const; void get_orientation(const pad_ensemble& binding) const;
protected: protected:
virtual std::array<std::set<u32>, PadHandlerBase::button::button_count> get_mapped_key_codes(const std::shared_ptr<PadDevice>& device, const cfg_pad* cfg); virtual std::array<std::set<u32>, PadHandlerBase::button::button_count> get_mapped_key_codes(const std::shared_ptr<PadDevice>& device, const cfg_pad* cfg);
virtual void get_mapping(const pad_ensemble& binding); virtual void get_mapping(const pad_ensemble& binding);
void TranslateButtonPress(const std::shared_ptr<PadDevice>& device, u64 keyCode, bool& pressed, u16& val, bool use_stick_multipliers, bool ignore_stick_threshold = false, bool ignore_trigger_threshold = false); void TranslateButtonPress(const std::shared_ptr<PadDevice>& device, u32 keyCode, bool& pressed, u16& val, bool use_stick_multipliers, bool ignore_stick_threshold = false, bool ignore_trigger_threshold = false);
void init_configs(); void init_configs();
cfg_pad* get_config(const std::string& pad_id); cfg_pad* get_config(const std::string& pad_id);
rpcs3/Input/ds3_pad_handler.cpp
+7 -7
View File
@@ -348,9 +348,9 @@ ds3_pad_handler::DataStatus ds3_pad_handler::get_data(ds3_device* ds3dev)
return DataStatus::NoNewData; return DataStatus::NoNewData;
} }
std::unordered_map<u64, u16> ds3_pad_handler::get_button_values(const std::shared_ptr<PadDevice>& device) std::unordered_map<u32, u16> ds3_pad_handler::get_button_values(const std::shared_ptr<PadDevice>& device)
{ {
std::unordered_map<u64, u16> key_buf; std::unordered_map<u32, u16> key_buf;
ds3_device* dev = static_cast<ds3_device*>(device.get()); ds3_device* dev = static_cast<ds3_device*>(device.get());
if (!dev) if (!dev)
return key_buf; return key_buf;
@@ -397,7 +397,7 @@ std::unordered_map<u64, u16> ds3_pad_handler::get_button_values(const std::share
return key_buf; return key_buf;
} }
pad_preview_values ds3_pad_handler::get_preview_values(const std::unordered_map<u64, u16>& data) pad_preview_values ds3_pad_handler::get_preview_values(const std::unordered_map<u32, u16>& data)
{ {
return { return {
::at32(data, L2), ::at32(data, L2),
@@ -460,17 +460,17 @@ void ds3_pad_handler::get_extended_info(const pad_ensemble& binding)
set_raw_orientation(*pad); set_raw_orientation(*pad);
} }
bool ds3_pad_handler::get_is_left_trigger(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool ds3_pad_handler::get_is_left_trigger(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
return keyCode == DS3KeyCodes::L2; return keyCode == DS3KeyCodes::L2;
} }
bool ds3_pad_handler::get_is_right_trigger(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool ds3_pad_handler::get_is_right_trigger(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
return keyCode == DS3KeyCodes::R2; return keyCode == DS3KeyCodes::R2;
} }
bool ds3_pad_handler::get_is_left_stick(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool ds3_pad_handler::get_is_left_stick(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
switch (keyCode) switch (keyCode)
{ {
@@ -484,7 +484,7 @@ bool ds3_pad_handler::get_is_left_stick(const std::shared_ptr<PadDevice>& /*devi
} }
} }
bool ds3_pad_handler::get_is_right_stick(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool ds3_pad_handler::get_is_right_stick(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
switch (keyCode) switch (keyCode)
{ {
rpcs3/Input/ds3_pad_handler.h
+6 -6
View File
@@ -147,13 +147,13 @@ private:
int send_output_report(ds3_device* ds3dev) override; int send_output_report(ds3_device* ds3dev) override;
void check_add_device(hid_device* hidDevice, hid_enumerated_device_view path, std::wstring_view serial) override; void check_add_device(hid_device* hidDevice, hid_enumerated_device_view path, std::wstring_view serial) override;
bool get_is_left_trigger(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_left_trigger(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_right_trigger(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_right_trigger(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_left_stick(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_left_stick(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_right_stick(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_right_stick(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
PadHandlerBase::connection update_connection(const std::shared_ptr<PadDevice>& device) override; PadHandlerBase::connection update_connection(const std::shared_ptr<PadDevice>& device) override;
void get_extended_info(const pad_ensemble& binding) override; void get_extended_info(const pad_ensemble& binding) override;
void apply_pad_data(const pad_ensemble& binding) override; void apply_pad_data(const pad_ensemble& binding) override;
std::unordered_map<u64, u16> get_button_values(const std::shared_ptr<PadDevice>& device) override; std::unordered_map<u32, u16> get_button_values(const std::shared_ptr<PadDevice>& device) override;
pad_preview_values get_preview_values(const std::unordered_map<u64, u16>& data) override; pad_preview_values get_preview_values(const std::unordered_map<u32, u16>& data) override;
}; };
rpcs3/Input/ds4_pad_handler.cpp
+8 -8
View File
@@ -250,9 +250,9 @@ void ds4_pad_handler::SetPadData(const std::string& padId, u8 player_id, u8 larg
} }
} }
std::unordered_map<u64, u16> ds4_pad_handler::get_button_values(const std::shared_ptr<PadDevice>& device) std::unordered_map<u32, u16> ds4_pad_handler::get_button_values(const std::shared_ptr<PadDevice>& device)
{ {
std::unordered_map<u64, u16> keyBuffer; std::unordered_map<u32, u16> keyBuffer;
DS4Device* dev = static_cast<DS4Device*>(device.get()); DS4Device* dev = static_cast<DS4Device*>(device.get());
if (!dev) if (!dev)
return keyBuffer; return keyBuffer;
@@ -405,7 +405,7 @@ std::unordered_map<u64, u16> ds4_pad_handler::get_button_values(const std::share
return keyBuffer; return keyBuffer;
} }
pad_preview_values ds4_pad_handler::get_preview_values(const std::unordered_map<u64, u16>& data) pad_preview_values ds4_pad_handler::get_preview_values(const std::unordered_map<u32, u16>& data)
{ {
return { return {
::at32(data, L2), ::at32(data, L2),
@@ -774,17 +774,17 @@ ds4_pad_handler::DataStatus ds4_pad_handler::get_data(DS4Device* device)
return DataStatus::NewData; return DataStatus::NewData;
} }
bool ds4_pad_handler::get_is_left_trigger(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool ds4_pad_handler::get_is_left_trigger(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
return keyCode == DS4KeyCodes::L2; return keyCode == DS4KeyCodes::L2;
} }
bool ds4_pad_handler::get_is_right_trigger(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool ds4_pad_handler::get_is_right_trigger(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
return keyCode == DS4KeyCodes::R2; return keyCode == DS4KeyCodes::R2;
} }
bool ds4_pad_handler::get_is_left_stick(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool ds4_pad_handler::get_is_left_stick(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
switch (keyCode) switch (keyCode)
{ {
@@ -798,7 +798,7 @@ bool ds4_pad_handler::get_is_left_stick(const std::shared_ptr<PadDevice>& /*devi
} }
} }
bool ds4_pad_handler::get_is_right_stick(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool ds4_pad_handler::get_is_right_stick(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
switch (keyCode) switch (keyCode)
{ {
@@ -812,7 +812,7 @@ bool ds4_pad_handler::get_is_right_stick(const std::shared_ptr<PadDevice>& /*dev
} }
} }
bool ds4_pad_handler::get_is_touch_pad_motion(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool ds4_pad_handler::get_is_touch_pad_motion(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
switch (keyCode) switch (keyCode)
{ {
rpcs3/Input/ds4_pad_handler.h
+7 -7
View File
@@ -186,14 +186,14 @@ private:
int send_output_report(DS4Device* device) override; int send_output_report(DS4Device* device) override;
void check_add_device(hid_device* hidDevice, hid_enumerated_device_view path, std::wstring_view serial) override; void check_add_device(hid_device* hidDevice, hid_enumerated_device_view path, std::wstring_view serial) override;
bool get_is_left_trigger(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_left_trigger(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_right_trigger(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_right_trigger(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_left_stick(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_left_stick(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_right_stick(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_right_stick(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_touch_pad_motion(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_touch_pad_motion(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
PadHandlerBase::connection update_connection(const std::shared_ptr<PadDevice>& device) override; PadHandlerBase::connection update_connection(const std::shared_ptr<PadDevice>& device) override;
void get_extended_info(const pad_ensemble& binding) override; void get_extended_info(const pad_ensemble& binding) override;
void apply_pad_data(const pad_ensemble& binding) override; void apply_pad_data(const pad_ensemble& binding) override;
std::unordered_map<u64, u16> get_button_values(const std::shared_ptr<PadDevice>& device) override; std::unordered_map<u32, u16> get_button_values(const std::shared_ptr<PadDevice>& device) override;
pad_preview_values get_preview_values(const std::unordered_map<u64, u16>& data) override; pad_preview_values get_preview_values(const std::unordered_map<u32, u16>& data) override;
}; };
rpcs3/Input/dualsense_pad_handler.cpp
+8 -8
View File
@@ -505,17 +505,17 @@ bool dualsense_pad_handler::get_calibration_data(DualSenseDevice* dev) const
return true; return true;
} }
bool dualsense_pad_handler::get_is_left_trigger(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool dualsense_pad_handler::get_is_left_trigger(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
return keyCode == DualSenseKeyCodes::L2; return keyCode == DualSenseKeyCodes::L2;
} }
bool dualsense_pad_handler::get_is_right_trigger(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool dualsense_pad_handler::get_is_right_trigger(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
return keyCode == DualSenseKeyCodes::R2; return keyCode == DualSenseKeyCodes::R2;
} }
bool dualsense_pad_handler::get_is_left_stick(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool dualsense_pad_handler::get_is_left_stick(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
switch (keyCode) switch (keyCode)
{ {
@@ -529,7 +529,7 @@ bool dualsense_pad_handler::get_is_left_stick(const std::shared_ptr<PadDevice>&
} }
} }
bool dualsense_pad_handler::get_is_right_stick(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool dualsense_pad_handler::get_is_right_stick(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
switch (keyCode) switch (keyCode)
{ {
@@ -543,7 +543,7 @@ bool dualsense_pad_handler::get_is_right_stick(const std::shared_ptr<PadDevice>&
} }
} }
bool dualsense_pad_handler::get_is_touch_pad_motion(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool dualsense_pad_handler::get_is_touch_pad_motion(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
switch (keyCode) switch (keyCode)
{ {
@@ -635,9 +635,9 @@ void dualsense_pad_handler::get_extended_info(const pad_ensemble& binding)
set_raw_orientation(pad->move_data, accel_x, accel_y, accel_z, gyro_x, gyro_y, gyro_z); set_raw_orientation(pad->move_data, accel_x, accel_y, accel_z, gyro_x, gyro_y, gyro_z);
} }
std::unordered_map<u64, u16> dualsense_pad_handler::get_button_values(const std::shared_ptr<PadDevice>& device) std::unordered_map<u32, u16> dualsense_pad_handler::get_button_values(const std::shared_ptr<PadDevice>& device)
{ {
std::unordered_map<u64, u16> keyBuffer; std::unordered_map<u32, u16> keyBuffer;
DualSenseDevice* dev = static_cast<DualSenseDevice*>(device.get()); DualSenseDevice* dev = static_cast<DualSenseDevice*>(device.get());
if (!dev) if (!dev)
return keyBuffer; return keyBuffer;
@@ -777,7 +777,7 @@ std::unordered_map<u64, u16> dualsense_pad_handler::get_button_values(const std:
return keyBuffer; return keyBuffer;
} }
pad_preview_values dualsense_pad_handler::get_preview_values(const std::unordered_map<u64, u16>& data) pad_preview_values dualsense_pad_handler::get_preview_values(const std::unordered_map<u32, u16>& data)
{ {
return { return {
::at32(data, L2), ::at32(data, L2),
rpcs3/Input/dualsense_pad_handler.h
+7 -7
View File
@@ -248,14 +248,14 @@ private:
void check_add_device(hid_device* hidDevice, hid_enumerated_device_view path, std::wstring_view wide_serial) override; void check_add_device(hid_device* hidDevice, hid_enumerated_device_view path, std::wstring_view wide_serial) override;
int send_output_report(DualSenseDevice* device) override; int send_output_report(DualSenseDevice* device) override;
bool get_is_left_trigger(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_left_trigger(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_right_trigger(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_right_trigger(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_left_stick(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_left_stick(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_right_stick(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_right_stick(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_touch_pad_motion(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_touch_pad_motion(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
PadHandlerBase::connection update_connection(const std::shared_ptr<PadDevice>& device) override; PadHandlerBase::connection update_connection(const std::shared_ptr<PadDevice>& device) override;
std::unordered_map<u64, u16> get_button_values(const std::shared_ptr<PadDevice>& device) override; std::unordered_map<u32, u16> get_button_values(const std::shared_ptr<PadDevice>& device) override;
pad_preview_values get_preview_values(const std::unordered_map<u64, u16>& data) override; pad_preview_values get_preview_values(const std::unordered_map<u32, u16>& data) override;
void get_extended_info(const pad_ensemble& binding) override; void get_extended_info(const pad_ensemble& binding) override;
void apply_pad_data(const pad_ensemble& binding) override; void apply_pad_data(const pad_ensemble& binding) override;
}; };
rpcs3/Input/evdev_joystick_handler.cpp
+19 -19
View File
@@ -259,9 +259,9 @@ void evdev_joystick_handler::close_devices()
} }
} }
std::unordered_map<u64, std::pair<u16, bool>> evdev_joystick_handler::GetButtonValues(const std::shared_ptr<EvdevDevice>& device) std::unordered_map<u32, std::pair<u16, bool>> evdev_joystick_handler::GetButtonValues(const std::shared_ptr<EvdevDevice>& device)
{ {
std::unordered_map<u64, std::pair<u16, bool>> button_values; std::unordered_map<u32, std::pair<u16, bool>> button_values;
if (!device) if (!device)
return button_values; return button_values;
@@ -379,23 +379,23 @@ PadHandlerBase::connection evdev_joystick_handler::get_next_button_press(const s
const auto set_value = [&value, &data](u32 code, bool dir) const auto set_value = [&value, &data](u32 code, bool dir)
{ {
if (const auto it = data.find(static_cast<u64>(code)); it != data.cend() && dir == it->second.second) if (const auto it = data.find(code); it != data.cend() && dir == it->second.second)
{ {
value = std::max(value, it->second.first); value = std::max(value, it->second.first);
} }
}; };
for (const u32 code : FindKeyCodes<u32, u32>(rev_axis_list, names)) for (const u32 code : FindKeyCodes(rev_axis_list, names))
{ {
set_value(code, true); set_value(code, true);
} }
for (const u32 code : FindKeyCodes<u32, u32>(axis_list, names)) for (const u32 code : FindKeyCodes(axis_list, names))
{ {
set_value(code, false); set_value(code, false);
} }
for (const u32 code : FindKeyCodes<u32, u32>(button_list, names)) for (const u32 code : FindKeyCodes(button_list, names))
{ {
set_value(code, false); set_value(code, false);
} }
@@ -435,7 +435,7 @@ PadHandlerBase::connection evdev_joystick_handler::get_next_button_press(const s
return; return;
// Ignore codes that aren't part of the latest events. Otherwise we will get value 0 which will reset our min_value. // Ignore codes that aren't part of the latest events. Otherwise we will get value 0 which will reset our min_value.
const auto it = data.find(static_cast<u64>(code)); const auto it = data.find(code);
if (it == data.cend()) if (it == data.cend())
{ {
if (call_type == gui_call_type::reset_input) if (call_type == gui_call_type::reset_input)
@@ -1351,17 +1351,17 @@ bool evdev_joystick_handler::bindPadToDevice(std::shared_ptr<Pad> pad)
// In evdev we store indices to an EvdevButton vector in our pad objects instead of the usual key codes. // In evdev we store indices to an EvdevButton vector in our pad objects instead of the usual key codes.
std::set<u32> indices; std::set<u32> indices;
for (const u32 code : FindKeyCodes<u32, u32>(axis_list, names)) for (const u32 code : FindKeyCodes(axis_list, names))
{ {
indices.insert(register_evdevbutton(code, true, false)); indices.insert(register_evdevbutton(code, true, false));
} }
for (const u32 code : FindKeyCodes<u32, u32>(rev_axis_list, names)) for (const u32 code : FindKeyCodes(rev_axis_list, names))
{ {
indices.insert(register_evdevbutton(code, true, true)); indices.insert(register_evdevbutton(code, true, true));
} }
for (const u32 code : FindKeyCodes<u32, u32>(button_list, names)) for (const u32 code : FindKeyCodes(button_list, names))
{ {
indices.insert(register_evdevbutton(code, false, false)); indices.insert(register_evdevbutton(code, false, false));
} }
@@ -1376,7 +1376,7 @@ bool evdev_joystick_handler::bindPadToDevice(std::shared_ptr<Pad> pad)
e_sensor.mirrored = sensor.mirrored.get(); e_sensor.mirrored = sensor.mirrored.get();
e_sensor.shift = sensor.shift.get(); e_sensor.shift = sensor.shift.get();
const std::set<u32> keys = FindKeyCodes<u32, u32>(motion_axis_list, sensor.axis); const std::set<u32> keys = FindKeyCodes(motion_axis_list, sensor.axis);
if (!keys.empty()) e_sensor.code = *keys.begin(); // We should only have one key for each of our sensors if (!keys.empty()) e_sensor.code = *keys.begin(); // We should only have one key for each of our sensors
return e_sensor; return e_sensor;
}; };
@@ -1533,24 +1533,24 @@ bool evdev_joystick_handler::check_button_sets(const std::array<std::set<u32>, 4
return std::any_of(sets.begin(), sets.end(), [this, code](const std::set<u32>& indices) { return check_button_set(indices, code); }); return std::any_of(sets.begin(), sets.end(), [this, code](const std::set<u32>& indices) { return check_button_set(indices, code); });
}; };
bool evdev_joystick_handler::get_is_left_trigger(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool evdev_joystick_handler::get_is_left_trigger(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
return check_button_set(m_dev->trigger_left, static_cast<u32>(keyCode)); return check_button_set(m_dev->trigger_left, keyCode);
} }
bool evdev_joystick_handler::get_is_right_trigger(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool evdev_joystick_handler::get_is_right_trigger(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
return check_button_set(m_dev->trigger_right, static_cast<u32>(keyCode)); return check_button_set(m_dev->trigger_right, keyCode);
} }
bool evdev_joystick_handler::get_is_left_stick(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool evdev_joystick_handler::get_is_left_stick(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
return check_button_sets(m_dev->axis_left, static_cast<u32>(keyCode)); return check_button_sets(m_dev->axis_left, keyCode);
} }
bool evdev_joystick_handler::get_is_right_stick(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool evdev_joystick_handler::get_is_right_stick(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
return check_button_sets(m_dev->axis_right, static_cast<u32>(keyCode)); return check_button_sets(m_dev->axis_right, keyCode);
} }
#endif #endif
rpcs3/Input/evdev_joystick_handler.h
+5 -5
View File
@@ -397,7 +397,7 @@ private:
bool update_device(const std::shared_ptr<PadDevice>& device); bool update_device(const std::shared_ptr<PadDevice>& device);
std::shared_ptr<evdev_joystick_handler::EvdevDevice> add_device(const std::string& device, bool in_settings = false); std::shared_ptr<evdev_joystick_handler::EvdevDevice> add_device(const std::string& device, bool in_settings = false);
std::shared_ptr<evdev_joystick_handler::EvdevDevice> add_motion_device(const std::string& device, bool in_settings); std::shared_ptr<evdev_joystick_handler::EvdevDevice> add_motion_device(const std::string& device, bool in_settings);
std::unordered_map<u64, std::pair<u16, bool>> GetButtonValues(const std::shared_ptr<EvdevDevice>& device); std::unordered_map<u32, std::pair<u16, bool>> GetButtonValues(const std::shared_ptr<EvdevDevice>& device);
void SetRumble(EvdevDevice* device, u8 large, u8 small); void SetRumble(EvdevDevice* device, u8 large, u8 small);
positive_axis m_pos_axis_config; positive_axis m_pos_axis_config;
@@ -420,10 +420,10 @@ protected:
void get_mapping(const pad_ensemble& binding) override; void get_mapping(const pad_ensemble& binding) override;
void get_extended_info(const pad_ensemble& binding) override; void get_extended_info(const pad_ensemble& binding) override;
void apply_pad_data(const pad_ensemble& binding) override; void apply_pad_data(const pad_ensemble& binding) override;
bool get_is_left_trigger(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_left_trigger(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_right_trigger(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_right_trigger(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_left_stick(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_left_stick(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_right_stick(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_right_stick(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
}; };
#endif #endif
rpcs3/Input/keyboard_pad_handler.cpp
+1 -1
View File
@@ -980,7 +980,7 @@ bool keyboard_pad_handler::bindPadToDevice(std::shared_ptr<Pad> pad)
const auto find_keys = [this](const cfg::string& name) const auto find_keys = [this](const cfg::string& name)
{ {
std::set<u32> keys = FindKeyCodes<u32, u32>(mouse_list, name, false); std::set<u32> keys = FindKeyCodes(mouse_list, name, false);
for (const u32& key : GetKeyCodes(name)) keys.insert(key); for (const u32& key : GetKeyCodes(name)) keys.insert(key);
if (!keys.empty()) if (!keys.empty())
rpcs3/Input/mm_joystick_handler.cpp
+84 -86
View File
@@ -34,23 +34,23 @@ void mm_joystick_handler::init_config(cfg_pad* cfg)
cfg->rs_down.def = ::at32(axis_list, mmjoy_axis::joy_r_neg); cfg->rs_down.def = ::at32(axis_list, mmjoy_axis::joy_r_neg);
cfg->rs_right.def = ::at32(axis_list, mmjoy_axis::joy_z_pos); cfg->rs_right.def = ::at32(axis_list, mmjoy_axis::joy_z_pos);
cfg->rs_up.def = ::at32(axis_list, mmjoy_axis::joy_r_pos); cfg->rs_up.def = ::at32(axis_list, mmjoy_axis::joy_r_pos);
cfg->start.def = ::at32(button_list, JOY_BUTTON9); cfg->start.def = ::at32(button_list, static_cast<u32>(JOY_BUTTON9));
cfg->select.def = ::at32(button_list, JOY_BUTTON10); cfg->select.def = ::at32(button_list, static_cast<u32>(JOY_BUTTON10));
cfg->ps.def = ::at32(button_list, JOY_BUTTON17); cfg->ps.def = ::at32(button_list, static_cast<u32>(JOY_BUTTON17));
cfg->square.def = ::at32(button_list, JOY_BUTTON4); cfg->square.def = ::at32(button_list, static_cast<u32>(JOY_BUTTON4));
cfg->cross.def = ::at32(button_list, JOY_BUTTON3); cfg->cross.def = ::at32(button_list, static_cast<u32>(JOY_BUTTON3));
cfg->circle.def = ::at32(button_list, JOY_BUTTON2); cfg->circle.def = ::at32(button_list, static_cast<u32>(JOY_BUTTON2));
cfg->triangle.def = ::at32(button_list, JOY_BUTTON1); cfg->triangle.def = ::at32(button_list, static_cast<u32>(JOY_BUTTON1));
cfg->left.def = ::at32(pov_list, JOY_POVLEFT); cfg->left.def = ::at32(pov_list, static_cast<u32>(JOY_POVLEFT));
cfg->down.def = ::at32(pov_list, JOY_POVBACKWARD); cfg->down.def = ::at32(pov_list, static_cast<u32>(JOY_POVBACKWARD));
cfg->right.def = ::at32(pov_list, JOY_POVRIGHT); cfg->right.def = ::at32(pov_list, static_cast<u32>(JOY_POVRIGHT));
cfg->up.def = ::at32(pov_list, JOY_POVFORWARD); cfg->up.def = ::at32(pov_list, static_cast<u32>(JOY_POVFORWARD));
cfg->r1.def = ::at32(button_list, JOY_BUTTON8); cfg->r1.def = ::at32(button_list, static_cast<u32>(JOY_BUTTON8));
cfg->r2.def = ::at32(button_list, JOY_BUTTON6); cfg->r2.def = ::at32(button_list, static_cast<u32>(JOY_BUTTON6));
cfg->r3.def = ::at32(button_list, JOY_BUTTON12); cfg->r3.def = ::at32(button_list, static_cast<u32>(JOY_BUTTON12));
cfg->l1.def = ::at32(button_list, JOY_BUTTON7); cfg->l1.def = ::at32(button_list, static_cast<u32>(JOY_BUTTON7));
cfg->l2.def = ::at32(button_list, JOY_BUTTON5); cfg->l2.def = ::at32(button_list, static_cast<u32>(JOY_BUTTON5));
cfg->l3.def = ::at32(button_list, JOY_BUTTON11); cfg->l3.def = ::at32(button_list, static_cast<u32>(JOY_BUTTON11));
cfg->pressure_intensity_button.def = ::at32(button_list, NO_BUTTON); cfg->pressure_intensity_button.def = ::at32(button_list, NO_BUTTON);
cfg->analog_limiter_button.def = ::at32(button_list, NO_BUTTON); cfg->analog_limiter_button.def = ::at32(button_list, NO_BUTTON);
@@ -102,7 +102,7 @@ void mm_joystick_handler::enumerate_devices()
{ {
MMJOYDevice dev; MMJOYDevice dev;
if (GetMMJOYDevice(i, &dev) == false) if (get_device(i, &dev) == false)
continue; continue;
auto it = m_devices.find(dev.device_name); auto it = m_devices.find(dev.device_name);
@@ -145,20 +145,18 @@ std::vector<pad_list_entry> mm_joystick_handler::list_devices()
return devices; return devices;
} }
template <typename T> std::set<u32> mm_joystick_handler::find_keys(const cfg::string& cfg_string) const
std::set<T> mm_joystick_handler::find_keys(const cfg::string& cfg_string) const
{ {
return find_keys<T>(cfg_pad::get_buttons(cfg_string.to_string())); return find_keys(cfg_pad::get_buttons(cfg_string.to_string()));
} }
template <typename T> std::set<u32> mm_joystick_handler::find_keys(const std::vector<std::string>& names) const
std::set<T> mm_joystick_handler::find_keys(const std::vector<std::string>& names) const
{ {
std::set<T> keys; std::set<u32> keys;
for (const T& k : FindKeyCodes<u64, T>(axis_list, names)) keys.insert(k); for (u32 k : FindKeyCodes(axis_list, names)) keys.insert(k);
for (const T& k : FindKeyCodes<u64, T>(pov_list, names)) keys.insert(k); for (u32 k : FindKeyCodes(pov_list, names)) keys.insert(k);
for (const T& k : FindKeyCodes<u64, T>(button_list, names)) keys.insert(k); for (u32 k : FindKeyCodes(button_list, names)) keys.insert(k);
return keys; return keys;
} }
@@ -171,58 +169,58 @@ std::array<std::set<u32>, PadHandlerBase::button::button_count> mm_joystick_hand
if (!dev || !cfg) if (!dev || !cfg)
return mapping; return mapping;
dev->trigger_code_left = find_keys<u64>(cfg->l2); dev->trigger_code_left = find_keys(cfg->l2);
dev->trigger_code_right = find_keys<u64>(cfg->r2); dev->trigger_code_right = find_keys(cfg->r2);
dev->axis_code_left[0] = find_keys<u64>(cfg->ls_left); dev->axis_code_left[0] = find_keys(cfg->ls_left);
dev->axis_code_left[1] = find_keys<u64>(cfg->ls_right); dev->axis_code_left[1] = find_keys(cfg->ls_right);
dev->axis_code_left[2] = find_keys<u64>(cfg->ls_down); dev->axis_code_left[2] = find_keys(cfg->ls_down);
dev->axis_code_left[3] = find_keys<u64>(cfg->ls_up); dev->axis_code_left[3] = find_keys(cfg->ls_up);
dev->axis_code_right[0] = find_keys<u64>(cfg->rs_left); dev->axis_code_right[0] = find_keys(cfg->rs_left);
dev->axis_code_right[1] = find_keys<u64>(cfg->rs_right); dev->axis_code_right[1] = find_keys(cfg->rs_right);
dev->axis_code_right[2] = find_keys<u64>(cfg->rs_down); dev->axis_code_right[2] = find_keys(cfg->rs_down);
dev->axis_code_right[3] = find_keys<u64>(cfg->rs_up); dev->axis_code_right[3] = find_keys(cfg->rs_up);
mapping[button::up] = find_keys<u32>(cfg->up); mapping[button::up] = find_keys(cfg->up);
mapping[button::down] = find_keys<u32>(cfg->down); mapping[button::down] = find_keys(cfg->down);
mapping[button::left] = find_keys<u32>(cfg->left); mapping[button::left] = find_keys(cfg->left);
mapping[button::right] = find_keys<u32>(cfg->right); mapping[button::right] = find_keys(cfg->right);
mapping[button::cross] = find_keys<u32>(cfg->cross); mapping[button::cross] = find_keys(cfg->cross);
mapping[button::square] = find_keys<u32>(cfg->square); mapping[button::square] = find_keys(cfg->square);
mapping[button::circle] = find_keys<u32>(cfg->circle); mapping[button::circle] = find_keys(cfg->circle);
mapping[button::triangle] = find_keys<u32>(cfg->triangle); mapping[button::triangle] = find_keys(cfg->triangle);
mapping[button::l1] = find_keys<u32>(cfg->l1); mapping[button::l1] = find_keys(cfg->l1);
mapping[button::l2] = narrow_set(dev->trigger_code_left); mapping[button::l2] = dev->trigger_code_left;
mapping[button::l3] = find_keys<u32>(cfg->l3); mapping[button::l3] = find_keys(cfg->l3);
mapping[button::r1] = find_keys<u32>(cfg->r1); mapping[button::r1] = find_keys(cfg->r1);
mapping[button::r2] = narrow_set(dev->trigger_code_right); mapping[button::r2] = dev->trigger_code_right;
mapping[button::r3] = find_keys<u32>(cfg->r3); mapping[button::r3] = find_keys(cfg->r3);
mapping[button::start] = find_keys<u32>(cfg->start); mapping[button::start] = find_keys(cfg->start);
mapping[button::select] = find_keys<u32>(cfg->select); mapping[button::select] = find_keys(cfg->select);
mapping[button::ps] = find_keys<u32>(cfg->ps); mapping[button::ps] = find_keys(cfg->ps);
mapping[button::ls_left] = narrow_set(dev->axis_code_left[0]); mapping[button::ls_left] = dev->axis_code_left[0];
mapping[button::ls_right] = narrow_set(dev->axis_code_left[1]); mapping[button::ls_right] = dev->axis_code_left[1];
mapping[button::ls_down] = narrow_set(dev->axis_code_left[2]); mapping[button::ls_down] = dev->axis_code_left[2];
mapping[button::ls_up] = narrow_set(dev->axis_code_left[3]); mapping[button::ls_up] = dev->axis_code_left[3];
mapping[button::rs_left] = narrow_set(dev->axis_code_right[0]); mapping[button::rs_left] = dev->axis_code_right[0];
mapping[button::rs_right] = narrow_set(dev->axis_code_right[1]); mapping[button::rs_right] = dev->axis_code_right[1];
mapping[button::rs_down] = narrow_set(dev->axis_code_right[2]); mapping[button::rs_down] = dev->axis_code_right[2];
mapping[button::rs_up] = narrow_set(dev->axis_code_right[3]); mapping[button::rs_up] = dev->axis_code_right[3];
mapping[button::skateboard_ir_nose] = find_keys<u32>(cfg->ir_nose); mapping[button::skateboard_ir_nose] = find_keys(cfg->ir_nose);
mapping[button::skateboard_ir_tail] = find_keys<u32>(cfg->ir_tail); mapping[button::skateboard_ir_tail] = find_keys(cfg->ir_tail);
mapping[button::skateboard_ir_left] = find_keys<u32>(cfg->ir_left); mapping[button::skateboard_ir_left] = find_keys(cfg->ir_left);
mapping[button::skateboard_ir_right] = find_keys<u32>(cfg->ir_right); mapping[button::skateboard_ir_right] = find_keys(cfg->ir_right);
mapping[button::skateboard_tilt_left] = find_keys<u32>(cfg->tilt_left); mapping[button::skateboard_tilt_left] = find_keys(cfg->tilt_left);
mapping[button::skateboard_tilt_right] = find_keys<u32>(cfg->tilt_right); mapping[button::skateboard_tilt_right] = find_keys(cfg->tilt_right);
if (b_has_pressure_intensity_button) if (b_has_pressure_intensity_button)
{ {
mapping[button::pressure_intensity_button] = find_keys<u32>(cfg->pressure_intensity_button); mapping[button::pressure_intensity_button] = find_keys(cfg->pressure_intensity_button);
} }
if (b_has_analog_limiter_button) if (b_has_analog_limiter_button)
{ {
mapping[button::analog_limiter_button] = find_keys<u32>(cfg->analog_limiter_button); mapping[button::analog_limiter_button] = find_keys(cfg->analog_limiter_button);
} }
return mapping; return mapping;
@@ -295,7 +293,7 @@ PadHandlerBase::connection mm_joystick_handler::get_next_button_press(const std:
std::string name; std::string name;
} pressed_button{}; } pressed_button{};
const auto set_button_press = [&](const u64& keycode, const std::string& name, std::string_view type, u16 threshold) const auto set_button_press = [&](u32 keycode, const std::string& name, std::string_view type, u16 threshold)
{ {
if (call_type != gui_call_type::blacklist && m_blacklist.contains(keycode)) if (call_type != gui_call_type::blacklist && m_blacklist.contains(keycode))
return; return;
@@ -365,7 +363,7 @@ PadHandlerBase::connection mm_joystick_handler::get_next_button_press(const std:
const auto get_key_value = [this, &data](const std::string& str) -> u16 const auto get_key_value = [this, &data](const std::string& str) -> u16
{ {
u16 value{}; u16 value{};
for (u32 key_code : find_keys<u32>(cfg_pad::get_buttons(str))) for (u32 key_code : find_keys(cfg_pad::get_buttons(str)))
{ {
if (const auto it = data.find(key_code); it != data.cend()) if (const auto it = data.find(key_code); it != data.cend())
{ {
@@ -399,9 +397,9 @@ PadHandlerBase::connection mm_joystick_handler::get_next_button_press(const std:
return connection::no_data; return connection::no_data;
} }
std::unordered_map<u64, u16> mm_joystick_handler::GetButtonValues(const JOYINFOEX& js_info, const JOYCAPS& js_caps) std::unordered_map<u32, u16> mm_joystick_handler::GetButtonValues(const JOYINFOEX& js_info, const JOYCAPS& js_caps)
{ {
std::unordered_map<u64, u16> button_values; std::unordered_map<u32, u16> button_values;
for (const auto& entry : button_list) for (const auto& entry : button_list)
{ {
@@ -424,7 +422,7 @@ std::unordered_map<u64, u16> mm_joystick_handler::GetButtonValues(const JOYINFOE
} }
else else
{ {
auto emplacePOVs = [&](float val, u64 pov_neg, u64 pov_pos) const auto emplacePOVs = [&](float val, u32 pov_neg, u32 pov_pos)
{ {
if (val < 0) if (val < 0)
{ {
@@ -461,7 +459,7 @@ std::unordered_map<u64, u16> mm_joystick_handler::GetButtonValues(const JOYINFOE
} }
} }
auto add_axis_value = [&](DWORD axis, UINT min, UINT max, u64 pos, u64 neg) auto add_axis_value = [&](DWORD axis, UINT min, UINT max, u32 pos, u32 neg)
{ {
constexpr f32 deadzone = 0.0f; constexpr f32 deadzone = 0.0f;
const float val = ScaledAxisInput(static_cast<f32>(axis), static_cast<f32>(min), static_cast<f32>(max), deadzone); const float val = ScaledAxisInput(static_cast<f32>(axis), static_cast<f32>(min), static_cast<f32>(max), deadzone);
@@ -495,11 +493,11 @@ std::unordered_map<u64, u16> mm_joystick_handler::GetButtonValues(const JOYINFOE
return button_values; return button_values;
} }
std::unordered_map<u64, u16> mm_joystick_handler::get_button_values(const std::shared_ptr<PadDevice>& device) std::unordered_map<u32, u16> mm_joystick_handler::get_button_values(const std::shared_ptr<PadDevice>& device)
{ {
MMJOYDevice* dev = static_cast<MMJOYDevice*>(device.get()); MMJOYDevice* dev = static_cast<MMJOYDevice*>(device.get());
if (!dev) if (!dev)
return std::unordered_map<u64, u16>(); return std::unordered_map<u32, u16>();
return GetButtonValues(dev->device_info, dev->device_caps); return GetButtonValues(dev->device_info, dev->device_caps);
} }
@@ -539,7 +537,7 @@ std::shared_ptr<mm_joystick_handler::MMJOYDevice> mm_joystick_handler::create_de
return dev; return dev;
} }
bool mm_joystick_handler::GetMMJOYDevice(int index, MMJOYDevice* dev) const bool mm_joystick_handler::get_device(int index, MMJOYDevice* dev) const
{ {
if (!dev) if (!dev)
return false; return false;
@@ -578,28 +576,28 @@ std::shared_ptr<PadDevice> mm_joystick_handler::get_device(const std::string& de
return get_device_by_name(device); return get_device_by_name(device);
} }
bool mm_joystick_handler::get_is_left_trigger(const std::shared_ptr<PadDevice>& device, u64 keyCode) bool mm_joystick_handler::get_is_left_trigger(const std::shared_ptr<PadDevice>& device, u32 keyCode)
{ {
const MMJOYDevice* dev = static_cast<MMJOYDevice*>(device.get()); const MMJOYDevice* dev = static_cast<MMJOYDevice*>(device.get());
return dev && dev->trigger_code_left.contains(keyCode); return dev && dev->trigger_code_left.contains(keyCode);
} }
bool mm_joystick_handler::get_is_right_trigger(const std::shared_ptr<PadDevice>& device, u64 keyCode) bool mm_joystick_handler::get_is_right_trigger(const std::shared_ptr<PadDevice>& device, u32 keyCode)
{ {
const MMJOYDevice* dev = static_cast<MMJOYDevice*>(device.get()); const MMJOYDevice* dev = static_cast<MMJOYDevice*>(device.get());
return dev && dev->trigger_code_right.contains(keyCode); return dev && dev->trigger_code_right.contains(keyCode);
} }
bool mm_joystick_handler::get_is_left_stick(const std::shared_ptr<PadDevice>& device, u64 keyCode) bool mm_joystick_handler::get_is_left_stick(const std::shared_ptr<PadDevice>& device, u32 keyCode)
{ {
const MMJOYDevice* dev = static_cast<MMJOYDevice*>(device.get()); const MMJOYDevice* dev = static_cast<MMJOYDevice*>(device.get());
return dev && std::any_of(dev->axis_code_left.cbegin(), dev->axis_code_left.cend(), [&keyCode](const std::set<u64>& s){ return s.contains(keyCode); }); return dev && std::any_of(dev->axis_code_left.cbegin(), dev->axis_code_left.cend(), [&keyCode](const std::set<u32>& s){ return s.contains(keyCode); });
} }
bool mm_joystick_handler::get_is_right_stick(const std::shared_ptr<PadDevice>& device, u64 keyCode) bool mm_joystick_handler::get_is_right_stick(const std::shared_ptr<PadDevice>& device, u32 keyCode)
{ {
const MMJOYDevice* dev = static_cast<MMJOYDevice*>(device.get()); const MMJOYDevice* dev = static_cast<MMJOYDevice*>(device.get());
return dev && std::any_of(dev->axis_code_right.cbegin(), dev->axis_code_right.cend(), [&keyCode](const std::set<u64>& s){ return s.contains(keyCode); }); return dev && std::any_of(dev->axis_code_right.cbegin(), dev->axis_code_right.cend(), [&keyCode](const std::set<u32>& s){ return s.contains(keyCode); });
} }
PadHandlerBase::connection mm_joystick_handler::update_connection(const std::shared_ptr<PadDevice>& device) PadHandlerBase::connection mm_joystick_handler::update_connection(const std::shared_ptr<PadDevice>& device)
@@ -630,7 +628,7 @@ PadHandlerBase::connection mm_joystick_handler::update_connection(const std::sha
} }
// Try to connect properly again // Try to connect properly again
if (GetMMJOYDevice(dev->device_id, dev)) if (get_device(dev->device_id, dev))
return connection::connected; return connection::connected;
return connection::disconnected; return connection::disconnected;
rpcs3/Input/mm_joystick_handler.h
+20 -19
View File
@@ -16,10 +16,10 @@
class mm_joystick_handler final : public PadHandlerBase class mm_joystick_handler final : public PadHandlerBase
{ {
static constexpr u64 NO_BUTTON = u64{umax}; static constexpr u32 NO_BUTTON = u32{umax};
// Unique names for the config files and our pad settings dialog // Unique names for the config files and our pad settings dialog
const std::unordered_map<u64, std::string> button_list = const std::unordered_map<u32, std::string> button_list =
{ {
{ NO_BUTTON , "" }, { NO_BUTTON , "" },
{ JOY_BUTTON1 , "Button 1" }, { JOY_BUTTON1 , "Button 1" },
@@ -57,7 +57,7 @@ class mm_joystick_handler final : public PadHandlerBase
}; };
// Unique names for the config files and our pad settings dialog // Unique names for the config files and our pad settings dialog
const std::unordered_map<u64, std::string> pov_list = const std::unordered_map<u32, std::string> pov_list =
{ {
{ JOY_POVFORWARD, "POV Up" }, { JOY_POVFORWARD, "POV Up" },
{ JOY_POVRIGHT, "POV Right" }, { JOY_POVRIGHT, "POV Right" },
@@ -65,7 +65,7 @@ class mm_joystick_handler final : public PadHandlerBase
{ JOY_POVLEFT, "POV Left" } { JOY_POVLEFT, "POV Left" }
}; };
enum mmjoy_axis enum mmjoy_axis : u32
{ {
joy_x_pos = 9700, joy_x_pos = 9700,
joy_x_neg, joy_x_neg,
@@ -82,7 +82,7 @@ class mm_joystick_handler final : public PadHandlerBase
}; };
// Unique names for the config files and our pad settings dialog // Unique names for the config files and our pad settings dialog
const std::unordered_map<u64, std::string> axis_list = const std::unordered_map<u32, std::string> axis_list =
{ {
{ joy_x_pos, "X+" }, { joy_x_pos, "X+" },
{ joy_x_neg, "X-" }, { joy_x_neg, "X-" },
@@ -106,6 +106,10 @@ class mm_joystick_handler final : public PadHandlerBase
JOYCAPS device_caps{}; JOYCAPS device_caps{};
MMRESULT device_status = JOYERR_UNPLUGGED; MMRESULT device_status = JOYERR_UNPLUGGED;
steady_clock::time_point last_update{}; steady_clock::time_point last_update{};
std::set<u32> trigger_code_left{};
std::set<u32> trigger_code_right{};
std::array<std::set<u32>, 4> axis_code_left{};
std::array<std::set<u32>, 4> axis_code_right{};
}; };
public: public:
@@ -118,31 +122,28 @@ public:
void init_config(cfg_pad* cfg) override; void init_config(cfg_pad* cfg) override;
private: private:
std::unordered_map<u64, u16> GetButtonValues(const JOYINFOEX& js_info, const JOYCAPS& js_caps); std::unordered_map<u32, u16> GetButtonValues(const JOYINFOEX& js_info, const JOYCAPS& js_caps);
std::shared_ptr<MMJOYDevice> get_device_by_name(const std::string& name); std::shared_ptr<MMJOYDevice> get_device_by_name(const std::string& name);
std::shared_ptr<MMJOYDevice> create_device_by_name(const std::string& name); std::shared_ptr<MMJOYDevice> create_device_by_name(const std::string& name);
bool GetMMJOYDevice(int index, MMJOYDevice* dev) const; bool get_device(int index, MMJOYDevice* dev) const;
void enumerate_devices(); void enumerate_devices();
bool m_is_init = false; bool m_is_init = false;
std::set<u64> m_blacklist; std::set<u32> m_blacklist;
std::unordered_map<u64, u16> m_min_button_values; std::unordered_map<u32, u16> m_min_button_values;
std::map<std::string, std::shared_ptr<MMJOYDevice>> m_devices; std::map<std::string, std::shared_ptr<MMJOYDevice>> m_devices;
template <typename T> std::set<u32> find_keys(const std::vector<std::string>& names) const;
std::set<T> find_keys(const std::vector<std::string>& names) const; std::set<u32> find_keys(const cfg::string& cfg_string) const;
template <typename T>
std::set<T> find_keys(const cfg::string& cfg_string) const;
std::array<std::set<u32>, PadHandlerBase::button::button_count> get_mapped_key_codes(const std::shared_ptr<PadDevice>& device, const cfg_pad* cfg) override; std::array<std::set<u32>, PadHandlerBase::button::button_count> get_mapped_key_codes(const std::shared_ptr<PadDevice>& device, const cfg_pad* cfg) override;
std::shared_ptr<PadDevice> get_device(const std::string& device) override; std::shared_ptr<PadDevice> get_device(const std::string& device) override;
bool get_is_left_trigger(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_left_trigger(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_right_trigger(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_right_trigger(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_left_stick(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_left_stick(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_right_stick(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_right_stick(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
PadHandlerBase::connection update_connection(const std::shared_ptr<PadDevice>& device) override; PadHandlerBase::connection update_connection(const std::shared_ptr<PadDevice>& device) override;
std::unordered_map<u64, u16> get_button_values(const std::shared_ptr<PadDevice>& device) override; std::unordered_map<u32, u16> get_button_values(const std::shared_ptr<PadDevice>& device) override;
}; };
#endif #endif
rpcs3/Input/ps_move_handler.cpp
+5 -5
View File
@@ -580,21 +580,21 @@ void ps_move_handler::handle_external_device(const pad_ensemble& binding)
move_data.external_device_write_requested = false; move_data.external_device_write_requested = false;
} }
bool ps_move_handler::get_is_left_trigger(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool ps_move_handler::get_is_left_trigger(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
// We also report the T button as left trigger // We also report the T button as left trigger
return keyCode == ps_move_key_codes::L2 || keyCode == ps_move_key_codes::t; return keyCode == ps_move_key_codes::L2 || keyCode == ps_move_key_codes::t;
} }
bool ps_move_handler::get_is_right_trigger(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool ps_move_handler::get_is_right_trigger(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
// We also report the Throttle button as right trigger // We also report the Throttle button as right trigger
return keyCode == ps_move_key_codes::R2 || keyCode == ps_move_key_codes::throttle; return keyCode == ps_move_key_codes::R2 || keyCode == ps_move_key_codes::throttle;
} }
std::unordered_map<u64, u16> ps_move_handler::get_button_values(const std::shared_ptr<PadDevice>& device) std::unordered_map<u32, u16> ps_move_handler::get_button_values(const std::shared_ptr<PadDevice>& device)
{ {
std::unordered_map<u64, u16> key_buf; std::unordered_map<u32, u16> key_buf;
ps_move_device* dev = static_cast<ps_move_device*>(device.get()); ps_move_device* dev = static_cast<ps_move_device*>(device.get());
if (!dev) if (!dev)
return key_buf; return key_buf;
@@ -760,7 +760,7 @@ void ps_move_handler::get_extended_info(const pad_ensemble& binding)
handle_external_device(binding); handle_external_device(binding);
} }
pad_preview_values ps_move_handler::get_preview_values(const std::unordered_map<u64, u16>& data) pad_preview_values ps_move_handler::get_preview_values(const std::unordered_map<u32, u16>& data)
{ {
return { return {
std::max(::at32(data, ps_move_key_codes::L2), ::at32(data, ps_move_key_codes::t)), std::max(::at32(data, ps_move_key_codes::L2), ::at32(data, ps_move_key_codes::t)),
rpcs3/Input/ps_move_handler.h
+4 -4
View File
@@ -192,11 +192,11 @@ private:
void check_add_device(hid_device* hidDevice, hid_enumerated_device_view path, std::wstring_view wide_serial) override; void check_add_device(hid_device* hidDevice, hid_enumerated_device_view path, std::wstring_view wide_serial) override;
int send_output_report(ps_move_device* device) override; int send_output_report(ps_move_device* device) override;
bool get_is_left_trigger(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_left_trigger(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_right_trigger(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_right_trigger(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
PadHandlerBase::connection update_connection(const std::shared_ptr<PadDevice>& device) override; PadHandlerBase::connection update_connection(const std::shared_ptr<PadDevice>& device) override;
std::unordered_map<u64, u16> get_button_values(const std::shared_ptr<PadDevice>& device) override; std::unordered_map<u32, u16> get_button_values(const std::shared_ptr<PadDevice>& device) override;
pad_preview_values get_preview_values(const std::unordered_map<u64, u16>& data) override; pad_preview_values get_preview_values(const std::unordered_map<u32, u16>& data) override;
void get_extended_info(const pad_ensemble& binding) override; void get_extended_info(const pad_ensemble& binding) override;
void apply_pad_data(const pad_ensemble& binding) override; void apply_pad_data(const pad_ensemble& binding) override;
rpcs3/Input/sdl_pad_handler.cpp
+8 -8
View File
@@ -881,17 +881,17 @@ void sdl_pad_handler::set_rumble(SDLDevice* dev, u8 speed_large, u8 speed_small)
} }
} }
bool sdl_pad_handler::get_is_left_trigger(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool sdl_pad_handler::get_is_left_trigger(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
return keyCode == SDLKeyCodes::LT; return keyCode == SDLKeyCodes::LT;
} }
bool sdl_pad_handler::get_is_right_trigger(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool sdl_pad_handler::get_is_right_trigger(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
return keyCode == SDLKeyCodes::RT; return keyCode == SDLKeyCodes::RT;
} }
bool sdl_pad_handler::get_is_left_stick(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool sdl_pad_handler::get_is_left_stick(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
switch (keyCode) switch (keyCode)
{ {
@@ -905,7 +905,7 @@ bool sdl_pad_handler::get_is_left_stick(const std::shared_ptr<PadDevice>& /*devi
} }
} }
bool sdl_pad_handler::get_is_right_stick(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool sdl_pad_handler::get_is_right_stick(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
switch (keyCode) switch (keyCode)
{ {
@@ -919,7 +919,7 @@ bool sdl_pad_handler::get_is_right_stick(const std::shared_ptr<PadDevice>& /*dev
} }
} }
bool sdl_pad_handler::get_is_touch_pad_motion(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool sdl_pad_handler::get_is_touch_pad_motion(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
switch (keyCode) switch (keyCode)
{ {
@@ -933,9 +933,9 @@ bool sdl_pad_handler::get_is_touch_pad_motion(const std::shared_ptr<PadDevice>&
} }
} }
std::unordered_map<u64, u16> sdl_pad_handler::get_button_values(const std::shared_ptr<PadDevice>& device) std::unordered_map<u32, u16> sdl_pad_handler::get_button_values(const std::shared_ptr<PadDevice>& device)
{ {
std::unordered_map<u64, u16> values; std::unordered_map<u32, u16> values;
SDLDevice* dev = static_cast<SDLDevice*>(device.get()); SDLDevice* dev = static_cast<SDLDevice*>(device.get());
if (!dev || !dev->sdl.gamepad) if (!dev || !dev->sdl.gamepad)
return values; return values;
@@ -1086,7 +1086,7 @@ std::unordered_map<u64, u16> sdl_pad_handler::get_button_values(const std::share
return values; return values;
} }
pad_preview_values sdl_pad_handler::get_preview_values(const std::unordered_map<u64, u16>& data) pad_preview_values sdl_pad_handler::get_preview_values(const std::unordered_map<u32, u16>& data)
{ {
return { return {
::at32(data, LT), ::at32(data, LT),
rpcs3/Input/sdl_pad_handler.h
+7 -7
View File
@@ -171,13 +171,13 @@ private:
PadHandlerBase::connection update_connection(const std::shared_ptr<PadDevice>& device) override; PadHandlerBase::connection update_connection(const std::shared_ptr<PadDevice>& device) override;
void get_extended_info(const pad_ensemble& binding) override; void get_extended_info(const pad_ensemble& binding) override;
void apply_pad_data(const pad_ensemble& binding) override; void apply_pad_data(const pad_ensemble& binding) override;
bool get_is_left_trigger(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_left_trigger(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_right_trigger(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_right_trigger(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_left_stick(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_left_stick(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_right_stick(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_right_stick(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_touch_pad_motion(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_touch_pad_motion(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
std::unordered_map<u64, u16> get_button_values(const std::shared_ptr<PadDevice>& device) override; std::unordered_map<u32, u16> get_button_values(const std::shared_ptr<PadDevice>& device) override;
pad_preview_values get_preview_values(const std::unordered_map<u64, u16>& data) override; pad_preview_values get_preview_values(const std::unordered_map<u32, u16>& data) override;
u32 get_battery_color(int power_level, u32 brightness) const; u32 get_battery_color(int power_level, u32 brightness) const;
void set_rumble(SDLDevice* dev, u8 speed_large, u8 speed_small); void set_rumble(SDLDevice* dev, u8 speed_large, u8 speed_small);
rpcs3/Input/skateboard_pad_handler.cpp
+3 -3
View File
@@ -272,9 +272,9 @@ PadHandlerBase::connection skateboard_pad_handler::update_connection(const std::
return connection::connected; return connection::connected;
} }
std::unordered_map<u64, u16> skateboard_pad_handler::get_button_values(const std::shared_ptr<PadDevice>& device) std::unordered_map<u32, u16> skateboard_pad_handler::get_button_values(const std::shared_ptr<PadDevice>& device)
{ {
std::unordered_map<u64, u16> key_buf; std::unordered_map<u32, u16> key_buf;
skateboard_device* dev = static_cast<skateboard_device*>(device.get()); skateboard_device* dev = static_cast<skateboard_device*>(device.get());
if (!dev) if (!dev)
return key_buf; return key_buf;
@@ -328,7 +328,7 @@ void skateboard_pad_handler::get_extended_info(const pad_ensemble& binding)
set_raw_orientation(*pad); set_raw_orientation(*pad);
} }
pad_preview_values skateboard_pad_handler::get_preview_values(const std::unordered_map<u64, u16>& /*data*/) pad_preview_values skateboard_pad_handler::get_preview_values(const std::unordered_map<u32, u16>& /*data*/)
{ {
// There is no proper user interface for skateboard values yet // There is no proper user interface for skateboard values yet
return {}; return {};
rpcs3/Input/skateboard_pad_handler.h
+2 -2
View File
@@ -183,8 +183,8 @@ private:
int send_output_report(skateboard_device* device) override; int send_output_report(skateboard_device* device) override;
PadHandlerBase::connection update_connection(const std::shared_ptr<PadDevice>& device) override; PadHandlerBase::connection update_connection(const std::shared_ptr<PadDevice>& device) override;
std::unordered_map<u64, u16> get_button_values(const std::shared_ptr<PadDevice>& device) override; std::unordered_map<u32, u16> get_button_values(const std::shared_ptr<PadDevice>& device) override;
pad_preview_values get_preview_values(const std::unordered_map<u64, u16>& data) override; pad_preview_values get_preview_values(const std::unordered_map<u32, u16>& data) override;
void get_extended_info(const pad_ensemble& binding) override; void get_extended_info(const pad_ensemble& binding) override;
void apply_pad_data(const pad_ensemble& binding) override; void apply_pad_data(const pad_ensemble& binding) override;
}; };
rpcs3/Input/xinput_pad_handler.cpp
+11 -11
View File
@@ -201,9 +201,9 @@ int xinput_pad_handler::GetDeviceNumber(const std::string& padId)
return device_number; return device_number;
} }
std::unordered_map<u64, u16> xinput_pad_handler::get_button_values(const std::shared_ptr<PadDevice>& device) std::unordered_map<u32, u16> xinput_pad_handler::get_button_values(const std::shared_ptr<PadDevice>& device)
{ {
PadButtonValues values; std::unordered_map<u32, u16> values;
XInputDevice* dev = static_cast<XInputDevice*>(device.get()); XInputDevice* dev = static_cast<XInputDevice*>(device.get());
if (!dev || dev->state != ERROR_SUCCESS) // the state has to be aquired with update_connection before calling this function if (!dev || dev->state != ERROR_SUCCESS) // the state has to be aquired with update_connection before calling this function
return values; return values;
@@ -217,9 +217,9 @@ std::unordered_map<u64, u16> xinput_pad_handler::get_button_values(const std::sh
return get_button_values_base(dev->state_base, m_trigger_recognition_mode); return get_button_values_base(dev->state_base, m_trigger_recognition_mode);
} }
xinput_pad_handler::PadButtonValues xinput_pad_handler::get_button_values_base(const XINPUT_STATE& state, trigger_recognition_mode trigger_mode) std::unordered_map<u32, u16> xinput_pad_handler::get_button_values_base(const XINPUT_STATE& state, trigger_recognition_mode trigger_mode)
{ {
PadButtonValues values; std::unordered_map<u32, u16> values;
// Triggers // Triggers
if (trigger_mode == trigger_recognition_mode::any || trigger_mode == trigger_recognition_mode::one_directional) if (trigger_mode == trigger_recognition_mode::any || trigger_mode == trigger_recognition_mode::one_directional)
@@ -291,9 +291,9 @@ xinput_pad_handler::PadButtonValues xinput_pad_handler::get_button_values_base(c
return values; return values;
} }
xinput_pad_handler::PadButtonValues xinput_pad_handler::get_button_values_scp(const SCP_EXTN& state, trigger_recognition_mode trigger_mode) std::unordered_map<u32, u16> xinput_pad_handler::get_button_values_scp(const SCP_EXTN& state, trigger_recognition_mode trigger_mode)
{ {
PadButtonValues values; std::unordered_map<u32, u16> values;
// Triggers // Triggers
if (trigger_mode == trigger_recognition_mode::any || trigger_mode == trigger_recognition_mode::one_directional) if (trigger_mode == trigger_recognition_mode::any || trigger_mode == trigger_recognition_mode::one_directional)
@@ -359,7 +359,7 @@ xinput_pad_handler::PadButtonValues xinput_pad_handler::get_button_values_scp(co
return values; return values;
} }
pad_preview_values xinput_pad_handler::get_preview_values(const std::unordered_map<u64, u16>& data) pad_preview_values xinput_pad_handler::get_preview_values(const std::unordered_map<u32, u16>& data)
{ {
return { return {
::at32(data, LT), ::at32(data, LT),
@@ -455,17 +455,17 @@ std::shared_ptr<PadDevice> xinput_pad_handler::get_device(const std::string& dev
return dev; return dev;
} }
bool xinput_pad_handler::get_is_left_trigger(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool xinput_pad_handler::get_is_left_trigger(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
return keyCode == XInputKeyCodes::LT; return keyCode == XInputKeyCodes::LT;
} }
bool xinput_pad_handler::get_is_right_trigger(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool xinput_pad_handler::get_is_right_trigger(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
return keyCode == XInputKeyCodes::RT; return keyCode == XInputKeyCodes::RT;
} }
bool xinput_pad_handler::get_is_left_stick(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool xinput_pad_handler::get_is_left_stick(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
switch (keyCode) switch (keyCode)
{ {
@@ -479,7 +479,7 @@ bool xinput_pad_handler::get_is_left_stick(const std::shared_ptr<PadDevice>& /*d
} }
} }
bool xinput_pad_handler::get_is_right_stick(const std::shared_ptr<PadDevice>& /*device*/, u64 keyCode) bool xinput_pad_handler::get_is_right_stick(const std::shared_ptr<PadDevice>& /*device*/, u32 keyCode)
{ {
switch (keyCode) switch (keyCode)
{ {
rpcs3/Input/xinput_pad_handler.h
+8 -10
View File
@@ -93,8 +93,6 @@ class xinput_pad_handler final : public PadHandlerBase
RSYPos RSYPos
}; };
using PadButtonValues = std::unordered_map<u64, u16>;
struct XInputDevice : public PadDevice struct XInputDevice : public PadDevice
{ {
u32 deviceNumber{ 0 }; u32 deviceNumber{ 0 };
@@ -123,8 +121,8 @@ private:
using PFN_XINPUTGETBATTERYINFORMATION = DWORD(WINAPI*)(DWORD, BYTE, XINPUT_BATTERY_INFORMATION*); using PFN_XINPUTGETBATTERYINFORMATION = DWORD(WINAPI*)(DWORD, BYTE, XINPUT_BATTERY_INFORMATION*);
int GetDeviceNumber(const std::string& padId); int GetDeviceNumber(const std::string& padId);
static PadButtonValues get_button_values_base(const XINPUT_STATE& state, trigger_recognition_mode trigger_mode); static std::unordered_map<u32, u16> get_button_values_base(const XINPUT_STATE& state, trigger_recognition_mode trigger_mode);
static PadButtonValues get_button_values_scp(const SCP_EXTN& state, trigger_recognition_mode trigger_mode); static std::unordered_map<u32, u16> get_button_values_scp(const SCP_EXTN& state, trigger_recognition_mode trigger_mode);
PFN_XINPUTGETEXTENDED xinputGetExtended{ nullptr }; PFN_XINPUTGETEXTENDED xinputGetExtended{ nullptr };
PFN_XINPUTGETCUSTOMDATA xinputGetCustomData{ nullptr }; PFN_XINPUTGETCUSTOMDATA xinputGetCustomData{ nullptr };
@@ -134,13 +132,13 @@ private:
utils::dynamic_library library; utils::dynamic_library library;
std::shared_ptr<PadDevice> get_device(const std::string& device) override; std::shared_ptr<PadDevice> get_device(const std::string& device) override;
bool get_is_left_trigger(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_left_trigger(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_right_trigger(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_right_trigger(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_left_stick(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_left_stick(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
bool get_is_right_stick(const std::shared_ptr<PadDevice>& device, u64 keyCode) override; bool get_is_right_stick(const std::shared_ptr<PadDevice>& device, u32 keyCode) override;
PadHandlerBase::connection update_connection(const std::shared_ptr<PadDevice>& device) override; PadHandlerBase::connection update_connection(const std::shared_ptr<PadDevice>& device) override;
void get_extended_info(const pad_ensemble& binding) override; void get_extended_info(const pad_ensemble& binding) override;
void apply_pad_data(const pad_ensemble& binding) override; void apply_pad_data(const pad_ensemble& binding) override;
std::unordered_map<u64, u16> get_button_values(const std::shared_ptr<PadDevice>& device) override; std::unordered_map<u32, u16> get_button_values(const std::shared_ptr<PadDevice>& device) override;
pad_preview_values get_preview_values(const std::unordered_map<u64, u16>& data) override; pad_preview_values get_preview_values(const std::unordered_map<u32, u16>& data) override;
}; };