GC Adapter Implementation
This commit is contained in:
Ameer
parent
f98bf1025f
commit
0248614add
|
|
@ -93,7 +93,10 @@ u32 Controller_NPad::IndexToNPad(std::size_t index) {
|
|||
};
|
||||
}
|
||||
|
||||
Controller_NPad::Controller_NPad(Core::System& system) : ControllerBase(system), system(system) {}
|
||||
Controller_NPad::Controller_NPad(Core::System& system)
|
||||
: ControllerBase(system), system(system) {
|
||||
}
|
||||
|
||||
Controller_NPad::~Controller_NPad() = default;
|
||||
|
||||
void Controller_NPad::InitNewlyAddedControler(std::size_t controller_idx) {
|
||||
|
|
@ -194,7 +197,8 @@ void Controller_NPad::OnInit() {
|
|||
|
||||
std::transform(
|
||||
Settings::values.players.begin(), Settings::values.players.end(),
|
||||
connected_controllers.begin(), [](const Settings::PlayerInput& player) {
|
||||
connected_controllers.begin(), [](const Settings::PlayerInput& player)
|
||||
{
|
||||
return ControllerHolder{MapSettingsTypeToNPad(player.type), player.connected};
|
||||
});
|
||||
|
||||
|
|
@ -238,7 +242,8 @@ void Controller_NPad::OnLoadInputDevices() {
|
|||
}
|
||||
}
|
||||
|
||||
void Controller_NPad::OnRelease() {}
|
||||
void Controller_NPad::OnRelease() {
|
||||
}
|
||||
|
||||
void Controller_NPad::RequestPadStateUpdate(u32 npad_id) {
|
||||
const auto controller_idx = NPadIdToIndex(npad_id);
|
||||
|
|
@ -276,16 +281,20 @@ void Controller_NPad::RequestPadStateUpdate(u32 npad_id) {
|
|||
pad_state.d_down.Assign(button_state[DDown - BUTTON_HID_BEGIN]->GetStatus());
|
||||
|
||||
pad_state.l_stick_right.Assign(
|
||||
analog_state[static_cast<std::size_t>(JoystickId::Joystick_Left)]->GetAnalogDirectionStatus(
|
||||
analog_state[static_cast<std::size_t>(JoystickId::Joystick_Left)]->
|
||||
GetAnalogDirectionStatus(
|
||||
Input::AnalogDirection::RIGHT));
|
||||
pad_state.l_stick_left.Assign(
|
||||
analog_state[static_cast<std::size_t>(JoystickId::Joystick_Left)]->GetAnalogDirectionStatus(
|
||||
analog_state[static_cast<std::size_t>(JoystickId::Joystick_Left)]->
|
||||
GetAnalogDirectionStatus(
|
||||
Input::AnalogDirection::LEFT));
|
||||
pad_state.l_stick_up.Assign(
|
||||
analog_state[static_cast<std::size_t>(JoystickId::Joystick_Left)]->GetAnalogDirectionStatus(
|
||||
analog_state[static_cast<std::size_t>(JoystickId::Joystick_Left)]->
|
||||
GetAnalogDirectionStatus(
|
||||
Input::AnalogDirection::UP));
|
||||
pad_state.l_stick_down.Assign(
|
||||
analog_state[static_cast<std::size_t>(JoystickId::Joystick_Left)]->GetAnalogDirectionStatus(
|
||||
analog_state[static_cast<std::size_t>(JoystickId::Joystick_Left)]->
|
||||
GetAnalogDirectionStatus(
|
||||
Input::AnalogDirection::DOWN));
|
||||
|
||||
pad_state.r_stick_right.Assign(
|
||||
|
|
@ -459,7 +468,8 @@ void Controller_NPad::SetSupportedNPadIdTypes(u8* data, std::size_t length) {
|
|||
continue;
|
||||
}
|
||||
const auto requested_controller =
|
||||
i <= MAX_NPAD_ID ? MapSettingsTypeToNPad(Settings::values.players[i].type)
|
||||
i <= MAX_NPAD_ID
|
||||
? MapSettingsTypeToNPad(Settings::values.players[i].type)
|
||||
: NPadControllerType::Handheld;
|
||||
if (!IsControllerSupported(requested_controller)) {
|
||||
const auto is_handheld = requested_controller == NPadControllerType::Handheld;
|
||||
|
|
|
|||
|
|
@ -7,6 +7,10 @@ add_library(input_common STATIC
|
|||
main.h
|
||||
motion_emu.cpp
|
||||
motion_emu.h
|
||||
gcadapter/gc_adapter.cpp
|
||||
gcadapter/gc_adapter.h
|
||||
gcadapter/gc_poller.cpp
|
||||
gcadapter/gc_poller.h
|
||||
sdl/sdl.cpp
|
||||
sdl/sdl.h
|
||||
udp/client.cpp
|
||||
|
|
@ -26,5 +30,7 @@ if(SDL2_FOUND)
|
|||
target_compile_definitions(input_common PRIVATE HAVE_SDL2)
|
||||
endif()
|
||||
|
||||
target_link_libraries(input_common PUBLIC ${LIBUSB_LIBRARIES})
|
||||
|
||||
create_target_directory_groups(input_common)
|
||||
target_link_libraries(input_common PUBLIC core PRIVATE common Boost::boost)
|
||||
|
|
|
|||
|
|
@ -14,7 +14,8 @@ public:
|
|||
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_) {}
|
||||
modifier_scale(modifier_scale_) {
|
||||
}
|
||||
|
||||
std::tuple<float, float> GetStatus() const override {
|
||||
constexpr float SQRT_HALF = 0.707106781f;
|
||||
|
|
|
|||
|
|
@ -0,0 +1,350 @@
|
|||
// Copyright 2014 Dolphin Emulator Project
|
||||
// Licensed under GPLv2+
|
||||
// Refer to the license.txt file included.
|
||||
//*
|
||||
#include "common/logging/log.h"
|
||||
#include "common/threadsafe_queue.h"
|
||||
#include "input_common/gcadapter/gc_adapter.h"
|
||||
|
||||
Common::SPSCQueue<GCPadStatus> pad_queue[4];
|
||||
struct GCState state[4];
|
||||
|
||||
namespace GCAdapter {
|
||||
|
||||
static libusb_device_handle* usb_adapter_handle = nullptr;
|
||||
static u8 adapter_controllers_status[4] = {
|
||||
ControllerTypes::CONTROLLER_NONE, ControllerTypes::CONTROLLER_NONE,
|
||||
ControllerTypes::CONTROLLER_NONE, ControllerTypes::CONTROLLER_NONE};
|
||||
|
||||
static std::mutex s_mutex;
|
||||
|
||||
static std::thread adapter_input_thread;
|
||||
static bool adapter_thread_running;
|
||||
|
||||
static std::mutex initialization_mutex;
|
||||
static std::thread detect_thread;
|
||||
static bool detect_thread_running = false;
|
||||
|
||||
static libusb_context* libusb_ctx;
|
||||
|
||||
static u8 input_endpoint = 0;
|
||||
|
||||
static bool configuring = false;
|
||||
|
||||
GCPadStatus CheckStatus(int port, u8 adapter_payload[37]) {
|
||||
GCPadStatus pad = {};
|
||||
bool get_origin = false;
|
||||
|
||||
u8 type = adapter_payload[1 + (9 * port)] >> 4;
|
||||
if (type)
|
||||
get_origin = true;
|
||||
|
||||
adapter_controllers_status[port] = type;
|
||||
|
||||
if (adapter_controllers_status[port] != ControllerTypes::CONTROLLER_NONE) {
|
||||
u8 b1 = adapter_payload[1 + (9 * port) + 1];
|
||||
u8 b2 = adapter_payload[1 + (9 * port) + 2];
|
||||
|
||||
if (b1 & (1 << 0))
|
||||
pad.button |= PAD_BUTTON_A;
|
||||
if (b1 & (1 << 1))
|
||||
pad.button |= PAD_BUTTON_B;
|
||||
if (b1 & (1 << 2))
|
||||
pad.button |= PAD_BUTTON_X;
|
||||
if (b1 & (1 << 3))
|
||||
pad.button |= PAD_BUTTON_Y;
|
||||
|
||||
if (b1 & (1 << 4))
|
||||
pad.button |= PAD_BUTTON_LEFT;
|
||||
if (b1 & (1 << 5))
|
||||
pad.button |= PAD_BUTTON_RIGHT;
|
||||
if (b1 & (1 << 6))
|
||||
pad.button |= PAD_BUTTON_DOWN;
|
||||
if (b1 & (1 << 7))
|
||||
pad.button |= PAD_BUTTON_UP;
|
||||
|
||||
if (b2 & (1 << 0))
|
||||
pad.button |= PAD_BUTTON_START;
|
||||
if (b2 & (1 << 1))
|
||||
pad.button |= PAD_TRIGGER_Z;
|
||||
if (b2 & (1 << 2))
|
||||
pad.button |= PAD_TRIGGER_R;
|
||||
if (b2 & (1 << 3))
|
||||
pad.button |= PAD_TRIGGER_L;
|
||||
|
||||
if (get_origin)
|
||||
pad.button |= PAD_GET_ORIGIN;
|
||||
|
||||
pad.stickX = adapter_payload[1 + (9 * port) + 3];
|
||||
pad.stickY = adapter_payload[1 + (9 * port) + 4];
|
||||
pad.substickX = adapter_payload[1 + (9 * port) + 5];
|
||||
pad.substickY = adapter_payload[1 + (9 * port) + 6];
|
||||
pad.triggerLeft = adapter_payload[1 + (9 * port) + 7];
|
||||
pad.triggerRight = adapter_payload[1 + (9 * port) + 8];
|
||||
}
|
||||
return pad;
|
||||
}
|
||||
|
||||
void PadToState(GCPadStatus pad, GCState& state) {
|
||||
//std::lock_guard lock{s_mutex};
|
||||
state.buttons.insert_or_assign(PAD_BUTTON_A, pad.button & PAD_BUTTON_A);
|
||||
state.buttons.insert_or_assign(PAD_BUTTON_B, pad.button & PAD_BUTTON_B);
|
||||
state.buttons.insert_or_assign(PAD_BUTTON_X, pad.button & PAD_BUTTON_X);
|
||||
state.buttons.insert_or_assign(PAD_BUTTON_Y, pad.button & PAD_BUTTON_Y);
|
||||
state.buttons.insert_or_assign(PAD_BUTTON_LEFT, pad.button & PAD_BUTTON_LEFT);
|
||||
state.buttons.insert_or_assign(PAD_BUTTON_RIGHT, pad.button & PAD_BUTTON_RIGHT);
|
||||
state.buttons.insert_or_assign(PAD_BUTTON_DOWN, pad.button & PAD_BUTTON_DOWN);
|
||||
state.buttons.insert_or_assign(PAD_BUTTON_UP, pad.button & PAD_BUTTON_UP);
|
||||
state.buttons.insert_or_assign(PAD_BUTTON_START, pad.button & PAD_BUTTON_START);
|
||||
state.buttons.insert_or_assign(PAD_TRIGGER_Z, pad.button & PAD_TRIGGER_Z);
|
||||
state.buttons.insert_or_assign(PAD_TRIGGER_L, pad.button & PAD_TRIGGER_L);
|
||||
state.buttons.insert_or_assign(PAD_TRIGGER_R, pad.button & PAD_TRIGGER_R);
|
||||
state.axes.insert_or_assign(STICK_X, pad.stickX);
|
||||
state.axes.insert_or_assign(STICK_Y, pad.stickY);
|
||||
state.axes.insert_or_assign(SUBSTICK_X, pad.substickX);
|
||||
state.axes.insert_or_assign(SUBSTICK_Y, pad.substickY);
|
||||
state.axes.insert_or_assign(TRIGGER_LEFT, pad.triggerLeft);
|
||||
state.axes.insert_or_assign(TRIGGER_RIGHT, pad.triggerRight);
|
||||
}
|
||||
|
||||
static void Read() {
|
||||
LOG_INFO(Input, "GC Adapter Read() thread started");
|
||||
|
||||
int payload_size_in;
|
||||
u8 adapter_payload[37];
|
||||
while (adapter_thread_running) {
|
||||
libusb_interrupt_transfer(usb_adapter_handle, input_endpoint, adapter_payload,
|
||||
sizeof(adapter_payload), &payload_size_in, 32);
|
||||
|
||||
int payload_size = 0;
|
||||
u8 controller_payload_copy[37];
|
||||
|
||||
{
|
||||
std::lock_guard<std::mutex> lk(s_mutex);
|
||||
std::copy(std::begin(adapter_payload), std::end(adapter_payload),
|
||||
std::begin(controller_payload_copy));
|
||||
payload_size = payload_size_in;
|
||||
}
|
||||
|
||||
GCPadStatus pad[4];
|
||||
if (payload_size != sizeof(controller_payload_copy) ||
|
||||
controller_payload_copy[0] != LIBUSB_DT_HID) {
|
||||
LOG_ERROR(Input, "error reading payload (size: %d, type: %02x)", payload_size,
|
||||
controller_payload_copy[0]);
|
||||
} else {
|
||||
for (int i = 0; i < 4; i++)
|
||||
pad[i] = CheckStatus(i, controller_payload_copy);
|
||||
}
|
||||
for (int port = 0; port < 4; port++) {
|
||||
if (DeviceConnected(port) && configuring) {
|
||||
if (pad[port].button != PAD_GET_ORIGIN)
|
||||
pad_queue[port].Push(pad[port]);
|
||||
|
||||
// Accounting for a threshold here because of some controller variance
|
||||
if (pad[port].stickX > pad[port].MAIN_STICK_CENTER_X + pad[port].THRESHOLD ||
|
||||
pad[port].stickX < pad[port].MAIN_STICK_CENTER_X - pad[port].THRESHOLD) {
|
||||
pad[port].axis_which = STICK_X;
|
||||
pad[port].axis_value = pad[port].stickX;
|
||||
pad_queue[port].Push(pad[port]);
|
||||
}
|
||||
if (pad[port].stickY > pad[port].MAIN_STICK_CENTER_Y + pad[port].THRESHOLD ||
|
||||
pad[port].stickY < pad[port].MAIN_STICK_CENTER_Y - pad[port].THRESHOLD) {
|
||||
pad[port].axis_which = STICK_Y;
|
||||
pad[port].axis_value = pad[port].stickY;
|
||||
pad_queue[port].Push(pad[port]);
|
||||
}
|
||||
if (pad[port].substickX > pad[port].C_STICK_CENTER_X + pad[port].THRESHOLD ||
|
||||
pad[port].substickX < pad[port].C_STICK_CENTER_X - pad[port].THRESHOLD) {
|
||||
pad[port].axis_which = SUBSTICK_X;
|
||||
pad[port].axis_value = pad[port].substickX;
|
||||
pad_queue[port].Push(pad[port]);
|
||||
}
|
||||
if (pad[port].substickY > pad[port].C_STICK_CENTER_Y + pad[port].THRESHOLD ||
|
||||
pad[port].substickY < pad[port].C_STICK_CENTER_Y - pad[port].THRESHOLD) {
|
||||
pad[port].axis_which = SUBSTICK_Y;
|
||||
pad[port].axis_value = pad[port].substickY;
|
||||
pad_queue[port].Push(pad[port]);
|
||||
}
|
||||
}
|
||||
PadToState(pad[port], state[port]);
|
||||
}
|
||||
std::this_thread::yield();
|
||||
}
|
||||
}
|
||||
|
||||
static void ScanThreadFunc() {
|
||||
LOG_INFO(Input, "GC Adapter scanning thread started");
|
||||
|
||||
while (detect_thread_running) {
|
||||
if (usb_adapter_handle == nullptr) {
|
||||
std::lock_guard<std::mutex> lk(initialization_mutex);
|
||||
Setup();
|
||||
}
|
||||
Sleep(500);
|
||||
}
|
||||
}
|
||||
|
||||
void Init() {
|
||||
|
||||
if (usb_adapter_handle != nullptr)
|
||||
return;
|
||||
LOG_INFO(Input, "GC Adapter Initialization started");
|
||||
|
||||
current_status = NO_ADAPTER_DETECTED;
|
||||
libusb_init(&libusb_ctx);
|
||||
|
||||
StartScanThread();
|
||||
}
|
||||
|
||||
void StartScanThread() {
|
||||
if (detect_thread_running)
|
||||
return;
|
||||
if (!libusb_ctx)
|
||||
return;
|
||||
|
||||
detect_thread_running = true;
|
||||
detect_thread = std::thread(ScanThreadFunc);
|
||||
}
|
||||
|
||||
void StopScanThread() {
|
||||
detect_thread.join();
|
||||
}
|
||||
|
||||
static void Setup() {
|
||||
// Reset the error status in case the adapter gets unplugged
|
||||
if (current_status < 0)
|
||||
current_status = NO_ADAPTER_DETECTED;
|
||||
|
||||
for (int i = 0; i < 4; i++)
|
||||
adapter_controllers_status[i] = ControllerTypes::CONTROLLER_NONE;
|
||||
|
||||
libusb_device** devs; // pointer to list of connected usb devices
|
||||
|
||||
int cnt = libusb_get_device_list(libusb_ctx, &devs); //get the list of devices
|
||||
|
||||
for (int i = 0; i < cnt; i++) {
|
||||
if (CheckDeviceAccess(devs[i])) {
|
||||
// GC Adapter found, registering it
|
||||
GetGCEndpoint(devs[i]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static bool CheckDeviceAccess(libusb_device* device) {
|
||||
libusb_device_descriptor desc;
|
||||
int ret = libusb_get_device_descriptor(device, &desc);
|
||||
if (ret) {
|
||||
// could not acquire the descriptor, no point in trying to use it.
|
||||
LOG_ERROR(Input, "libusb_get_device_descriptor failed with error: %d", ret);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (desc.idVendor != 0x057e || desc.idProduct != 0x0337) {
|
||||
// This isn’t the device we are looking for.
|
||||
return false;
|
||||
}
|
||||
ret = libusb_open(device, &usb_adapter_handle);
|
||||
|
||||
if (ret == LIBUSB_ERROR_ACCESS) {
|
||||
LOG_ERROR(Input,
|
||||
"Yuzu can not gain access to this device: ID %04X:%04X.",
|
||||
desc.idVendor, desc.idProduct);
|
||||
return false;
|
||||
}
|
||||
if (ret) {
|
||||
LOG_ERROR(Input, "libusb_open failed to open device with error = %d", ret);
|
||||
return false;
|
||||
}
|
||||
|
||||
ret = libusb_kernel_driver_active(usb_adapter_handle, 0);
|
||||
if (ret == 1) {
|
||||
ret = libusb_detach_kernel_driver(usb_adapter_handle, 0);
|
||||
if (ret != 0 && ret != LIBUSB_ERROR_NOT_SUPPORTED)
|
||||
LOG_ERROR(Input, "libusb_detach_kernel_driver failed with error = %d", ret);
|
||||
}
|
||||
|
||||
if (ret != 0 && ret != LIBUSB_ERROR_NOT_SUPPORTED) {
|
||||
libusb_close(usb_adapter_handle);
|
||||
usb_adapter_handle = nullptr;
|
||||
return false;
|
||||
}
|
||||
|
||||
ret = libusb_claim_interface(usb_adapter_handle, 0);
|
||||
if (ret) {
|
||||
LOG_ERROR(Input, "libusb_claim_interface failed with error = %d", ret);
|
||||
libusb_close(usb_adapter_handle);
|
||||
usb_adapter_handle = nullptr;
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static void GetGCEndpoint(libusb_device* device) {
|
||||
libusb_config_descriptor* config = nullptr;
|
||||
libusb_get_config_descriptor(device, 0, &config);
|
||||
for (u8 ic = 0; ic < config->bNumInterfaces; ic++) {
|
||||
const libusb_interface* interfaceContainer = &config->interface[ic];
|
||||
for (int i = 0; i < interfaceContainer->num_altsetting; i++) {
|
||||
const libusb_interface_descriptor* interface = &interfaceContainer->altsetting[i];
|
||||
for (u8 e = 0; e < interface->bNumEndpoints; e++) {
|
||||
const libusb_endpoint_descriptor* endpoint = &interface->endpoint[e];
|
||||
if (endpoint->bEndpointAddress & LIBUSB_ENDPOINT_IN)
|
||||
input_endpoint = endpoint->bEndpointAddress;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
adapter_thread_running = true;
|
||||
current_status = ADAPTER_DETECTED;
|
||||
|
||||
adapter_input_thread = std::thread(Read); // Read input
|
||||
}
|
||||
|
||||
void Shutdown() {
|
||||
StopScanThread();
|
||||
Reset();
|
||||
|
||||
current_status = NO_ADAPTER_DETECTED;
|
||||
}
|
||||
|
||||
static void Reset() {
|
||||
std::unique_lock<std::mutex> lock(initialization_mutex, std::defer_lock);
|
||||
if (!lock.try_lock())
|
||||
return;
|
||||
if (current_status != ADAPTER_DETECTED)
|
||||
return;
|
||||
|
||||
if (adapter_thread_running)
|
||||
adapter_input_thread.join();
|
||||
|
||||
for (int i = 0; i < 4; i++)
|
||||
adapter_controllers_status[i] = ControllerTypes::CONTROLLER_NONE;
|
||||
|
||||
current_status = NO_ADAPTER_DETECTED;
|
||||
|
||||
if (usb_adapter_handle) {
|
||||
libusb_release_interface(usb_adapter_handle, 0);
|
||||
libusb_close(usb_adapter_handle);
|
||||
usb_adapter_handle = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
bool DeviceConnected(int port) {
|
||||
return adapter_controllers_status[port] != ControllerTypes::CONTROLLER_NONE;
|
||||
}
|
||||
|
||||
void ResetDeviceType(int port) {
|
||||
adapter_controllers_status[port] = ControllerTypes::CONTROLLER_NONE;
|
||||
}
|
||||
|
||||
void BeginConfiguration() {
|
||||
configuring = true;
|
||||
}
|
||||
|
||||
void EndConfiguration() {
|
||||
configuring = false;
|
||||
}
|
||||
|
||||
} // end of namespace GCAdapter
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
#pragma once
|
||||
#include <algorithm>
|
||||
#include <libusb.h>
|
||||
#include <mutex>
|
||||
#include <functional>
|
||||
#include "common/common_types.h"
|
||||
|
||||
|
||||
enum {
|
||||
PAD_USE_ORIGIN = 0x0080,
|
||||
PAD_GET_ORIGIN = 0x2000,
|
||||
PAD_ERR_STATUS = 0x8000,
|
||||
};
|
||||
|
||||
enum PadButton {
|
||||
PAD_BUTTON_LEFT = 0x0001,
|
||||
PAD_BUTTON_RIGHT = 0x0002,
|
||||
PAD_BUTTON_DOWN = 0x0004,
|
||||
PAD_BUTTON_UP = 0x0008,
|
||||
PAD_TRIGGER_Z = 0x0010,
|
||||
PAD_TRIGGER_R = 0x0020,
|
||||
PAD_TRIGGER_L = 0x0040,
|
||||
PAD_BUTTON_A = 0x0100,
|
||||
PAD_BUTTON_B = 0x0200,
|
||||
PAD_BUTTON_X = 0x0400,
|
||||
PAD_BUTTON_Y = 0x0800,
|
||||
PAD_BUTTON_START = 0x1000,
|
||||
// Below is for compatibility with "AxisButton" type
|
||||
PAD_STICK = 0x2000,
|
||||
|
||||
};
|
||||
|
||||
enum PadAxes { STICK_X, STICK_Y, SUBSTICK_X, SUBSTICK_Y, TRIGGER_LEFT, TRIGGER_RIGHT };
|
||||
|
||||
struct GCPadStatus {
|
||||
u16 button; // Or-ed PAD_BUTTON_* and PAD_TRIGGER_* bits
|
||||
u8 stickX; // 0 <= stickX <= 255
|
||||
u8 stickY; // 0 <= stickY <= 255
|
||||
u8 substickX; // 0 <= substickX <= 255
|
||||
u8 substickY; // 0 <= substickY <= 255
|
||||
u8 triggerLeft; // 0 <= triggerLeft <= 255
|
||||
u8 triggerRight; // 0 <= triggerRight <= 255
|
||||
bool isConnected{true};
|
||||
|
||||
static const u8 MAIN_STICK_CENTER_X = 0x80;
|
||||
static const u8 MAIN_STICK_CENTER_Y = 0x80;
|
||||
static const u8 MAIN_STICK_RADIUS = 0x7f;
|
||||
static const u8 C_STICK_CENTER_X = 0x80;
|
||||
static const u8 C_STICK_CENTER_Y = 0x80;
|
||||
static const u8 C_STICK_RADIUS = 0x7f;
|
||||
|
||||
static const u8 TRIGGER_CENTER = 20;
|
||||
static const u8 THRESHOLD = 10;
|
||||
u8 port;
|
||||
u8 axis_which = 255;
|
||||
u8 axis_value = 255;
|
||||
};
|
||||
|
||||
struct GCState {
|
||||
std::unordered_map<int, bool> buttons;
|
||||
std::unordered_map<int, u16> axes;
|
||||
};
|
||||
|
||||
|
||||
namespace GCAdapter {
|
||||
enum ControllerTypes {
|
||||
CONTROLLER_NONE = 0,
|
||||
CONTROLLER_WIRED = 1,
|
||||
CONTROLLER_WIRELESS = 2
|
||||
};
|
||||
|
||||
enum {
|
||||
NO_ADAPTER_DETECTED = 0,
|
||||
ADAPTER_DETECTED = 1,
|
||||
};
|
||||
|
||||
// Current adapter status: detected/not detected/in error (holds the error code)
|
||||
static int current_status = NO_ADAPTER_DETECTED;
|
||||
|
||||
GCPadStatus CheckStatus(int port, u8 adapter_payload[37]);
|
||||
/// Initialize the GC Adapter capture and read sequence
|
||||
void Init();
|
||||
|
||||
/// Close the adapter read thread and release the adapter
|
||||
void Shutdown();
|
||||
|
||||
/// Begin scanning for the GC Adapter.
|
||||
void StartScanThread();
|
||||
|
||||
/// Stop scanning for the adapter
|
||||
void StopScanThread();
|
||||
|
||||
/// Returns true if there is a device connected to port
|
||||
bool DeviceConnected(int port);
|
||||
|
||||
/// Resets status of device connected to port
|
||||
void ResetDeviceType(int port);
|
||||
|
||||
/// Returns true if we successfully gain access to GC Adapter
|
||||
bool CheckDeviceAccess(libusb_device* device);
|
||||
|
||||
/// Captures GC Adapter endpoint address,
|
||||
void GetGCEndpoint(libusb_device* device);
|
||||
|
||||
/// For shutting down, clear all data, join all threads, release usb
|
||||
void Reset();
|
||||
|
||||
/// For use in initialization, querying devices to find the adapter
|
||||
void Setup();
|
||||
|
||||
/// Used for polling
|
||||
void BeginConfiguration();
|
||||
|
||||
void EndConfiguration();
|
||||
|
||||
} // end of namespace GCAdapter
|
||||
|
|
@ -0,0 +1,310 @@
|
|||
#include <atomic>
|
||||
#include <list>
|
||||
#include <mutex>
|
||||
#include <utility>
|
||||
#include "input_common/gcadapter/gc_poller.h"
|
||||
#include "input_common/gcadapter/gc_adapter.h"
|
||||
#include "common/threadsafe_queue.h"
|
||||
|
||||
// Using extern as to avoid multply defined symbols.
|
||||
extern Common::SPSCQueue<GCPadStatus> pad_queue[4];
|
||||
extern struct GCState state[4];
|
||||
|
||||
namespace InputCommon {
|
||||
|
||||
class GCButton final : public Input::ButtonDevice {
|
||||
public:
|
||||
explicit GCButton(int port_, int button_, int axis_)
|
||||
: port(port_), button(button_) {
|
||||
}
|
||||
|
||||
~GCButton() override;
|
||||
|
||||
bool GetStatus() const override {
|
||||
return state[port].buttons.at(button);
|
||||
}
|
||||
|
||||
private:
|
||||
const int port;
|
||||
const int button;
|
||||
};
|
||||
|
||||
class GCAxisButton final : public Input::ButtonDevice {
|
||||
public:
|
||||
explicit GCAxisButton(int port_, int axis_, float threshold_,
|
||||
bool trigger_if_greater_)
|
||||
: port(port_), axis(axis_), threshold(threshold_),
|
||||
trigger_if_greater(trigger_if_greater_) {
|
||||
}
|
||||
|
||||
|
||||
bool GetStatus() const override {
|
||||
const float axis_value = (state[port].axes.at(axis) - 128.0f) / 128.0f;
|
||||
if (trigger_if_greater) {
|
||||
return axis_value > 0.10f; //TODO(ameerj) : Fix threshold.
|
||||
}
|
||||
return axis_value < -0.10f;
|
||||
}
|
||||
|
||||
private:
|
||||
const int port;
|
||||
const int axis;
|
||||
float threshold;
|
||||
bool trigger_if_greater;
|
||||
};
|
||||
|
||||
GCButtonFactory::GCButtonFactory() {
|
||||
GCAdapter::Init();
|
||||
}
|
||||
|
||||
GCButton::~GCButton() {
|
||||
GCAdapter::Shutdown();
|
||||
}
|
||||
|
||||
std::unique_ptr<Input::ButtonDevice> GCButtonFactory::Create(const Common::ParamPackage& params) {
|
||||
int button_id = params.Get("button", 0);
|
||||
int port = params.Get("port", 0);
|
||||
// For Axis buttons, used by the binary sticks.
|
||||
if (params.Has("axis")) {
|
||||
const int axis = params.Get("axis", 0);
|
||||
const float threshold = params.Get("threshold", 0.5f);
|
||||
const std::string direction_name = params.Get("direction", "");
|
||||
bool trigger_if_greater;
|
||||
if (direction_name == "+") {
|
||||
trigger_if_greater = true;
|
||||
} else if (direction_name == "-") {
|
||||
trigger_if_greater = false;
|
||||
} else {
|
||||
trigger_if_greater = true;
|
||||
LOG_ERROR(Input, "Unknown direction {}", direction_name);
|
||||
}
|
||||
return std::make_unique<GCAxisButton>(port, axis, threshold, trigger_if_greater);
|
||||
}
|
||||
|
||||
std::unique_ptr<GCButton> button =
|
||||
std::make_unique<GCButton>(port, button_id, params.Get("axis", 0));
|
||||
return std::move(button);
|
||||
}
|
||||
|
||||
Common::ParamPackage GCButtonFactory::GetNextInput() {
|
||||
Common::ParamPackage params;
|
||||
GCPadStatus pad;
|
||||
for (int i = 0; i < 4; i++) {
|
||||
while (pad_queue[i].Pop(pad)) {
|
||||
// This while loop will break on the earliest detected button
|
||||
params.Set("engine", "gcpad");
|
||||
params.Set("port", i);
|
||||
// I was debating whether to keep these verbose for ease of reading
|
||||
// or to use a while loop shifting the bits to test and set the value.
|
||||
if (pad.button & PAD_BUTTON_A) {
|
||||
params.Set("button", PAD_BUTTON_A);
|
||||
break;
|
||||
}
|
||||
if (pad.button & PAD_BUTTON_B) {
|
||||
params.Set("button", PAD_BUTTON_B);
|
||||
break;
|
||||
}
|
||||
if (pad.button & PAD_BUTTON_X) {
|
||||
params.Set("button", PAD_BUTTON_X);
|
||||
break;
|
||||
}
|
||||
if (pad.button & PAD_BUTTON_Y) {
|
||||
params.Set("button", PAD_BUTTON_Y);
|
||||
break;
|
||||
}
|
||||
if (pad.button & PAD_BUTTON_DOWN) {
|
||||
params.Set("button", PAD_BUTTON_DOWN);
|
||||
break;
|
||||
}
|
||||
if (pad.button & PAD_BUTTON_LEFT) {
|
||||
params.Set("button", PAD_BUTTON_LEFT);
|
||||
break;
|
||||
}
|
||||
if (pad.button & PAD_BUTTON_RIGHT) {
|
||||
params.Set("button", PAD_BUTTON_RIGHT);
|
||||
break;
|
||||
}
|
||||
if (pad.button & PAD_BUTTON_UP) {
|
||||
params.Set("button", PAD_BUTTON_UP);
|
||||
break;
|
||||
}
|
||||
if (pad.button & PAD_TRIGGER_L) {
|
||||
params.Set("button", PAD_TRIGGER_L);
|
||||
break;
|
||||
}
|
||||
if (pad.button & PAD_TRIGGER_R) {
|
||||
params.Set("button", PAD_TRIGGER_R);
|
||||
break;
|
||||
}
|
||||
if (pad.button & PAD_TRIGGER_Z) {
|
||||
params.Set("button", PAD_TRIGGER_Z);
|
||||
break;
|
||||
}
|
||||
if (pad.button & PAD_BUTTON_START) {
|
||||
params.Set("button", PAD_BUTTON_START);
|
||||
break;
|
||||
}
|
||||
// For Axis button implementation
|
||||
if (pad.axis_which != 255) {
|
||||
params.Set("axis", pad.axis_which);
|
||||
params.Set("button", PAD_STICK);
|
||||
if (pad.axis_value > 128) {
|
||||
params.Set("direction", "+");
|
||||
params.Set("threshold", "0.5");
|
||||
} else {
|
||||
params.Set("direction", "-");
|
||||
params.Set("threshold", "-0.5");
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return params;
|
||||
}
|
||||
|
||||
void GCButtonFactory::BeginConfiguration() {
|
||||
polling = true;
|
||||
for (int i = 0; i < 4; i++)
|
||||
pad_queue[i].Clear();
|
||||
GCAdapter::BeginConfiguration();
|
||||
}
|
||||
|
||||
void GCButtonFactory::EndConfiguration() {
|
||||
polling = false;
|
||||
|
||||
for (int i = 0; i < 4; i++)
|
||||
pad_queue[i].Clear();
|
||||
GCAdapter::EndConfiguration();
|
||||
}
|
||||
|
||||
class GCAnalog final : public Input::AnalogDevice {
|
||||
public:
|
||||
GCAnalog(int port_, int axis_x_, int axis_y_, float deadzone_)
|
||||
: port(port_), axis_x(axis_x_), axis_y(axis_y_), deadzone(deadzone_) {
|
||||
}
|
||||
|
||||
float GetAxis(int axis) const {
|
||||
std::lock_guard lock{mutex};
|
||||
// division is not by a perfect 128 to account for some variance in center location
|
||||
// e.g. my device idled at 131 in X, 120 in Y, and full range of motion was in range [20-230]
|
||||
return (state[port].axes.at(axis) - 128.0f) / 95.0f;
|
||||
}
|
||||
|
||||
std::tuple<float, float> GetAnalog(int axis_x, int axis_y) const {
|
||||
float x = GetAxis(axis_x);
|
||||
float y = GetAxis(axis_y);
|
||||
|
||||
// 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);
|
||||
}
|
||||
|
||||
std::tuple<float, float> GetStatus() const override {
|
||||
const auto [x, y] = GetAnalog(axis_x, axis_y);
|
||||
const float r = std::sqrt((x * x) + (y * y));
|
||||
if (r > deadzone) {
|
||||
return std::make_tuple(x / r * (r - deadzone) / (1 - deadzone),
|
||||
y / r * (r - deadzone) / (1 - deadzone));
|
||||
}
|
||||
return std::make_tuple<float, float>(0.0f, 0.0f);
|
||||
}
|
||||
|
||||
bool GetAnalogDirectionStatus(Input::AnalogDirection direction) const override {
|
||||
const auto [x, y] = GetStatus();
|
||||
const float directional_deadzone = 0.4f;
|
||||
switch (direction) {
|
||||
case Input::AnalogDirection::RIGHT:
|
||||
return x > directional_deadzone;
|
||||
case Input::AnalogDirection::LEFT:
|
||||
return x < -directional_deadzone;
|
||||
case Input::AnalogDirection::UP:
|
||||
return y > directional_deadzone;
|
||||
case Input::AnalogDirection::DOWN:
|
||||
return y < -directional_deadzone;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private:
|
||||
const int port;
|
||||
const int axis_x;
|
||||
const int axis_y;
|
||||
const float deadzone;
|
||||
mutable std::mutex mutex;
|
||||
};
|
||||
|
||||
|
||||
/// An analog device factory that creates analog devices from GC Adapter
|
||||
GCAnalogFactory::GCAnalogFactory() {};
|
||||
|
||||
|
||||
/**
|
||||
* Creates analog device from joystick axes
|
||||
* @param params contains parameters for creating the device:
|
||||
* - "port": the nth gcpad on the adapter
|
||||
* - "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> GCAnalogFactory::Create(const Common::ParamPackage& params) {
|
||||
const std::string guid = params.Get("guid", "0");
|
||||
const int port = params.Get("port", 0);
|
||||
const int axis_x = params.Get("axis_x", 0);
|
||||
const int axis_y = params.Get("axis_y", 1);
|
||||
const float deadzone = std::clamp(params.Get("deadzone", 0.0f), 0.0f, .99f);
|
||||
|
||||
return std::make_unique<GCAnalog>(port, axis_x, axis_y, deadzone);
|
||||
}
|
||||
|
||||
void GCAnalogFactory::BeginConfiguration() {
|
||||
polling = true;
|
||||
for (int i = 0; i < 4; i++)
|
||||
pad_queue[i].Clear();
|
||||
GCAdapter::BeginConfiguration();
|
||||
}
|
||||
|
||||
void GCAnalogFactory::EndConfiguration() {
|
||||
polling = false;
|
||||
for (int i = 0; i < 4; i++)
|
||||
pad_queue[i].Clear();
|
||||
GCAdapter::EndConfiguration();
|
||||
}
|
||||
|
||||
Common::ParamPackage GCAnalogFactory::GetNextInput() {
|
||||
GCPadStatus pad;
|
||||
for (int i = 0; i < 4; i++) {
|
||||
while (pad_queue[i].Pop(pad)) {
|
||||
if (pad.axis_which == 255 || std::abs((pad.axis_value - 128.0f) / 128.0f) < 0.1) {
|
||||
continue;
|
||||
}
|
||||
// An analog device needs two axes, so we need to store the axis for later and wait for
|
||||
// a second SDL event. The axes also must be from the same joystick.
|
||||
const int axis = pad.axis_which;
|
||||
if (analog_x_axis == -1) {
|
||||
analog_x_axis = axis;
|
||||
controller_number = i;
|
||||
} else if (analog_y_axis == -1 && analog_x_axis != axis && controller_number == i) {
|
||||
analog_y_axis = axis;
|
||||
}
|
||||
}
|
||||
}
|
||||
Common::ParamPackage params;
|
||||
if (analog_x_axis != -1 && analog_y_axis != -1) {
|
||||
params.Set("engine", "gcpad");
|
||||
params.Set("port", controller_number);
|
||||
params.Set("axis_x", analog_x_axis);
|
||||
params.Set("axis_y", analog_y_axis);
|
||||
analog_x_axis = -1;
|
||||
analog_y_axis = -1;
|
||||
controller_number = -1;
|
||||
return params;
|
||||
}
|
||||
return params;
|
||||
}
|
||||
} // namespace InputCommon
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
#pragma once
|
||||
|
||||
#include <memory>
|
||||
#include "core/frontend/input.h"
|
||||
|
||||
namespace InputCommon {
|
||||
|
||||
|
||||
/**
|
||||
* A button device factory representing a gcpad. It receives gcpad events and forward them
|
||||
* to all button devices it created.
|
||||
*/
|
||||
class GCButtonFactory final : public Input::Factory<Input::ButtonDevice> {
|
||||
public:
|
||||
GCButtonFactory();
|
||||
|
||||
/**
|
||||
* Creates a button device from a button press
|
||||
* @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;
|
||||
|
||||
Common::ParamPackage GetNextInput();
|
||||
|
||||
/// For device input configuration/polling
|
||||
void BeginConfiguration();
|
||||
void EndConfiguration();
|
||||
|
||||
bool IsPolling() {
|
||||
return polling;
|
||||
}
|
||||
|
||||
private:
|
||||
bool polling = false;
|
||||
};
|
||||
|
||||
/// An analog device factory that creates analog devices from GC Adapter
|
||||
class GCAnalogFactory final : public Input::Factory<Input::AnalogDevice> {
|
||||
public:
|
||||
GCAnalogFactory();
|
||||
std::unique_ptr<Input::AnalogDevice> Create(const Common::ParamPackage& params) override;
|
||||
Common::ParamPackage GetNextInput();
|
||||
|
||||
/// For device input configuration/polling
|
||||
void BeginConfiguration();
|
||||
void EndConfiguration();
|
||||
|
||||
bool IsPolling() {
|
||||
return polling;
|
||||
}
|
||||
|
||||
private:
|
||||
int analog_x_axis = -1;
|
||||
int analog_y_axis = -1;
|
||||
int controller_number = -1;
|
||||
bool polling = false;
|
||||
};
|
||||
} // namespace InputCommon
|
||||
|
|
@ -13,7 +13,8 @@ namespace InputCommon {
|
|||
class KeyButton final : public Input::ButtonDevice {
|
||||
public:
|
||||
explicit KeyButton(std::shared_ptr<KeyButtonList> key_button_list_)
|
||||
: key_button_list(std::move(key_button_list_)) {}
|
||||
: key_button_list(std::move(key_button_list_)) {
|
||||
}
|
||||
|
||||
~KeyButton() override;
|
||||
|
||||
|
|
@ -49,8 +50,10 @@ public:
|
|||
void ChangeKeyStatus(int key_code, bool pressed) {
|
||||
std::lock_guard guard{mutex};
|
||||
for (const KeyButtonPair& pair : list) {
|
||||
if (pair.key_code == key_code)
|
||||
if (pair.key_code == key_code) {
|
||||
pair.key_button->status.store(pressed);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -66,7 +69,9 @@ private:
|
|||
std::list<KeyButtonPair> list;
|
||||
};
|
||||
|
||||
Keyboard::Keyboard() : key_button_list{std::make_shared<KeyButtonList>()} {}
|
||||
Keyboard::Keyboard()
|
||||
: key_button_list{std::make_shared<KeyButtonList>()} {
|
||||
}
|
||||
|
||||
KeyButton::~KeyButton() {
|
||||
key_button_list->RemoveKeyButton(this);
|
||||
|
|
@ -76,7 +81,7 @@ std::unique_ptr<Input::ButtonDevice> Keyboard::Create(const Common::ParamPackage
|
|||
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 button;
|
||||
return std::move(button);
|
||||
}
|
||||
|
||||
void Keyboard::PressKey(int key_code) {
|
||||
|
|
|
|||
|
|
@ -4,8 +4,11 @@
|
|||
|
||||
#include <memory>
|
||||
#include <thread>
|
||||
#include <libusb.h>
|
||||
#include <iostream>
|
||||
#include "common/param_package.h"
|
||||
#include "input_common/analog_from_button.h"
|
||||
#include "input_common/gcadapter/gc_poller.h"
|
||||
#include "input_common/keyboard.h"
|
||||
#include "input_common/main.h"
|
||||
#include "input_common/motion_emu.h"
|
||||
|
|
@ -22,8 +25,15 @@ static std::shared_ptr<MotionEmu> motion_emu;
|
|||
static std::unique_ptr<SDL::State> sdl;
|
||||
#endif
|
||||
static std::unique_ptr<CemuhookUDP::State> udp;
|
||||
static std::shared_ptr<GCButtonFactory> gcbuttons;
|
||||
static std::shared_ptr<GCAnalogFactory> gcanalog;
|
||||
|
||||
void Init() {
|
||||
gcbuttons = std::make_shared<GCButtonFactory>();
|
||||
Input::RegisterFactory<Input::ButtonDevice>("gcpad", gcbuttons);
|
||||
gcanalog = std::make_shared<GCAnalogFactory>();
|
||||
Input::RegisterFactory<Input::AnalogDevice>("gcpad", gcanalog);
|
||||
|
||||
keyboard = std::make_shared<Keyboard>();
|
||||
Input::RegisterFactory<Input::ButtonDevice>("keyboard", keyboard);
|
||||
Input::RegisterFactory<Input::AnalogDevice>("analog_from_button",
|
||||
|
|
@ -34,8 +44,10 @@ void Init() {
|
|||
#ifdef HAVE_SDL2
|
||||
sdl = SDL::Init();
|
||||
#endif
|
||||
/*
|
||||
|
||||
udp = CemuhookUDP::Init();
|
||||
*/
|
||||
}
|
||||
|
||||
void Shutdown() {
|
||||
|
|
@ -48,6 +60,8 @@ void Shutdown() {
|
|||
sdl.reset();
|
||||
#endif
|
||||
udp.reset();
|
||||
Input::UnregisterFactory<Input::ButtonDevice>("gcpad");
|
||||
gcbuttons.reset();
|
||||
}
|
||||
|
||||
Keyboard* GetKeyboard() {
|
||||
|
|
@ -58,6 +72,14 @@ MotionEmu* GetMotionEmu() {
|
|||
return motion_emu.get();
|
||||
}
|
||||
|
||||
GCButtonFactory* GetGCButtons() {
|
||||
return gcbuttons.get();
|
||||
}
|
||||
|
||||
GCAnalogFactory* GetGCAnalogs() {
|
||||
return gcanalog.get();
|
||||
}
|
||||
|
||||
std::string GenerateKeyboardParam(int key_code) {
|
||||
Common::ParamPackage param{
|
||||
{"engine", "keyboard"},
|
||||
|
|
@ -88,7 +110,6 @@ std::vector<std::unique_ptr<DevicePoller>> GetPollers(DeviceType type) {
|
|||
#ifdef HAVE_SDL2
|
||||
pollers = sdl->GetPollers(type);
|
||||
#endif
|
||||
|
||||
return pollers;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
#include <memory>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include "input_common/gcadapter/gc_poller.h"
|
||||
#include "input_common/gcadapter/gc_adapter.h"
|
||||
|
||||
namespace Common {
|
||||
class ParamPackage;
|
||||
|
|
@ -30,6 +32,13 @@ class MotionEmu;
|
|||
/// Gets the motion emulation factory.
|
||||
MotionEmu* GetMotionEmu();
|
||||
|
||||
class GCButtonFactory;
|
||||
class GCAnalogFactory;
|
||||
|
||||
GCButtonFactory* GetGCButtons();
|
||||
GCAnalogFactory* GetGCAnalogs();
|
||||
|
||||
|
||||
/// Generates a serialized param package for creating a keyboard button device
|
||||
std::string GenerateKeyboardParam(int key_code);
|
||||
|
||||
|
|
|
|||
|
|
@ -22,7 +22,8 @@ public:
|
|||
: update_millisecond(update_millisecond),
|
||||
update_duration(std::chrono::duration_cast<std::chrono::steady_clock::duration>(
|
||||
std::chrono::milliseconds(update_millisecond))),
|
||||
sensitivity(sensitivity), motion_emu_thread(&MotionEmuDevice::MotionEmuThread, this) {}
|
||||
sensitivity(sensitivity), motion_emu_thread(&MotionEmuDevice::MotionEmuThread, this) {
|
||||
}
|
||||
|
||||
~MotionEmuDevice() {
|
||||
if (motion_emu_thread.joinable()) {
|
||||
|
|
@ -145,7 +146,7 @@ std::unique_ptr<Input::MotionDevice> MotionEmu::Create(const Common::ParamPackag
|
|||
// Previously created device is disconnected here. Having two motion devices for 3DS is not
|
||||
// expected.
|
||||
current_device = device_wrapper->device;
|
||||
return device_wrapper;
|
||||
return std::move(device_wrapper);
|
||||
}
|
||||
|
||||
void MotionEmu::BeginTilt(int x, int y) {
|
||||
|
|
|
|||
|
|
@ -49,7 +49,8 @@ static int SDLEventWatcher(void* user_data, SDL_Event* event) {
|
|||
class SDLJoystick {
|
||||
public:
|
||||
SDLJoystick(std::string guid_, int port_, SDL_Joystick* joystick)
|
||||
: guid{std::move(guid_)}, port{port_}, sdl_joystick{joystick, &SDL_JoystickClose} {}
|
||||
: guid{std::move(guid_)}, port{port_}, sdl_joystick{joystick, &SDL_JoystickClose} {
|
||||
}
|
||||
|
||||
void SetButton(int button, bool value) {
|
||||
std::lock_guard lock{mutex};
|
||||
|
|
@ -97,6 +98,7 @@ public:
|
|||
std::lock_guard lock{mutex};
|
||||
return (state.hats.at(hat) & direction) != 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* The guid of the joystick
|
||||
*/
|
||||
|
|
@ -125,6 +127,7 @@ private:
|
|||
std::unordered_map<int, Sint16> axes;
|
||||
std::unordered_map<int, Uint8> hats;
|
||||
} state;
|
||||
|
||||
std::string guid;
|
||||
int port;
|
||||
std::unique_ptr<SDL_Joystick, decltype(&SDL_JoystickClose)> sdl_joystick;
|
||||
|
|
@ -155,7 +158,8 @@ std::shared_ptr<SDLJoystick> SDLState::GetSDLJoystickBySDLID(SDL_JoystickID sdl_
|
|||
if (map_it != joystick_map.end()) {
|
||||
const auto vec_it =
|
||||
std::find_if(map_it->second.begin(), map_it->second.end(),
|
||||
[&sdl_joystick](const std::shared_ptr<SDLJoystick>& joystick) {
|
||||
[&sdl_joystick](const std::shared_ptr<SDLJoystick>& joystick)
|
||||
{
|
||||
return sdl_joystick == joystick->GetSDLJoystick();
|
||||
});
|
||||
if (vec_it != map_it->second.end()) {
|
||||
|
|
@ -166,7 +170,8 @@ std::shared_ptr<SDLJoystick> SDLState::GetSDLJoystickBySDLID(SDL_JoystickID sdl_
|
|||
|
||||
// Search for a SDLJoystick without a mapped SDL_Joystick...
|
||||
const auto nullptr_it = std::find_if(map_it->second.begin(), map_it->second.end(),
|
||||
[](const std::shared_ptr<SDLJoystick>& joystick) {
|
||||
[](const std::shared_ptr<SDLJoystick>& joystick)
|
||||
{
|
||||
return !joystick->GetSDLJoystick();
|
||||
});
|
||||
if (nullptr_it != map_it->second.end()) {
|
||||
|
|
@ -223,7 +228,8 @@ void SDLState::CloseJoystick(SDL_Joystick* sdl_joystick) {
|
|||
const auto& joystick_guid_list = joystick_map[guid];
|
||||
const auto joystick_it =
|
||||
std::find_if(joystick_guid_list.begin(), joystick_guid_list.end(),
|
||||
[&sdl_joystick](const std::shared_ptr<SDLJoystick>& joystick) {
|
||||
[&sdl_joystick](const std::shared_ptr<SDLJoystick>& joystick)
|
||||
{
|
||||
return joystick->GetSDLJoystick() == sdl_joystick;
|
||||
});
|
||||
joystick = *joystick_it;
|
||||
|
|
@ -279,7 +285,8 @@ void SDLState::CloseJoysticks() {
|
|||
class SDLButton final : public Input::ButtonDevice {
|
||||
public:
|
||||
explicit SDLButton(std::shared_ptr<SDLJoystick> joystick_, int button_)
|
||||
: joystick(std::move(joystick_)), button(button_) {}
|
||||
: joystick(std::move(joystick_)), button(button_) {
|
||||
}
|
||||
|
||||
bool GetStatus() const override {
|
||||
return joystick->GetButton(button);
|
||||
|
|
@ -293,7 +300,8 @@ private:
|
|||
class SDLDirectionButton final : public Input::ButtonDevice {
|
||||
public:
|
||||
explicit SDLDirectionButton(std::shared_ptr<SDLJoystick> joystick_, int hat_, Uint8 direction_)
|
||||
: joystick(std::move(joystick_)), hat(hat_), direction(direction_) {}
|
||||
: joystick(std::move(joystick_)), hat(hat_), direction(direction_) {
|
||||
}
|
||||
|
||||
bool GetStatus() const override {
|
||||
return joystick->GetHatDirection(hat, direction);
|
||||
|
|
@ -310,7 +318,8 @@ public:
|
|||
explicit SDLAxisButton(std::shared_ptr<SDLJoystick> joystick_, int axis_, float threshold_,
|
||||
bool trigger_if_greater_)
|
||||
: joystick(std::move(joystick_)), axis(axis_), threshold(threshold_),
|
||||
trigger_if_greater(trigger_if_greater_) {}
|
||||
trigger_if_greater(trigger_if_greater_) {
|
||||
}
|
||||
|
||||
bool GetStatus() const override {
|
||||
const float axis_value = joystick->GetAxis(axis);
|
||||
|
|
@ -330,7 +339,8 @@ private:
|
|||
class SDLAnalog final : public Input::AnalogDevice {
|
||||
public:
|
||||
SDLAnalog(std::shared_ptr<SDLJoystick> joystick_, int axis_x_, int axis_y_, float deadzone_)
|
||||
: joystick(std::move(joystick_)), axis_x(axis_x_), axis_y(axis_y_), deadzone(deadzone_) {}
|
||||
: joystick(std::move(joystick_)), axis_x(axis_x_), axis_y(axis_y_), deadzone(deadzone_) {
|
||||
}
|
||||
|
||||
std::tuple<float, float> GetStatus() const override {
|
||||
const auto [x, y] = joystick->GetAnalog(axis_x, axis_y);
|
||||
|
|
@ -368,7 +378,9 @@ private:
|
|||
/// A button device factory that creates button devices from SDL joystick
|
||||
class SDLButtonFactory final : public Input::Factory<Input::ButtonDevice> {
|
||||
public:
|
||||
explicit SDLButtonFactory(SDLState& state_) : state(state_) {}
|
||||
explicit SDLButtonFactory(SDLState& state_)
|
||||
: state(state_) {
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a button device from a joystick button
|
||||
|
|
@ -443,7 +455,10 @@ private:
|
|||
/// An analog device factory that creates analog devices from SDL joystick
|
||||
class SDLAnalogFactory final : public Input::Factory<Input::AnalogDevice> {
|
||||
public:
|
||||
explicit SDLAnalogFactory(SDLState& state_) : state(state_) {}
|
||||
explicit SDLAnalogFactory(SDLState& state_)
|
||||
: state(state_) {
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates analog device from joystick axes
|
||||
* @param params contains parameters for creating the device:
|
||||
|
|
@ -490,7 +505,8 @@ SDLState::SDLState() {
|
|||
|
||||
initialized = true;
|
||||
if (start_thread) {
|
||||
poll_thread = std::thread([this] {
|
||||
poll_thread = std::thread([this]
|
||||
{
|
||||
using namespace std::chrono_literals;
|
||||
while (initialized) {
|
||||
SDL_PumpEvents();
|
||||
|
|
@ -576,7 +592,9 @@ namespace Polling {
|
|||
|
||||
class SDLPoller : public InputCommon::Polling::DevicePoller {
|
||||
public:
|
||||
explicit SDLPoller(SDLState& state_) : state(state_) {}
|
||||
explicit SDLPoller(SDLState& state_)
|
||||
: state(state_) {
|
||||
}
|
||||
|
||||
void Start() override {
|
||||
state.event_queue.Clear();
|
||||
|
|
@ -593,7 +611,9 @@ protected:
|
|||
|
||||
class SDLButtonPoller final : public SDLPoller {
|
||||
public:
|
||||
explicit SDLButtonPoller(SDLState& state_) : SDLPoller(state_) {}
|
||||
explicit SDLButtonPoller(SDLState& state_)
|
||||
: SDLPoller(state_) {
|
||||
}
|
||||
|
||||
Common::ParamPackage GetNextInput() override {
|
||||
SDL_Event event;
|
||||
|
|
@ -602,8 +622,7 @@ public:
|
|||
case SDL_JOYAXISMOTION:
|
||||
if (std::abs(event.jaxis.value / 32767.0) < 0.5) {
|
||||
break;
|
||||
}
|
||||
[[fallthrough]];
|
||||
}[[fallthrough]];
|
||||
case SDL_JOYBUTTONUP:
|
||||
case SDL_JOYHATMOTION:
|
||||
return SDLEventToButtonParamPackage(state, event);
|
||||
|
|
@ -615,7 +634,9 @@ public:
|
|||
|
||||
class SDLAnalogPoller final : public SDLPoller {
|
||||
public:
|
||||
explicit SDLAnalogPoller(SDLState& state_) : SDLPoller(state_) {}
|
||||
explicit SDLAnalogPoller(SDLState& state_)
|
||||
: SDLPoller(state_) {
|
||||
}
|
||||
|
||||
void Start() override {
|
||||
SDLPoller::Start();
|
||||
|
|
|
|||
|
|
@ -59,7 +59,8 @@ public:
|
|||
void StartReceive() {
|
||||
socket.async_receive_from(
|
||||
boost::asio::buffer(receive_buffer), receive_endpoint,
|
||||
[this](const boost::system::error_code& error, std::size_t bytes_transferred) {
|
||||
[this](const boost::system::error_code& error, std::size_t bytes_transferred)
|
||||
{
|
||||
HandleReceive(error, bytes_transferred);
|
||||
});
|
||||
}
|
||||
|
|
@ -211,9 +212,15 @@ void Client::StartCommunication(const std::string& host, u16 port, u8 pad_index,
|
|||
void TestCommunication(const std::string& host, u16 port, u8 pad_index, u32 client_id,
|
||||
std::function<void()> success_callback,
|
||||
std::function<void()> failure_callback) {
|
||||
std::thread([=] {
|
||||
std::thread([=]
|
||||
{
|
||||
Common::Event success_event;
|
||||
SocketCallback callback{[](Response::Version version) {}, [](Response::PortInfo info) {},
|
||||
SocketCallback callback{[](Response::Version version)
|
||||
{
|
||||
},
|
||||
[](Response::PortInfo info)
|
||||
{
|
||||
},
|
||||
[&](Response::PadData data) { success_event.Set(); }};
|
||||
Socket socket{host, port, pad_index, client_id, std::move(callback)};
|
||||
std::thread worker_thread{SocketLoop, &socket};
|
||||
|
|
@ -234,7 +241,8 @@ CalibrationConfigurationJob::CalibrationConfigurationJob(
|
|||
std::function<void(Status)> status_callback,
|
||||
std::function<void(u16, u16, u16, u16)> data_callback) {
|
||||
|
||||
std::thread([=] {
|
||||
std::thread([=]
|
||||
{
|
||||
constexpr u16 CALIBRATION_THRESHOLD = 100;
|
||||
|
||||
u16 min_x{UINT16_MAX};
|
||||
|
|
@ -243,8 +251,14 @@ CalibrationConfigurationJob::CalibrationConfigurationJob(
|
|||
u16 max_y{};
|
||||
|
||||
Status current_status{Status::Initialized};
|
||||
SocketCallback callback{[](Response::Version version) {}, [](Response::PortInfo info) {},
|
||||
[&](Response::PadData data) {
|
||||
SocketCallback callback{[](Response::Version version)
|
||||
{
|
||||
},
|
||||
[](Response::PortInfo info)
|
||||
{
|
||||
},
|
||||
[&](Response::PadData data)
|
||||
{
|
||||
if (current_status == Status::Initialized) {
|
||||
// Receiving data means the communication is ready now
|
||||
current_status = Status::Ready;
|
||||
|
|
|
|||
|
|
@ -40,6 +40,7 @@ struct DeviceStatus {
|
|||
u16 max_x{};
|
||||
u16 max_y{};
|
||||
};
|
||||
|
||||
std::optional<CalibrationData> touch_calibration;
|
||||
};
|
||||
|
||||
|
|
@ -72,6 +73,7 @@ public:
|
|||
Stage1Completed,
|
||||
Completed,
|
||||
};
|
||||
|
||||
/**
|
||||
* Constructs and starts the job with the specified parameter.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -35,6 +35,7 @@ struct Header {
|
|||
///> the data
|
||||
Type type{};
|
||||
};
|
||||
|
||||
static_assert(sizeof(Header) == 20, "UDP Message Header struct has wrong size");
|
||||
static_assert(std::is_trivially_copyable_v<Header>, "UDP Message Header is not trivially copyable");
|
||||
|
||||
|
|
@ -54,7 +55,9 @@ constexpr Type GetMessageType();
|
|||
|
||||
namespace Request {
|
||||
|
||||
struct Version {};
|
||||
struct Version {
|
||||
};
|
||||
|
||||
/**
|
||||
* Requests the server to send information about what controllers are plugged into the ports
|
||||
* In citra's case, we only have one controller, so for simplicity's sake, we can just send a
|
||||
|
|
@ -62,10 +65,12 @@ struct Version {};
|
|||
* nice to make this configurable
|
||||
*/
|
||||
constexpr u32 MAX_PORTS = 4;
|
||||
|
||||
struct PortInfo {
|
||||
u32_le pad_count{}; ///> Number of ports to request data for
|
||||
std::array<u8, MAX_PORTS> port;
|
||||
};
|
||||
|
||||
static_assert(std::is_trivially_copyable_v<PortInfo>,
|
||||
"UDP Request PortInfo is not trivially copyable");
|
||||
|
||||
|
|
@ -80,6 +85,7 @@ struct PadData {
|
|||
Id,
|
||||
Mac,
|
||||
};
|
||||
|
||||
/// Determines which method will be used as a look up for the controller
|
||||
Flags flags{};
|
||||
/// Index of the port of the controller to retrieve data about
|
||||
|
|
@ -87,6 +93,7 @@ struct PadData {
|
|||
/// Mac address of the controller to retrieve data about
|
||||
MacAddress mac;
|
||||
};
|
||||
|
||||
static_assert(sizeof(PadData) == 8, "UDP Request PadData struct has wrong size");
|
||||
static_assert(std::is_trivially_copyable_v<PadData>,
|
||||
"UDP Request PadData is not trivially copyable");
|
||||
|
|
@ -114,6 +121,7 @@ namespace Response {
|
|||
struct Version {
|
||||
u16_le version{};
|
||||
};
|
||||
|
||||
static_assert(sizeof(Version) == 2, "UDP Response Version struct has wrong size");
|
||||
static_assert(std::is_trivially_copyable_v<Version>,
|
||||
"UDP Response Version is not trivially copyable");
|
||||
|
|
@ -127,6 +135,7 @@ struct PortInfo {
|
|||
u8 battery{};
|
||||
u8 is_pad_active{};
|
||||
};
|
||||
|
||||
static_assert(sizeof(PortInfo) == 12, "UDP Response PortInfo struct has wrong size");
|
||||
static_assert(std::is_trivially_copyable_v<PortInfo>,
|
||||
"UDP Response PortInfo is not trivially copyable");
|
||||
|
|
@ -232,22 +241,27 @@ template <>
|
|||
constexpr Type GetMessageType<Request::Version>() {
|
||||
return Type::Version;
|
||||
}
|
||||
|
||||
template <>
|
||||
constexpr Type GetMessageType<Request::PortInfo>() {
|
||||
return Type::PortInfo;
|
||||
}
|
||||
|
||||
template <>
|
||||
constexpr Type GetMessageType<Request::PadData>() {
|
||||
return Type::PadData;
|
||||
}
|
||||
|
||||
template <>
|
||||
constexpr Type GetMessageType<Response::Version>() {
|
||||
return Type::Version;
|
||||
}
|
||||
|
||||
template <>
|
||||
constexpr Type GetMessageType<Response::PortInfo>() {
|
||||
return Type::PortInfo;
|
||||
}
|
||||
|
||||
template <>
|
||||
constexpr Type GetMessageType<Response::PadData>() {
|
||||
return Type::PadData;
|
||||
|
|
|
|||
|
|
@ -16,7 +16,10 @@ namespace InputCommon::CemuhookUDP {
|
|||
|
||||
class UDPTouchDevice final : public Input::TouchDevice {
|
||||
public:
|
||||
explicit UDPTouchDevice(std::shared_ptr<DeviceStatus> status_) : status(std::move(status_)) {}
|
||||
explicit UDPTouchDevice(std::shared_ptr<DeviceStatus> status_)
|
||||
: status(std::move(status_)) {
|
||||
}
|
||||
|
||||
std::tuple<float, float, bool> GetStatus() const override {
|
||||
std::lock_guard guard(status->update_mutex);
|
||||
return status->touch_status;
|
||||
|
|
@ -28,7 +31,10 @@ private:
|
|||
|
||||
class UDPMotionDevice final : public Input::MotionDevice {
|
||||
public:
|
||||
explicit UDPMotionDevice(std::shared_ptr<DeviceStatus> status_) : status(std::move(status_)) {}
|
||||
explicit UDPMotionDevice(std::shared_ptr<DeviceStatus> status_)
|
||||
: status(std::move(status_)) {
|
||||
}
|
||||
|
||||
std::tuple<Common::Vec3<float>, Common::Vec3<float>> GetStatus() const override {
|
||||
std::lock_guard guard(status->update_mutex);
|
||||
return status->motion_status;
|
||||
|
|
@ -40,7 +46,9 @@ private:
|
|||
|
||||
class UDPTouchFactory final : public Input::Factory<Input::TouchDevice> {
|
||||
public:
|
||||
explicit UDPTouchFactory(std::shared_ptr<DeviceStatus> status_) : status(std::move(status_)) {}
|
||||
explicit UDPTouchFactory(std::shared_ptr<DeviceStatus> status_)
|
||||
: status(std::move(status_)) {
|
||||
}
|
||||
|
||||
std::unique_ptr<Input::TouchDevice> Create(const Common::ParamPackage& params) override {
|
||||
{
|
||||
|
|
@ -61,7 +69,9 @@ private:
|
|||
|
||||
class UDPMotionFactory final : public Input::Factory<Input::MotionDevice> {
|
||||
public:
|
||||
explicit UDPMotionFactory(std::shared_ptr<DeviceStatus> status_) : status(std::move(status_)) {}
|
||||
explicit UDPMotionFactory(std::shared_ptr<DeviceStatus> status_)
|
||||
: status(std::move(status_)) {
|
||||
}
|
||||
|
||||
std::unique_ptr<Input::MotionDevice> Create(const Common::ParamPackage& params) override {
|
||||
return std::make_unique<UDPMotionDevice>(status);
|
||||
|
|
|
|||
|
|
@ -19,13 +19,13 @@
|
|||
#include "yuzu/configuration/configure_input_player.h"
|
||||
|
||||
const std::array<std::string, ConfigureInputPlayer::ANALOG_SUB_BUTTONS_NUM>
|
||||
ConfigureInputPlayer::analog_sub_buttons{{
|
||||
ConfigureInputPlayer::analog_sub_buttons{{
|
||||
"up",
|
||||
"down",
|
||||
"left",
|
||||
"right",
|
||||
"modifier",
|
||||
}};
|
||||
}};
|
||||
|
||||
static void LayerGridElements(QGridLayout* grid, QWidget* item, QWidget* onTopOf) {
|
||||
const int index1 = grid->indexOf(item);
|
||||
|
|
@ -70,6 +70,20 @@ static QString ButtonToText(const Common::ParamPackage& param) {
|
|||
return GetKeyName(param.Get("code", 0));
|
||||
}
|
||||
|
||||
if (param.Get("engine", "") == "gcpad") {
|
||||
if (param.Has("axis")) {
|
||||
const QString axis_str = QString::fromStdString(param.Get("axis", ""));
|
||||
const QString direction_str = QString::fromStdString(param.Get("direction", ""));
|
||||
|
||||
return QObject::tr("Axis %1%2").arg(axis_str, direction_str);
|
||||
}
|
||||
if (param.Has("button")) {
|
||||
const QString button_str = QString::number(int(std::log2(param.Get("button", 0))));
|
||||
return QObject::tr("Button %1").arg(button_str);
|
||||
}
|
||||
return GetKeyName(param.Get("code", 0));
|
||||
}
|
||||
|
||||
if (param.Get("engine", "") == "sdl") {
|
||||
if (param.Has("hat")) {
|
||||
const QString hat_str = QString::fromStdString(param.Get("hat", ""));
|
||||
|
|
@ -106,7 +120,7 @@ static QString AnalogToText(const Common::ParamPackage& param, const std::string
|
|||
return ButtonToText(Common::ParamPackage{param.Get(dir, "")});
|
||||
}
|
||||
|
||||
if (param.Get("engine", "") == "sdl") {
|
||||
if (param.Get("engine", "") == "sdl" || param.Get("engine", "") == "gcpad") {
|
||||
if (dir == "modifier") {
|
||||
return QObject::tr("[unused]");
|
||||
}
|
||||
|
|
@ -247,9 +261,11 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
|
|||
}
|
||||
|
||||
button->setContextMenuPolicy(Qt::CustomContextMenu);
|
||||
connect(button, &QPushButton::clicked, [=] {
|
||||
connect(button, &QPushButton::clicked, [=]
|
||||
{
|
||||
HandleClick(button_map[button_id],
|
||||
[=](Common::ParamPackage params) {
|
||||
[=](Common::ParamPackage params)
|
||||
{
|
||||
// Workaround for ZL & ZR for analog triggers like on XBOX controllors.
|
||||
// Analog triggers (from controllers like the XBOX controller) would not
|
||||
// work due to a different range of their signals (from 0 to 255 on
|
||||
|
|
@ -267,13 +283,16 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
|
|||
},
|
||||
InputCommon::Polling::DeviceType::Button);
|
||||
});
|
||||
connect(button, &QPushButton::customContextMenuRequested, [=](const QPoint& menu_location) {
|
||||
connect(button, &QPushButton::customContextMenuRequested, [=](const QPoint& menu_location)
|
||||
{
|
||||
QMenu context_menu;
|
||||
context_menu.addAction(tr("Clear"), [&] {
|
||||
context_menu.addAction(tr("Clear"), [&]
|
||||
{
|
||||
buttons_param[button_id].Clear();
|
||||
button_map[button_id]->setText(tr("[not set]"));
|
||||
});
|
||||
context_menu.addAction(tr("Restore Default"), [&] {
|
||||
context_menu.addAction(tr("Restore Default"), [&]
|
||||
{
|
||||
buttons_param[button_id] = Common::ParamPackage{
|
||||
InputCommon::GenerateKeyboardParam(Config::default_buttons[button_id])};
|
||||
button_map[button_id]->setText(ButtonToText(buttons_param[button_id]));
|
||||
|
|
@ -290,22 +309,27 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
|
|||
}
|
||||
|
||||
analog_button->setContextMenuPolicy(Qt::CustomContextMenu);
|
||||
connect(analog_button, &QPushButton::clicked, [=]() {
|
||||
connect(analog_button, &QPushButton::clicked, [=]()
|
||||
{
|
||||
HandleClick(analog_map_buttons[analog_id][sub_button_id],
|
||||
[=](const Common::ParamPackage& params) {
|
||||
[=](const Common::ParamPackage& params)
|
||||
{
|
||||
SetAnalogButton(params, analogs_param[analog_id],
|
||||
analog_sub_buttons[sub_button_id]);
|
||||
},
|
||||
InputCommon::Polling::DeviceType::Button);
|
||||
});
|
||||
connect(analog_button, &QPushButton::customContextMenuRequested,
|
||||
[=](const QPoint& menu_location) {
|
||||
[=](const QPoint& menu_location)
|
||||
{
|
||||
QMenu context_menu;
|
||||
context_menu.addAction(tr("Clear"), [&] {
|
||||
context_menu.addAction(tr("Clear"), [&]
|
||||
{
|
||||
analogs_param[analog_id].Erase(analog_sub_buttons[sub_button_id]);
|
||||
analog_map_buttons[analog_id][sub_button_id]->setText(tr("[not set]"));
|
||||
});
|
||||
context_menu.addAction(tr("Restore Default"), [&] {
|
||||
context_menu.addAction(tr("Restore Default"), [&]
|
||||
{
|
||||
Common::ParamPackage params{InputCommon::GenerateKeyboardParam(
|
||||
Config::default_analogs[analog_id][sub_button_id])};
|
||||
SetAnalogButton(params, analogs_param[analog_id],
|
||||
|
|
@ -317,7 +341,8 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
|
|||
menu_location));
|
||||
});
|
||||
}
|
||||
connect(analog_map_stick[analog_id], &QPushButton::clicked, [=] {
|
||||
connect(analog_map_stick[analog_id], &QPushButton::clicked, [=]
|
||||
{
|
||||
if (QMessageBox::information(
|
||||
this, tr("Information"),
|
||||
tr("After pressing OK, first move your joystick horizontally, "
|
||||
|
|
@ -330,9 +355,11 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
|
|||
}
|
||||
});
|
||||
|
||||
connect(analog_map_deadzone_and_modifier_slider[analog_id], &QSlider::valueChanged, [=] {
|
||||
connect(analog_map_deadzone_and_modifier_slider[analog_id], &QSlider::valueChanged, [=]
|
||||
{
|
||||
const float slider_value = analog_map_deadzone_and_modifier_slider[analog_id]->value();
|
||||
if (analogs_param[analog_id].Get("engine", "") == "sdl") {
|
||||
if (analogs_param[analog_id].Get("engine", "") == "sdl" ||
|
||||
analogs_param[analog_id].Get("engine", "") == "gcpad") {
|
||||
analog_map_deadzone_and_modifier_slider_label[analog_id]->setText(
|
||||
tr("Deadzone: %1%").arg(slider_value));
|
||||
analogs_param[analog_id].Set("deadzone", slider_value / 100.0f);
|
||||
|
|
@ -350,8 +377,23 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
|
|||
timeout_timer->setSingleShot(true);
|
||||
connect(timeout_timer.get(), &QTimer::timeout, [this] { SetPollingResult({}, true); });
|
||||
|
||||
connect(poll_timer.get(), &QTimer::timeout, [this] {
|
||||
connect(poll_timer.get(), &QTimer::timeout, [this]
|
||||
{
|
||||
Common::ParamPackage params;
|
||||
if (InputCommon::GetGCButtons()->IsPolling()) {
|
||||
params = InputCommon::GetGCButtons()->GetNextInput();
|
||||
if (params.Has("engine")) {
|
||||
SetPollingResult(params, false);
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (InputCommon::GetGCAnalogs()->IsPolling()) {
|
||||
params = InputCommon::GetGCAnalogs()->GetNextInput();
|
||||
if (params.Has("engine")) {
|
||||
SetPollingResult(params, false);
|
||||
return;
|
||||
}
|
||||
}
|
||||
for (auto& poller : device_pollers) {
|
||||
params = poller->GetNextInput();
|
||||
if (params.Has("engine")) {
|
||||
|
|
@ -534,7 +576,7 @@ void ConfigureInputPlayer::UpdateButtonLabels() {
|
|||
analog_map_deadzone_and_modifier_slider_label[analog_id];
|
||||
|
||||
if (param.Has("engine")) {
|
||||
if (param.Get("engine", "") == "sdl") {
|
||||
if (param.Get("engine", "") == "sdl" || param.Get("engine", "") == "gcpad") {
|
||||
if (!param.Has("deadzone")) {
|
||||
param.Set("deadzone", 0.1f);
|
||||
}
|
||||
|
|
@ -583,6 +625,10 @@ void ConfigureInputPlayer::HandleClick(
|
|||
|
||||
grabKeyboard();
|
||||
grabMouse();
|
||||
if (type == InputCommon::Polling::DeviceType::Button)
|
||||
InputCommon::GetGCButtons()->BeginConfiguration();
|
||||
else
|
||||
InputCommon::GetGCAnalogs()->BeginConfiguration();
|
||||
timeout_timer->start(5000); // Cancel after 5 seconds
|
||||
poll_timer->start(200); // Check for new inputs every 200ms
|
||||
}
|
||||
|
|
@ -596,6 +642,9 @@ void ConfigureInputPlayer::SetPollingResult(const Common::ParamPackage& params,
|
|||
poller->Stop();
|
||||
}
|
||||
|
||||
InputCommon::GetGCButtons()->EndConfiguration();
|
||||
InputCommon::GetGCAnalogs()->EndConfiguration();
|
||||
|
||||
if (!abort) {
|
||||
(*input_setter)(params);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ class ConfigureInputPlayer;
|
|||
}
|
||||
|
||||
class ConfigureInputPlayer : public QDialog {
|
||||
Q_OBJECT
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
explicit ConfigureInputPlayer(QWidget* parent, std::size_t player_index, bool debug = false);
|
||||
|
|
|
|||
Reference in New Issue