RPCS3/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2026-03-10 23:45:16 +01:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Address review comments

Browse source
This commit is contained in:
Barış Hamil 2026-02-11 11:24:57 +03:00
parent 1369699f77
commit bb9d12ba22
5 changed files with 46 additions and 80 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

100
rpcs3/Input/hid_instance.cpp
View file

@ -8,6 +8,8 @@
#include "3rdparty/hidapi/hidapi/mac/hidapi_darwin.h"
#endif
LOG_CHANNEL(hid_log, "HID");
std::mutex g_hid_mutex;
hid_instance::~hid_instance()
@ -68,96 +70,58 @@ bool hid_instance::initialize()
hid_device_info* hid_instance::enumerate(u16 vid, u16 pid)
{
hid_device_info* devs = nullptr;
#if defined(__APPLE__)
if (thread_ctrl::is_main())
{
std::lock_guard lock(g_hid_mutex);
devs = hid_enumerate(vid, pid);
}
else
{
Emu.BlockingCallFromMainThread([&]()
{
std::lock_guard lock(g_hid_mutex);
devs = hid_enumerate(vid, pid);
}, false);
}
#else
std::lock_guard lock(g_hid_mutex);
devs = hid_enumerate(vid, pid);
#if defined(__APPLE__)
if (!thread_ctrl::is_main())
{
hid_device_info* devs = nullptr;
Emu.BlockingCallFromMainThread([&]() { devs = hid_enumerate(vid, pid); }, false);
return devs;
}
#endif
return devs;
return hid_enumerate(vid, pid);
}
void hid_instance::free_enumeration(hid_device_info* devs)
{
if (!devs) return;
#if defined(__APPLE__)
if (thread_ctrl::is_main())
{
std::lock_guard lock(g_hid_mutex);
hid_free_enumeration(devs);
}
else
{
Emu.BlockingCallFromMainThread([&]()
{
std::lock_guard lock(g_hid_mutex);
hid_free_enumeration(devs);
}, false);
}
#else
std::lock_guard lock(g_hid_mutex);
hid_free_enumeration(devs);
#if defined(__APPLE__)
if (!thread_ctrl::is_main())
{
Emu.BlockingCallFromMainThread([&]() { hid_free_enumeration(devs); }, false);
return;
}
#endif
hid_free_enumeration(devs);
}
hid_device* hid_instance::open_path(const char* path)
{
hid_device* dev = nullptr;
#if defined(__APPLE__)
if (thread_ctrl::is_main())
{
std::lock_guard lock(g_hid_mutex);
dev = hid_open_path(path);
}
else
{
Emu.BlockingCallFromMainThread([&]()
{
std::lock_guard lock(g_hid_mutex);
dev = hid_open_path(path);
}, false);
}
#else
std::lock_guard lock(g_hid_mutex);
dev = hid_open_path(path);
#if defined(__APPLE__)
if (!thread_ctrl::is_main())
{
hid_device* dev = nullptr;
Emu.BlockingCallFromMainThread([&]() { dev = hid_open_path(path); }, false);
return dev;
}
#endif
return dev;
return hid_open_path(path);
}
void hid_instance::close(hid_device* dev)
{
if (!dev) return;
#if defined(__APPLE__)
if (thread_ctrl::is_main())
{
std::lock_guard lock(g_hid_mutex);
hid_close(dev);
}
else
{
Emu.BlockingCallFromMainThread([&]()
{
std::lock_guard lock(g_hid_mutex);
hid_close(dev);
}, false);
}
#else
std::lock_guard lock(g_hid_mutex);
hid_close(dev);
#if defined(__APPLE__)
if (!thread_ctrl::is_main())
{
Emu.BlockingCallFromMainThread([&]() { hid_close(dev); }, false);
return;
}
#endif
hid_close(dev);
}

3
rpcs3/Input/hid_instance.h
View file

@ -1,12 +1,9 @@
#pragma once
#include "util/types.hpp"
#include "util/logs.hpp"
#include <mutex>
#include <hidapi.h>
LOG_CHANNEL(hid_log, "HID");
struct hid_instance
{
public:

2
rpcs3/Input/hid_pad_handler.cpp
View file

@ -12,6 +12,8 @@
#include <algorithm>
#include <memory>
LOG_CHANNEL(hid_log, "HID");
#ifdef ANDROID
std::vector<android_usb_device> g_android_usb_devices;
std::mutex g_android_usb_devices_mutex;

20
rpcs3/Input/wiimote_handler.cpp
View file

@ -6,6 +6,8 @@
#include "util/yaml.hpp"
#include "util/logs.hpp"
#include <algorithm>
#include <initializer_list>
#include <vector>
LOG_CHANNEL(wiimote_log, "Wiimote");
@ -364,7 +366,7 @@ void wiimote_handler::thread_proc()
// Scan every 2 seconds
if (counter++ % 200 == 0)
{
const auto scan_and_add = [&](u16 vid, u16 pid_start, u16 pid_end)
const auto scan_and_add = [&](u16 vid, std::initializer_list<std::pair<u16, u16>> ranges)
{
struct info_t
{
@ -377,9 +379,13 @@ void wiimote_handler::thread_proc()
hid_device_info* devs = hid_instance::enumerate(vid, 0);
for (hid_device_info* cur = devs; cur; cur = cur->next)
{
if (cur->product_id >= pid_start && cur->product_id <= pid_end)
for (const auto& range : ranges)
{
candidates.push_back({cur->path, cur->product_id, cur->serial_number ? cur->serial_number : L""});
if (cur->product_id >= range.first && cur->product_id <= range.second)
{
candidates.push_back({cur->path, cur->product_id, cur->serial_number ? cur->serial_number : L""});
break;
}
}
}
hid_instance::free_enumeration(devs);
@ -447,12 +453,10 @@ void wiimote_handler::thread_proc()
}
};
// Generic Wiimote / DolphinBar Mode 4 (Normal)
scan_and_add(VID_NINTENDO, PID_WIIMOTE, PID_WIIMOTE);
// Wiimote Plus
scan_and_add(VID_NINTENDO, PID_WIIMOTE_PLUS, PID_WIIMOTE_PLUS);
// Generic Wiimote / Wiimote Plus / DolphinBar Mode 4 (Normal)
scan_and_add(VID_NINTENDO, {{PID_WIIMOTE, PID_WIIMOTE}, {PID_WIIMOTE_PLUS, PID_WIIMOTE_PLUS}});
// Mayflash DolphinBar Mode 4 (Custom VID/PIDs)
scan_and_add(VID_MAYFLASH, PID_DOLPHINBAR_START, PID_DOLPHINBAR_END);
scan_and_add(VID_MAYFLASH, {{PID_DOLPHINBAR_START, PID_DOLPHINBAR_END}});
}
// Update all devices at 100Hz

1
rpcs3/rpcs3qt/gui_application.h
View file

@ -13,7 +13,6 @@
#include "main_application.h"
#include "Emu/System.h"
#include "Input/wiimote_handler.h"
#include "Input/raw_mouse_handler.h"
#include <memory>