RPCSX/rpcsx
1
0
Fork 0
mirror of https://github.com/RPCSX/rpcsx.git synced 2026-04-05 14:37:08 +00:00
Code Issues Projects Releases Packages Wiki Activity

Input: Abbreviate some variable names and add min output interval

Browse source 
The abbreviation allows for easier diff between handlers.
This commit is contained in:
Megamouse 2024-08-17 11:21:11 +02:00
parent 9a071746ed
commit 08f81160cc
14 changed files with 246 additions and 221 deletions
Download patch file Download diff file Expand all files Collapse all files

99
rpcs3/Input/ds4_pad_handler.cpp
View file

@ -253,11 +253,11 @@ 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<u64, u16> keyBuffer;
DS4Device* ds4_dev = static_cast<DS4Device*>(device.get());
if (!ds4_dev)
DS4Device* dev = static_cast<DS4Device*>(device.get());
if (!dev)
return keyBuffer;
const ds4_input_report_common& input = ds4_dev->bt_controller ? ds4_dev->report_bt.common : ds4_dev->report_usb.common;
const ds4_input_report_common& input = dev->bt_controller ? dev->report_bt.common : dev->report_usb.common;
// Left Stick X Axis
keyBuffer[DS4KeyCodes::LSXNeg] = Clamp0To255((127.5f - input.x) * 2.0f);
@ -383,9 +383,9 @@ std::unordered_map<u64, u16> ds4_pad_handler::get_button_values(const std::share
}
};
if (ds4_dev->bt_controller)
if (dev->bt_controller)
{
const ds4_input_report_bt& report = ds4_dev->report_bt;
const ds4_input_report_bt& report = dev->report_bt;
for (u32 i = 0; i < std::min<u32>(report.num_touch_reports, ::size32(report.touch_reports)); i++)
{
@ -394,7 +394,7 @@ std::unordered_map<u64, u16> ds4_pad_handler::get_button_values(const std::share
}
else
{
const ds4_input_report_usb& report = ds4_dev->report_usb;
const ds4_input_report_usb& report = dev->report_usb;
for (u32 i = 0; i < std::min<u32>(report.num_touch_reports, ::size32(report.touch_reports)); i++)
{
@ -828,23 +828,26 @@ bool ds4_pad_handler::get_is_touch_pad_motion(const std::shared_ptr<PadDevice>&
PadHandlerBase::connection ds4_pad_handler::update_connection(const std::shared_ptr<PadDevice>& device)
{
DS4Device* ds4_dev = static_cast<DS4Device*>(device.get());
if (!ds4_dev || ds4_dev->path.empty())
DS4Device* dev = static_cast<DS4Device*>(device.get());
if (!dev || dev->path.empty())
return connection::disconnected;
if (ds4_dev->hidDevice == nullptr)
if (dev->hidDevice == nullptr)
{
// try to reconnect
hid_device* dev = hid_open_path(ds4_dev->path.c_str());
if (dev)
if (hid_device* hid_dev = hid_open_path(dev->path.c_str()))
{
if (hid_set_nonblocking(dev, 1) == -1)
if (hid_set_nonblocking(hid_dev, 1) == -1)
{
ds4_log.error("Reconnecting Device %s: hid_set_nonblocking failed with error %s", ds4_dev->path, hid_error(dev));
ds4_log.error("Reconnecting Device %s: hid_set_nonblocking failed with error %s", dev->path, hid_error(hid_dev));
}
dev->hidDevice = hid_dev;
if (!dev->has_calib_data)
{
dev->has_calib_data = GetCalibrationData(dev);
}
ds4_dev->hidDevice = dev;
if (!ds4_dev->has_calib_data)
ds4_dev->has_calib_data = GetCalibrationData(ds4_dev);
}
else
{
@ -853,10 +856,10 @@ PadHandlerBase::connection ds4_pad_handler::update_connection(const std::shared_
}
}
if (get_data(ds4_dev) == DataStatus::ReadError)
if (get_data(dev) == DataStatus::ReadError)
{
// this also can mean disconnected, either way deal with it on next loop and reconnect
ds4_dev->close();
dev->close();
return connection::no_data;
}
@ -869,14 +872,14 @@ void ds4_pad_handler::get_extended_info(const pad_ensemble& binding)
const auto& device = binding.device;
const auto& pad = binding.pad;
DS4Device* ds4_device = static_cast<DS4Device*>(device.get());
if (!ds4_device || !pad)
DS4Device* dev = static_cast<DS4Device*>(device.get());
if (!dev || !pad)
return;
const ds4_input_report_common& input = ds4_device->bt_controller ? ds4_device->report_bt.common : ds4_device->report_usb.common;
const ds4_input_report_common& input = dev->bt_controller ? dev->report_bt.common : dev->report_usb.common;
pad->m_battery_level = ds4_device->battery_level;
pad->m_cable_state = ds4_device->cable_state;
pad->m_battery_level = dev->battery_level;
pad->m_cable_state = dev->cable_state;
// these values come already calibrated, all we need to do is convert to ds3 range
@ -910,11 +913,11 @@ void ds4_pad_handler::apply_pad_data(const pad_ensemble& binding)
const auto& device = binding.device;
const auto& pad = binding.pad;
DS4Device* ds4_dev = static_cast<DS4Device*>(device.get());
if (!ds4_dev || !ds4_dev->hidDevice || !ds4_dev->config || !pad)
DS4Device* dev = static_cast<DS4Device*>(device.get());
if (!dev || !dev->hidDevice || !dev->config || !pad)
return;
cfg_pad* config = ds4_dev->config;
cfg_pad* config = dev->config;
// Attempt to send rumble no matter what
const int idx_l = config->switch_vibration_motors ? 1 : 0;
@ -923,9 +926,9 @@ void ds4_pad_handler::apply_pad_data(const pad_ensemble& binding)
const u8 speed_large = config->enable_vibration_motor_large ? pad->m_vibrateMotors[idx_l].m_value : 0;
const u8 speed_small = config->enable_vibration_motor_small ? pad->m_vibrateMotors[idx_s].m_value : 0;
const bool wireless = ds4_dev->cable_state == 0;
const bool low_battery = ds4_dev->battery_level < 2;
const bool is_blinking = ds4_dev->led_delay_on > 0 || ds4_dev->led_delay_off > 0;
const bool wireless = dev->cable_state == 0;
const bool low_battery = dev->battery_level < 2;
const bool is_blinking = dev->led_delay_on > 0 || dev->led_delay_off > 0;
// Blink LED when battery is low
if (config->led_low_battery_blink)
@ -933,16 +936,16 @@ void ds4_pad_handler::apply_pad_data(const pad_ensemble& binding)
// we are now wired or have okay battery level -> stop blinking
if (is_blinking && !(wireless && low_battery))
{
ds4_dev->led_delay_on = 0;
ds4_dev->led_delay_off = 0;
ds4_dev->new_output_data = true;
dev->led_delay_on = 0;
dev->led_delay_off = 0;
dev->new_output_data = true;
}
// we are now wireless and low on battery -> blink
else if (!is_blinking && wireless && low_battery)
{
ds4_dev->led_delay_on = 100;
ds4_dev->led_delay_off = 100;
ds4_dev->new_output_data = true;
dev->led_delay_on = 100;
dev->led_delay_off = 100;
dev->new_output_data = true;
}
}
@ -950,31 +953,35 @@ void ds4_pad_handler::apply_pad_data(const pad_ensemble& binding)
if (config->led_battery_indicator)
{
// This makes sure that the LED color doesn't update every 1ms. DS4 only reports battery level in 10% increments
if (ds4_dev->last_battery_level != ds4_dev->battery_level)
if (dev->last_battery_level != dev->battery_level)
{
const u32 combined_color = get_battery_color(ds4_dev->battery_level, config->led_battery_indicator_brightness);
const u32 combined_color = get_battery_color(dev->battery_level, config->led_battery_indicator_brightness);
config->colorR.set(combined_color >> 8);
config->colorG.set(combined_color & 0xff);
config->colorB.set(0);
ds4_dev->new_output_data = true;
ds4_dev->last_battery_level = ds4_dev->battery_level;
dev->new_output_data = true;
dev->last_battery_level = dev->battery_level;
}
}
ds4_dev->new_output_data |= ds4_dev->large_motor != speed_large || ds4_dev->small_motor != speed_small;
dev->new_output_data |= dev->large_motor != speed_large || dev->small_motor != speed_small;
ds4_dev->large_motor = speed_large;
ds4_dev->small_motor = speed_small;
dev->large_motor = speed_large;
dev->small_motor = speed_small;
if (ds4_dev->new_output_data)
const auto now = steady_clock::now();
const auto elapsed = now - dev->last_output;
if (dev->new_output_data || elapsed > min_output_interval)
{
if (const int res = send_output_report(ds4_dev); res >= 0)
if (const int res = send_output_report(dev); res >= 0)
{
ds4_dev->new_output_data = false;
dev->new_output_data = false;
dev->last_output = now;
}
else if (res == -1)
{
ds4_log.error("apply_pad_data: send_output_report failed! error=%s", hid_error(ds4_dev->hidDevice));
ds4_log.error("apply_pad_data: send_output_report failed! error=%s", hid_error(dev->hidDevice));
}
}
}