mirrors/suyu
0
0
Fork 0
mirror of https://git.suyu.dev/suyu/suyu.git synced 2024-11-25 22:57:22 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

GC Adapter Implementation

Browse source
This commit is contained in:
Ameer 2020-06-21 12:36:28 -04:00
parent f98bf1025f
commit 0248614add
18 changed files with 1156 additions and 158 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

42
src/core/hle/service/hid/controllers/npad.cpp
View file

@ -44,7 +44,7 @@ static Controller_NPad::NPadControllerType MapSettingsTypeToNPad(Settings::Contr
case Settings::ControllerType::RightJoycon:
return Controller_NPad::NPadControllerType::JoyRight;
default:
UNREACHABLE();
UNREACHABLE();
return Controller_NPad::NPadControllerType::JoyDual;
}
}
@ -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) {
@ -106,7 +109,7 @@ void Controller_NPad::InitNewlyAddedControler(std::size_t controller_idx) {
controller.device_type.raw = 0;
switch (controller_type) {
case NPadControllerType::None:
UNREACHABLE();
UNREACHABLE();
break;
case NPadControllerType::Handheld:
controller.joy_styles.handheld.Assign(1);
@ -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,27 +281,31 @@ 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(
analog_state[static_cast<std::size_t>(JoystickId::Joystick_Right)]
->GetAnalogDirectionStatus(Input::AnalogDirection::RIGHT));
->GetAnalogDirectionStatus(Input::AnalogDirection::RIGHT));
pad_state.r_stick_left.Assign(analog_state[static_cast<std::size_t>(JoystickId::Joystick_Right)]
->GetAnalogDirectionStatus(Input::AnalogDirection::LEFT));
->GetAnalogDirectionStatus(Input::AnalogDirection::LEFT));
pad_state.r_stick_up.Assign(analog_state[static_cast<std::size_t>(JoystickId::Joystick_Right)]
->GetAnalogDirectionStatus(Input::AnalogDirection::UP));
->GetAnalogDirectionStatus(Input::AnalogDirection::UP));
pad_state.r_stick_down.Assign(analog_state[static_cast<std::size_t>(JoystickId::Joystick_Right)]
->GetAnalogDirectionStatus(Input::AnalogDirection::DOWN));
->GetAnalogDirectionStatus(Input::AnalogDirection::DOWN));
pad_state.left_sl.Assign(button_state[SL - BUTTON_HID_BEGIN]->GetStatus());
pad_state.left_sr.Assign(button_state[SR - BUTTON_HID_BEGIN]->GetStatus());
@ -363,7 +372,7 @@ void Controller_NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8*
switch (controller_type) {
case NPadControllerType::None:
UNREACHABLE();
UNREACHABLE();
break;
case NPadControllerType::Handheld:
handheld_entry.connection_status.raw = 0;
@ -459,8 +468,9 @@ 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)
: NPadControllerType::Handheld;
i <= MAX_NPAD_ID
? MapSettingsTypeToNPad(Settings::values.players[i].type)
: NPadControllerType::Handheld;
if (!IsControllerSupported(requested_controller)) {
const auto is_handheld = requested_controller == NPadControllerType::Handheld;
if (is_handheld) {

6
src/input_common/CMakeLists.txt
View file

@ -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)

3
src/input_common/analog_from_button.cpp
View file

@ -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;

350
src/input_common/gcadapter/gc_adapter.cpp Normal file
View file

@ -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

116
src/input_common/gcadapter/gc_adapter.h Normal file
View file

@ -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

310
src/input_common/gcadapter/gc_poller.cpp Normal file
View file

@ -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

59
src/input_common/gcadapter/gc_poller.h Normal file
View file

@ -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
src/input_common/keyboard.cpp
View file

@ -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) {

23
src/input_common/main.cpp
View file

@ -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;
}

9
src/input_common/main.h
View file

@ -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);

5
src/input_common/motion_emu.cpp
View file

@ -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) {

53
src/input_common/sdl/sdl_impl.cpp
View file

@ -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();

134
src/input_common/udp/client.cpp
View file

@ -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,21 +212,27 @@ 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([=] {
Common::Event success_event;
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};
bool result = success_event.WaitFor(std::chrono::seconds(8));
socket.Stop();
worker_thread.join();
if (result) {
success_callback();
} else {
failure_callback();
}
})
std::thread([=]
{
Common::Event success_event;
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};
bool result = success_event.WaitFor(std::chrono::seconds(8));
socket.Stop();
worker_thread.join();
if (result) {
success_callback();
} else {
failure_callback();
}
})
.detach();
}
@ -234,53 +241,60 @@ CalibrationConfigurationJob::CalibrationConfigurationJob(
std::function<void(Status)> status_callback,
std::function<void(u16, u16, u16, u16)> data_callback) {
std::thread([=] {
constexpr u16 CALIBRATION_THRESHOLD = 100;
std::thread([=]
{
constexpr u16 CALIBRATION_THRESHOLD = 100;
u16 min_x{UINT16_MAX};
u16 min_y{UINT16_MAX};
u16 max_x{};
u16 max_y{};
u16 min_x{UINT16_MAX};
u16 min_y{UINT16_MAX};
u16 max_x{};
u16 max_y{};
Status current_status{Status::Initialized};
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;
status_callback(current_status);
}
if (!data.touch_1.is_active) {
return;
}
LOG_DEBUG(Input, "Current touch: {} {}", data.touch_1.x,
data.touch_1.y);
min_x = std::min(min_x, static_cast<u16>(data.touch_1.x));
min_y = std::min(min_y, static_cast<u16>(data.touch_1.y));
if (current_status == Status::Ready) {
// First touch - min data (min_x/min_y)
current_status = Status::Stage1Completed;
status_callback(current_status);
}
if (data.touch_1.x - min_x > CALIBRATION_THRESHOLD &&
data.touch_1.y - min_y > CALIBRATION_THRESHOLD) {
// Set the current position as max value and finishes
// configuration
max_x = data.touch_1.x;
max_y = data.touch_1.y;
current_status = Status::Completed;
data_callback(min_x, min_y, max_x, max_y);
status_callback(current_status);
Status current_status{Status::Initialized};
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;
status_callback(current_status);
}
if (!data.touch_1.is_active) {
return;
}
LOG_DEBUG(Input, "Current touch: {} {}", data.touch_1.x,
data.touch_1.y);
min_x = std::min(min_x, static_cast<u16>(data.touch_1.x));
min_y = std::min(min_y, static_cast<u16>(data.touch_1.y));
if (current_status == Status::Ready) {
// First touch - min data (min_x/min_y)
current_status = Status::Stage1Completed;
status_callback(current_status);
}
if (data.touch_1.x - min_x > CALIBRATION_THRESHOLD &&
data.touch_1.y - min_y > CALIBRATION_THRESHOLD) {
// Set the current position as max value and finishes
// configuration
max_x = data.touch_1.x;
max_y = data.touch_1.y;
current_status = Status::Completed;
data_callback(min_x, min_y, max_x, max_y);
status_callback(current_status);
complete_event.Set();
}
}};
Socket socket{host, port, pad_index, client_id, std::move(callback)};
std::thread worker_thread{SocketLoop, &socket};
complete_event.Wait();
socket.Stop();
worker_thread.join();
})
complete_event.Set();
}
}};
Socket socket{host, port, pad_index, client_id, std::move(callback)};
std::thread worker_thread{SocketLoop, &socket};
complete_event.Wait();
socket.Stop();
worker_thread.join();
})
.detach();
}

2
src/input_common/udp/client.h
View file

@ -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.
*

32
src/input_common/udp/protocol.h
View file

@ -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,12 +65,14 @@ 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");
"UDP Request PortInfo is not trivially copyable");
/**
* Request the latest pad information from the server. If the server hasn't received this message
@ -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,9 +93,10 @@ 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");
"UDP Request PadData is not trivially copyable");
/**
* Creates a message with the proper header data that can be sent to the server.
@ -114,9 +121,10 @@ 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");
"UDP Response Version is not trivially copyable");
struct PortInfo {
u8 id{};
@ -127,9 +135,10 @@ 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");
"UDP Response PortInfo is not trivially copyable");
#pragma pack(push, 1)
struct PadData {
@ -206,16 +215,16 @@ struct PadData {
static_assert(sizeof(PadData) == 80, "UDP Response PadData struct has wrong size ");
static_assert(std::is_trivially_copyable_v<PadData>,
"UDP Response PadData is not trivially copyable");
"UDP Response PadData is not trivially copyable");
static_assert(sizeof(Message<PadData>) == MAX_PACKET_SIZE,
"UDP MAX_PACKET_SIZE is no longer larger than Message<PadData>");
"UDP MAX_PACKET_SIZE is no longer larger than Message<PadData>");
static_assert(sizeof(PadData::AnalogButton) == 12,
"UDP Response AnalogButton struct has wrong size ");
"UDP Response AnalogButton struct has wrong size ");
static_assert(sizeof(PadData::TouchPad) == 6, "UDP Response TouchPad struct has wrong size ");
static_assert(sizeof(PadData::Accelerometer) == 12,
"UDP Response Accelerometer struct has wrong size ");
"UDP Response Accelerometer struct has wrong size ");
static_assert(sizeof(PadData::Gyroscope) == 12, "UDP Response Gyroscope struct has wrong size ");
/**
@ -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;

18
src/input_common/udp/udp.cpp
View file

@ -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);

131
src/yuzu/configuration/configure_input_player.cpp
View file

@ -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{{
"up",
"down",
"left",
"right",
"modifier",
}};
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]");
}
@ -137,13 +151,13 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
setFocusPolicy(Qt::ClickFocus);
button_map = {
ui->buttonA, ui->buttonB, ui->buttonX, ui->buttonY,
ui->buttonLStick, ui->buttonRStick, ui->buttonL, ui->buttonR,
ui->buttonZL, ui->buttonZR, ui->buttonPlus, ui->buttonMinus,
ui->buttonDpadLeft, ui->buttonDpadUp, ui->buttonDpadRight, ui->buttonDpadDown,
ui->buttonA, ui->buttonB, ui->buttonX, ui->buttonY,
ui->buttonLStick, ui->buttonRStick, ui->buttonL, ui->buttonR,
ui->buttonZL, ui->buttonZR, ui->buttonPlus, ui->buttonMinus,
ui->buttonDpadLeft, ui->buttonDpadUp, ui->buttonDpadRight, ui->buttonDpadDown,
ui->buttonLStickLeft, ui->buttonLStickUp, ui->buttonLStickRight, ui->buttonLStickDown,
ui->buttonRStickLeft, ui->buttonRStickUp, ui->buttonRStickRight, ui->buttonRStickDown,
ui->buttonSL, ui->buttonSR, ui->buttonHome, ui->buttonScreenshot,
ui->buttonSL, ui->buttonSR, ui->buttonHome, ui->buttonScreenshot,
};
analog_map_buttons = {{
@ -164,11 +178,11 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
}};
debug_hidden = {
ui->buttonSL, ui->labelSL,
ui->buttonSR, ui->labelSR,
ui->buttonLStick, ui->labelLStickPressed,
ui->buttonRStick, ui->labelRStickPressed,
ui->buttonHome, ui->labelHome,
ui->buttonSL, ui->labelSL,
ui->buttonSR, ui->labelSR,
ui->buttonLStick, ui->labelLStickPressed,
ui->buttonRStick, ui->labelRStickPressed,
ui->buttonHome, ui->labelHome,
ui->buttonScreenshot, ui->labelScreenshot,
};
@ -207,12 +221,12 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
case Settings::ControllerType::RightJoycon:
layout_hidden = {
ui->left_body_button, ui->left_buttons_button,
ui->left_body_label, ui->left_buttons_label,
ui->buttonL, ui->labelL,
ui->buttonZL, ui->labelZL,
ui->labelScreenshot, ui->buttonScreenshot,
ui->buttonMinus, ui->labelMinus,
ui->LStick, ui->Dpad,
ui->left_body_label, ui->left_buttons_label,
ui->buttonL, ui->labelL,
ui->buttonZL, ui->labelZL,
ui->labelScreenshot, ui->buttonScreenshot,
ui->buttonMinus, ui->labelMinus,
ui->LStick, ui->Dpad,
};
break;
}
@ -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,11 +341,12 @@ 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, "
"and then vertically."),
"and then vertically."),
QMessageBox::Ok | QMessageBox::Cancel) == QMessageBox::Ok) {
HandleClick(
analog_map_stick[analog_id],
@ -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")) {
@ -463,7 +505,7 @@ void ConfigureInputPlayer::LoadConfiguration() {
for (std::size_t i = 0; i < colors.size(); ++i) {
controller_color_buttons[i]->setStyleSheet(
QStringLiteral("QPushButton { background-color: %1 }")
.arg(controller_colors[i].name()));
.arg(controller_colors[i].name()));
}
}
@ -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);
}

8
src/yuzu/configuration/configure_input_player.h
View file

@ -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);
@ -92,15 +92,15 @@ private:
/// A group of five QPushButtons represent one analog input. The buttons each represent up,
/// down, left, right, and modifier, respectively.
std::array<std::array<QPushButton*, ANALOG_SUB_BUTTONS_NUM>, Settings::NativeAnalog::NumAnalogs>
analog_map_buttons;
analog_map_buttons;
/// Analog inputs are also represented each with a single button, used to configure with an
/// actual analog stick
std::array<QPushButton*, Settings::NativeAnalog::NumAnalogs> analog_map_stick;
std::array<QSlider*, Settings::NativeAnalog::NumAnalogs>
analog_map_deadzone_and_modifier_slider;
analog_map_deadzone_and_modifier_slider;
std::array<QLabel*, Settings::NativeAnalog::NumAnalogs>
analog_map_deadzone_and_modifier_slider_label;
analog_map_deadzone_and_modifier_slider_label;
static const std::array<std::string, ANALOG_SUB_BUTTONS_NUM> analog_sub_buttons;