diff --git a/rpcs3/Emu/CMakeLists.txt b/rpcs3/Emu/CMakeLists.txt index 30bc9fb783..62a91d1d34 100644 --- a/rpcs3/Emu/CMakeLists.txt +++ b/rpcs3/Emu/CMakeLists.txt @@ -418,6 +418,8 @@ target_sources(rpcs3_emu PRIVATE Io/usb_device.cpp Io/usb_vfs.cpp Io/usio.cpp + Io/LogitechG27.cpp + Io/LogitechG27Config.cpp ) # Np diff --git a/rpcs3/Emu/Cell/lv2/sys_usbd.cpp b/rpcs3/Emu/Cell/lv2/sys_usbd.cpp index c8b5b7d6cb..aee7c6c04b 100644 --- a/rpcs3/Emu/Cell/lv2/sys_usbd.cpp +++ b/rpcs3/Emu/Cell/lv2/sys_usbd.cpp @@ -38,6 +38,9 @@ #include "Emu/Io/usio.h" #include "Emu/Io/usio_config.h" #include "Emu/Io/midi_config_types.h" +#ifdef HAVE_SDL3 +#include "Emu/Io/LogitechG27.h" +#endif #include @@ -208,7 +211,11 @@ private: // GT5 Wheels&co + #ifdef HAVE_SDL3 + {0x046D, 0xC283, 0xC29B, "lgFF_c283_c29b", &usb_device_logitech_g27::get_num_emu_devices, &usb_device_logitech_g27::make_instance}, + #else {0x046D, 0xC283, 0xC29B, "lgFF_c283_c29b", nullptr, nullptr}, + #endif {0x044F, 0xB653, 0xB653, "Thrustmaster RGT FFB Pro", nullptr, nullptr}, {0x044F, 0xB65A, 0xB65A, "Thrustmaster F430", nullptr, nullptr}, {0x044F, 0xB65D, 0xB65D, "Thrustmaster FFB", nullptr, nullptr}, diff --git a/rpcs3/Emu/Io/LogitechG27.cpp b/rpcs3/Emu/Io/LogitechG27.cpp new file mode 100644 index 0000000000..7f050088fe --- /dev/null +++ b/rpcs3/Emu/Io/LogitechG27.cpp @@ -0,0 +1,1565 @@ +// Logitech G27 + +// ffb ref +// https://opensource.logitech.com/wiki/force_feedback/Logitech_Force_Feedback_Protocol_V1.6.pdf +// https://github.com/mathijsvandenberg/g29emu/files/14395098/Logitech_Force_Feedback_Protocol_V1.6.pdf + +// shifter input ref +// https://github.com/sonik-br/lgff_wheel_adapter/blob/d97f7823154818e1b3edff6d51498a122c302728/pico_lgff_wheel_adapter/reports.h#L265-L310 + + +#include "stdafx.h" + +#ifdef HAVE_SDL3 + +#include + +#include "LogitechG27.h" +#include "LogitechG27Config.h" +#include "Emu/Cell/lv2/sys_usbd.h" +#include "Emu/system_config.h" +#include "Input/pad_thread.h" +#include "Input/sdl_instance.h" + +LOG_CHANNEL(logitech_g27_log, "LOGIG27"); + +static int SDLCALL refresh_thread(void *arg) +{ + auto ctx = reinterpret_cast(arg); + + while(true) + { + ctx->thread_control_mutex.lock(); + if (ctx->stop_thread) + { + break; + } + ctx->thread_control_mutex.unlock(); + ctx->sdl_refresh(); + std::this_thread::sleep_for(std::chrono::seconds(5)); + } + ctx->thread_control_mutex.unlock(); + + return 0; +} + +usb_device_logitech_g27::usb_device_logitech_g27(u32 controller_index, const std::array& location) + : usb_device_emulated(location), m_controller_index(controller_index) +{ + device = UsbDescriptorNode(USB_DESCRIPTOR_DEVICE, UsbDeviceDescriptor{0x0200, 0, 0, 0, 16, 0x046d, 0xc29b, 0x1350, 1, 2, 0, 1}); + + // parse the raw response like with passthrough device + static const uint8_t raw_config[] = {0x9, 0x2, 0x29, 0x0, 0x1, 0x1, 0x4, 0x80, 0x31, 0x9, 0x4, 0x0, 0x0, 0x2, 0x3, 0x0, 0x0, 0x0, 0x9, 0x21, 0x11, 0x1, 0x21, 0x1, 0x22, 0x85, 0x0, 0x7, 0x5, 0x81, 0x3, 0x10, 0x0, 0x2, 0x7, 0x5, 0x1, 0x3, 0x10, 0x0, 0x2}; + auto &conf = device.add_node(UsbDescriptorNode(raw_config[0], raw_config[1], &raw_config[2])); + for (unsigned int index = raw_config[0];index < sizeof(raw_config);) + { + conf.add_node(UsbDescriptorNode(raw_config[index], raw_config[index + 1], &raw_config[index + 2])); + index += raw_config[index]; + } + + // Initialize effect slots + for (int i = 0;i < 4;i++) + { + effect_slots[i].state = G27_FFB_INACTIVE; + effect_slots[i].effect_id = -1; + } + + SDL_HapticDirection direction = { + .type = SDL_HAPTIC_POLAR, + .dir = {27000, 0} + }; + default_spring_effect.type = SDL_HAPTIC_SPRING; + default_spring_effect.condition.direction = direction; + default_spring_effect.condition.length = SDL_HAPTIC_INFINITY; + //for (int i = 0;i < 3;i++) + for (int i = 0;i < 1;i++) + { + default_spring_effect.condition.right_sat[i] = 0x7FFF; + default_spring_effect.condition.left_sat[i] = 0x7FFF; + default_spring_effect.condition.right_coeff[i] = 0x7FFF; + default_spring_effect.condition.left_coeff[i] = 0x7FFF; + } + + thread_control_mutex.lock(); + stop_thread = false; + thread_control_mutex.unlock(); + + g_cfg_logitech_g27.load(); + + bool sdl_init_state = sdl_instance::get_instance().initialize(); + + enabled = g_cfg_logitech_g27.enabled.get() && sdl_init_state; + + if (!enabled) + return; + + sprintf(thread_name, "LogiG27 %p", this); + thread = SDL_CreateThread(refresh_thread, thread_name, this); + if (thread == nullptr) + { + logitech_g27_log.error("Failed creating sdl housekeeping thread, %s", SDL_GetError()); + } +} + +bool usb_device_logitech_g27::open_device(){ + return enabled; +} + +static void clear_sdl_joysticks(std::map> &joysticks) +{ + for (auto joystick_type = joysticks.begin();joystick_type != joysticks.end();joystick_type++) + { + for (auto joystick = joystick_type->second.begin(); joystick != joystick_type->second.end();joystick++) + { + SDL_CloseJoystick(*joystick); + } + } + joysticks.clear(); +} + +usb_device_logitech_g27::~usb_device_logitech_g27() +{ + // stop the background thread + thread_control_mutex.lock(); + stop_thread = true; + thread_control_mutex.unlock(); + + // Close sdl handles + sdl_handles_mutex.lock(); + if (haptic_handle != nullptr) + { + SDL_CloseHaptic(haptic_handle); + } + clear_sdl_joysticks(joysticks); + sdl_handles_mutex.unlock(); + + // wait for the background thread to finish + if (thread != nullptr) + SDL_WaitThread(thread, nullptr); +} + +std::shared_ptr usb_device_logitech_g27::make_instance(u32 controller_index, const std::array& location) +{ + return std::make_shared(controller_index, location); +} + +u16 usb_device_logitech_g27::get_num_emu_devices() +{ + return 1; +} + +void usb_device_logitech_g27::control_transfer(u8 bmRequestType, u8 bRequest, u16 wValue, u16 wIndex, u16 wLength, u32 buf_size, u8* buf, UsbTransfer* transfer) +{ + transfer->fake = true; + transfer->expected_count = buf_size; + transfer->expected_result = HC_CC_NOERR; + transfer->expected_time = get_timestamp() + 100; + + // Log these for now, might not need to implement anything + usb_device_emulated::control_transfer(bmRequestType, bRequest, wValue, wIndex, wLength, buf_size, buf, transfer); +} + +static bool sdl_joysticks_equal(std::map> &left, std::map> &right) +{ + if (left.size() != right.size()) + { + return false; + } + for (auto left_joysticks_of_type = left.begin();left_joysticks_of_type != left.end();left_joysticks_of_type++) + { + auto right_joysticks_of_type = right.find(left_joysticks_of_type->first); + if (right_joysticks_of_type == right.end()) + { + return false; + } + if (left_joysticks_of_type->second.size() != right_joysticks_of_type->second.size()) + { + return false; + } + for (auto left_joystick = left_joysticks_of_type->second.begin();left_joystick != left_joysticks_of_type->second.end(); left_joystick++) + { + bool found = false; + for (auto right_joystick = right_joysticks_of_type->second.begin();right_joystick != right_joysticks_of_type->second.end();right_joystick++) + { + if (*left_joystick == *right_joystick) + { + found = true; + break; + } + } + if (!found) + { + return false; + } + } + } + return true; +} + +static inline logitech_g27_sdl_mapping get_runtime_mapping() +{ + logitech_g27_sdl_mapping mapping; + + #define CONVERT_MAPPING(name) \ + { \ + mapping.name.device_type_id = g_cfg_logitech_g27.name##_device_type_id.get(); \ + mapping.name.type = static_cast(g_cfg_logitech_g27.name##_type.get()); \ + mapping.name.id = static_cast(g_cfg_logitech_g27.name##_id.get()); \ + mapping.name.hat = static_cast(g_cfg_logitech_g27.name##_hat.get()); \ + mapping.name.reverse = g_cfg_logitech_g27.name##_reverse.get(); \ + mapping.name.positive_axis = false; \ + } + + CONVERT_MAPPING(steering); + CONVERT_MAPPING(throttle); + CONVERT_MAPPING(brake); + CONVERT_MAPPING(clutch); + CONVERT_MAPPING(shift_up); + CONVERT_MAPPING(shift_down); + + CONVERT_MAPPING(up); + CONVERT_MAPPING(down); + CONVERT_MAPPING(left); + CONVERT_MAPPING(right); + + CONVERT_MAPPING(triangle); + CONVERT_MAPPING(cross); + CONVERT_MAPPING(square); + CONVERT_MAPPING(circle); + + CONVERT_MAPPING(l2); + CONVERT_MAPPING(l3); + CONVERT_MAPPING(r2); + CONVERT_MAPPING(r3); + + CONVERT_MAPPING(plus); + CONVERT_MAPPING(minus); + + CONVERT_MAPPING(dial_clockwise); + CONVERT_MAPPING(dial_anticlockwise); + + CONVERT_MAPPING(select); + CONVERT_MAPPING(pause); + + CONVERT_MAPPING(shifter_1); + CONVERT_MAPPING(shifter_2); + CONVERT_MAPPING(shifter_3); + CONVERT_MAPPING(shifter_4); + CONVERT_MAPPING(shifter_5); + CONVERT_MAPPING(shifter_6); + CONVERT_MAPPING(shifter_r); + + #undef CONVERT_MAPPING + + return mapping; +} + +void usb_device_logitech_g27::sdl_refresh() +{ + g_cfg_logitech_g27.m_mutex.lock(); + mapping = get_runtime_mapping(); + + reverse_effects = g_cfg_logitech_g27.reverse_effects.get(); + + uint32_t ffb_vendor_id = g_cfg_logitech_g27.ffb_device_type_id.get() >> 16; + uint32_t ffb_product_id = g_cfg_logitech_g27.ffb_device_type_id.get() & 0xFFFF; + + uint32_t led_vendor_id = g_cfg_logitech_g27.led_device_type_id.get() >> 16; + uint32_t led_product_id = g_cfg_logitech_g27.led_device_type_id.get() & 0xFFFF; + g_cfg_logitech_g27.m_mutex.unlock(); + + + SDL_Joystick *new_led_joystick_handle = nullptr; + SDL_Haptic *new_haptic_handle = nullptr; + std::map> new_joysticks; + + int joystick_count; + SDL_JoystickID *joystick_ids = SDL_GetJoysticks(&joystick_count); + if (joystick_ids != nullptr) + { + for (int i = 0;i < joystick_count;i++) + { + SDL_Joystick *cur_joystick = SDL_OpenJoystick(joystick_ids[i]); + if (cur_joystick == nullptr) + { + logitech_g27_log.error("Failed opening joystick %d, %s", joystick_ids[i], SDL_GetError()); + continue; + } + uint16_t cur_vendor_id = SDL_GetJoystickVendor(cur_joystick); + uint16_t cur_product_id = SDL_GetJoystickProduct(cur_joystick); + uint32_t joystick_type_id = (cur_vendor_id << 16) | cur_product_id; + auto joysticks_of_type = new_joysticks.find(joystick_type_id); + if (joysticks_of_type == new_joysticks.end()) + { + std::vector joystick_group = {cur_joystick}; + new_joysticks[joystick_type_id] = joystick_group; + } + else + { + joysticks_of_type->second.push_back(cur_joystick); + } + + if (cur_vendor_id == ffb_vendor_id && cur_product_id == ffb_product_id && new_haptic_handle == nullptr) + { + SDL_Haptic *cur_haptic = SDL_OpenHapticFromJoystick(cur_joystick); + if (cur_haptic == nullptr) + { + logitech_g27_log.error("Failed opening haptic device from selected ffb device %04x:%04x", cur_vendor_id, cur_product_id); + } + else + { + new_haptic_handle = cur_haptic; + } + } + + if (cur_vendor_id == led_vendor_id && cur_product_id == led_product_id && new_led_joystick_handle == nullptr) + { + new_led_joystick_handle = cur_joystick; + } + } + SDL_free(joystick_ids); + } + else + { + logitech_g27_log.error("Failed fetching joystick list, %s", SDL_GetError()); + } + + bool joysticks_changed = !sdl_joysticks_equal(joysticks, new_joysticks); + bool haptic_changed = haptic_handle != new_haptic_handle; + bool led_joystick_changed = led_joystick_handle != new_led_joystick_handle; + + // if we should touch the mutex + if (joysticks_changed || haptic_changed || led_joystick_changed) + { + sdl_handles_mutex.lock(); + if (joysticks_changed) + { + clear_sdl_joysticks(joysticks); + joysticks = new_joysticks; + } + // reset effects if the ffb device is changed + if (haptic_changed) + { + SDL_CloseHaptic(haptic_handle); + for (int i = 0;i < 4;i++) + { + effect_slots[i].effect_id = -1; + } + default_spring_effect_id = -1; + led_joystick_handle = new_led_joystick_handle; + haptic_handle = new_haptic_handle; + } + if (led_joystick_changed) + { + led_joystick_handle = new_led_joystick_handle; + } + sdl_handles_mutex.unlock(); + } + + if (!joysticks_changed) + { + clear_sdl_joysticks(new_joysticks); + } + + if (!haptic_changed) + { + SDL_CloseHaptic(new_haptic_handle); + } +} + +static inline int16_t logitech_g27_force_to_level(uint8_t force) +{ + if (force == 127 || force == 128) + { + return 0; + } + if (force > 128) + { + return ((force - 128) * 0x7FFF) / (255 - 128); + } + return ((127 - force) * 0x7FFF * -1) / (127 - 0); +} + +static inline int16_t logitech_g27_position_to_center(uint8_t left, uint8_t right) +{ + uint16_t center_unsigned = (((right + left) * 0xFFFF) / 255) / 2; + return center_unsigned - 0x8000; +} + +static inline int16_t logitech_g27_high_resolution_position_to_center(uint16_t left, uint16_t right) +{ + uint16_t center_unsigned = (((right + left) * 0xFFFF) / (0xFFFF >> 5)) / 2; + return center_unsigned - 0x8000; +} + +static inline uint16_t logitech_g27_position_to_width(uint8_t left, uint8_t right) +{ + return ((right - left) * 0xFFFF) / 255; +} + +static inline uint16_t logitech_g27_high_resolution_position_to_width(uint16_t left, uint16_t right) +{ + return ((right - left) * 0xFFFF) / (0xFFFF >> 5); +} + +static inline int16_t logitech_g27_coeff_to_coeff(uint8_t coeff, uint8_t invert) +{ + if (!invert) + { + return (coeff * 0x7FFF) / 7; + } + return (coeff * 0x7FFF * -1) / 7; +} + +static inline int16_t logitech_g27_high_resolution_coeff_to_coeff(uint8_t coeff, uint8_t invert) +{ + if (!invert) + { + return (coeff * 0x7FFF) / 15; + } + return (coeff * 0x7FFF * -1) / 15; +} + +static inline int16_t logitech_g27_friction_coeff_to_coeff(uint8_t coeff, uint8_t invert) +{ + if (!invert) + { + return (coeff * 0x7FFF) / 255; + } + return (coeff * 0x7FFF * -1) / 255; +} + +static inline int16_t logitech_g27_clip_to_saturation(uint8_t clip) +{ + return (clip * 0x7FFF) / 255; +} + +static inline int16_t logitech_g27_amplitude_to_magnitude(uint8_t amplitude) +{ + return ((amplitude * 0x7FFF) / 2) / 255; +} + +static inline uint16_t logitech_g27_loops_to_ms(uint16_t loops, bool afap) +{ + if (afap) + { + return loops; + } + return loops * 2; +} + +static inline uint16_t axis_to_logitech_g27_steering(int16_t axis) +{ + uint16_t unsigned_axis = axis + 0x8000; + return (unsigned_axis * (0xFFFF >> 2)) / 0xFFFF; +} + +static inline uint8_t axis_to_logitech_g27_pedal(int16_t axis) +{ + uint16_t unsigned_axis = axis + 0x8000; + return (unsigned_axis * (0xFF)) / 0xFFFF; +} + +extern bool is_input_allowed(); + +static uint8_t sdl_hat_to_logitech_g27_hat(uint8_t sdl_hat) +{ + switch(sdl_hat) + { + case SDL_HAT_CENTERED: + return 8; + case SDL_HAT_UP: + return 0; + case SDL_HAT_RIGHTUP: + return 1; + case SDL_HAT_RIGHT: + return 2; + case SDL_HAT_RIGHTDOWN: + return 3; + case SDL_HAT_DOWN: + return 4; + case SDL_HAT_LEFTDOWN: + return 5; + case SDL_HAT_LEFT: + return 6; + case SDL_HAT_LEFTUP: + return 7; + } + return 0; +} + +static uint8_t hat_components_to_logitech_g27_hat(bool up, bool down, bool left, bool right) +{ + uint8_t sdl_hat = 0; + if (up) + sdl_hat = sdl_hat | SDL_HAT_UP; + if (down) + sdl_hat = sdl_hat | SDL_HAT_DOWN; + if (left) + sdl_hat = sdl_hat | SDL_HAT_LEFT; + if (right) + sdl_hat = sdl_hat | SDL_HAT_RIGHT; + return sdl_hat_to_logitech_g27_hat(sdl_hat); +} + +static bool fetch_sdl_as_button(SDL_Joystick *joystick, const sdl_mapping &mapping) +{ + switch(mapping.type) + { + case MAPPING_BUTTON: + { + bool pressed = SDL_GetJoystickButton(joystick, mapping.id); + return mapping.reverse ? !pressed : pressed; + } + case MAPPING_HAT: + { + uint8_t hat_value = SDL_GetJoystickHat(joystick, mapping.id); + bool pressed = false; + switch (mapping.hat) + { + case HAT_UP: + pressed = (hat_value & SDL_HAT_UP) ? true : false; + break; + case HAT_DOWN: + pressed = (hat_value & SDL_HAT_DOWN) ? true : false; + break; + case HAT_LEFT: + pressed = (hat_value & SDL_HAT_LEFT) ? true : false; + break; + case HAT_RIGHT: + pressed = (hat_value & SDL_HAT_RIGHT) ? true : false; + break; + case HAT_NONE: + break; + } + return mapping.reverse ? !pressed : pressed; + } + case MAPPING_AXIS: + { + int32_t axis_value = SDL_GetJoystickAxis(joystick, mapping.id); + bool pressed = false; + if (mapping.positive_axis) + { + pressed = axis_value > (0x7FFF / 2); + } + else + { + pressed = axis_value < (0x7FFF / (-2)); + } + return mapping.reverse ? !pressed : pressed; + } + } + return false; +} + +static int16_t fetch_sdl_as_axis(SDL_Joystick *joystick, const sdl_mapping &mapping) +{ + const static int16_t MAX = 0x7FFF; + const static int16_t MIN = -0x8000; + const static int16_t MID = 0; + + switch(mapping.type) + { + case MAPPING_BUTTON: + { + bool pressed = SDL_GetJoystickButton(joystick, mapping.id); + if (mapping.reverse) + { + pressed = !pressed; + } + int16_t pressed_value = mapping.positive_axis ? MAX : MIN; + return pressed ? pressed_value : MID; + } + case MAPPING_HAT: + { + uint8_t hat_value = SDL_GetJoystickHat(joystick, mapping.id); + bool pressed = false; + switch (mapping.hat) + { + case HAT_UP: + pressed = (hat_value & SDL_HAT_UP) ? true : false; + break; + case HAT_DOWN: + pressed = (hat_value & SDL_HAT_DOWN) ? true : false; + break; + case HAT_LEFT: + pressed = (hat_value & SDL_HAT_LEFT) ? true : false; + break; + case HAT_RIGHT: + pressed = (hat_value & SDL_HAT_RIGHT) ? true : false; + break; + case HAT_NONE: + break; + } + if (mapping.reverse) + { + pressed = !pressed; + } + int16_t pressed_value = mapping.positive_axis ? MAX : MIN; + return pressed ? pressed_value : MID; + } + case MAPPING_AXIS: + { + int32_t axis_value = SDL_GetJoystickAxis(joystick, mapping.id); + if (mapping.reverse) + axis_value = axis_value * (-1); + if (axis_value > MAX) + axis_value = MAX; + if (axis_value < MIN) + axis_value = MIN; + if (axis_value == (MIN + 1)) + axis_value = MIN; + return axis_value; + } + } + return 0; +} + +static int16_t fetch_sdl_axis_avg(std::map> &joysticks, const sdl_mapping &mapping) +{ + const static int16_t MAX = 0x7FFF; + const static int16_t MIN = -0x8000; + + auto joysticks_of_type = joysticks.find(mapping.device_type_id); + if (joysticks_of_type == joysticks.end()) + { + return mapping.reverse ? MAX : MIN; + } + + if (joysticks_of_type->second.size() == 0) + { + return mapping.reverse ? MAX : MIN; + } + + // TODO account for deadzone and only pick up active devices + int32_t sdl_joysticks_total_value = 0; + for (auto joystick = joysticks_of_type->second.begin();joystick != joysticks_of_type->second.end();joystick++) + { + sdl_joysticks_total_value += fetch_sdl_as_axis(*joystick, mapping); + } + + return sdl_joysticks_total_value / joysticks_of_type->second.size(); +} + +static bool sdl_to_logitech_g27_button(std::map> &joysticks, const sdl_mapping &mapping) +{ + auto joysticks_of_type = joysticks.find(mapping.device_type_id); + if (joysticks_of_type == joysticks.end()) + { + return mapping.reverse; + } + + if (joysticks_of_type->second.size() == 0) + { + return mapping.reverse; + } + + bool pressed = false; + for (auto joystick = joysticks_of_type->second.begin();joystick != joysticks_of_type->second.end();joystick++) + { + pressed = pressed || fetch_sdl_as_button(*joystick, mapping); + } + return pressed; +} + +static uint16_t sdl_to_logitech_g27_steering(std::map> &joysticks, const sdl_mapping &mapping) +{ + int16_t avg = fetch_sdl_axis_avg(joysticks, mapping); + uint16_t unsigned_avg = avg + 0x8000; + return unsigned_avg * (0xFFFF >> 2) / 0xFFFF; +} + +static uint8_t sdl_to_logitech_g27_pedal(std::map> &joysticks, const sdl_mapping &mapping) +{ + int16_t avg = fetch_sdl_axis_avg(joysticks, mapping); + uint16_t unsigned_avg = avg + 0x8000; + return unsigned_avg * 0xFF / 0xFFFF; +} + +static inline void set_bit(uint8_t *buf, int bit_num, bool set) +{ + int byte_num = bit_num / 8; + bit_num = bit_num % 8; + uint8_t mask = 1 << bit_num; + if (set) + buf[byte_num] = buf[byte_num] | mask; + else + buf[byte_num] = buf[byte_num] & (~mask); +} + +void usb_device_logitech_g27::interrupt_transfer(u32 buf_size, u8* buf, u32 endpoint, UsbTransfer* transfer) +{ + transfer->fake = true; + transfer->expected_result = HC_CC_NOERR; + // G29 in G27 mode polls at 500 hz, let's try a delay of 1ms for now, for wheels that updates that fast + transfer->expected_time = get_timestamp() + 1000; + + if (endpoint & (1 << 7)) + { + if (buf_size < 11) + { + logitech_g27_log.error("Not populating input buffer with a buffer of the size of %u", buf_size); + return; + } + ensure(buf_size >= 11); + memset(buf, 0, buf_size); + + transfer->expected_count = 11; + + sdl_instance::get_instance().pump_events(); + + // Fetch input states from SDL + sdl_handles_mutex.lock(); + uint16_t steering = sdl_to_logitech_g27_steering(joysticks, mapping.steering); + uint8_t throttle = sdl_to_logitech_g27_pedal(joysticks, mapping.throttle); + uint8_t brake = sdl_to_logitech_g27_pedal(joysticks, mapping.brake); + uint8_t clutch = sdl_to_logitech_g27_pedal(joysticks, mapping.clutch); + bool shift_up = sdl_to_logitech_g27_button(joysticks, mapping.shift_up); + bool shift_down = sdl_to_logitech_g27_button(joysticks, mapping.shift_down); + + bool up = sdl_to_logitech_g27_button(joysticks, mapping.up); + bool down = sdl_to_logitech_g27_button(joysticks, mapping.down); + bool left = sdl_to_logitech_g27_button(joysticks, mapping.left); + bool right = sdl_to_logitech_g27_button(joysticks, mapping.right); + + bool triangle = sdl_to_logitech_g27_button(joysticks, mapping.triangle); + bool cross = sdl_to_logitech_g27_button(joysticks, mapping.cross); + bool square = sdl_to_logitech_g27_button(joysticks, mapping.square); + bool circle = sdl_to_logitech_g27_button(joysticks, mapping.circle); + + bool l2 = sdl_to_logitech_g27_button(joysticks, mapping.l2); + bool l3 = sdl_to_logitech_g27_button(joysticks, mapping.l3); + bool r2 = sdl_to_logitech_g27_button(joysticks, mapping.r2); + bool r3 = sdl_to_logitech_g27_button(joysticks, mapping.r3); + + bool plus = sdl_to_logitech_g27_button(joysticks, mapping.plus); + bool minus = sdl_to_logitech_g27_button(joysticks, mapping.minus); + + bool dial_clockwise = sdl_to_logitech_g27_button(joysticks, mapping.dial_clockwise); + bool dial_anticlockwise = sdl_to_logitech_g27_button(joysticks, mapping.dial_anticlockwise); + + bool select = sdl_to_logitech_g27_button(joysticks, mapping.select); + bool pause = sdl_to_logitech_g27_button(joysticks, mapping.pause); + + bool shifter_1 = sdl_to_logitech_g27_button(joysticks, mapping.shifter_1); + bool shifter_2 = sdl_to_logitech_g27_button(joysticks, mapping.shifter_2); + bool shifter_3 = sdl_to_logitech_g27_button(joysticks, mapping.shifter_3); + bool shifter_4 = sdl_to_logitech_g27_button(joysticks, mapping.shifter_4); + bool shifter_5 = sdl_to_logitech_g27_button(joysticks, mapping.shifter_5); + bool shifter_6 = sdl_to_logitech_g27_button(joysticks, mapping.shifter_6); + bool shifter_r = sdl_to_logitech_g27_button(joysticks, mapping.shifter_r); + sdl_handles_mutex.unlock(); + + // populate buffer + buf[0] = hat_components_to_logitech_g27_hat(up, down, left, right); + set_bit(buf, 8, shift_up); + set_bit(buf, 9, shift_down); + + set_bit(buf, 7, triangle); + set_bit(buf, 4, cross); + set_bit(buf, 5, square); + set_bit(buf, 6, circle); + + set_bit(buf, 11, l2); + set_bit(buf, 15, l3); + set_bit(buf, 10, r2); + set_bit(buf, 14, r3); + + set_bit(buf, 22, dial_clockwise); + set_bit(buf, 23, dial_anticlockwise); + + set_bit(buf, 24, plus); + set_bit(buf, 25, minus); + + set_bit(buf, 12, select); + set_bit(buf, 13, pause); + + set_bit(buf, 16, shifter_1); + set_bit(buf, 17, shifter_2); + set_bit(buf, 18, shifter_3); + set_bit(buf, 19, shifter_4); + set_bit(buf, 20, shifter_5); + set_bit(buf, 21, shifter_6); + set_bit(buf, 80, shifter_r); + + // calibrated, unsure + set_bit(buf, 82, true); + // shifter connected + set_bit(buf, 83, true); + // shifter stick down + set_bit(buf, 86, shifter_1 || shifter_2 || shifter_3 || shifter_4 || shifter_5 || shifter_6 || shifter_r); + + buf[3] = (steering << 2) | buf[3]; + buf[4] = steering >> 6; + buf[5] = throttle; + buf[6] = brake; + buf[7] = clutch; + + buf[8] = 0x80; // shifter x, don't own one to test gear/coord mapping + buf[9] = 0x80; // shifter y + buf[10] = buf[10] | (wheel_range > 360 ? 0x90 : 0x10); + + //logitech_g27_log.error("%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x", buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7], buf[8], buf[9], buf[10]); + + return; + } + else + { + // Sending data to wheel + if (buf_size < 7) + { + char *hex_buf = reinterpret_cast(malloc(buf_size * 3 + 1)); + if (hex_buf == nullptr) + { + logitech_g27_log.error("Unhandled wheel command with size %u != 16", buf_size); + return; + } + int offset = 0; + for (uint32_t i = 0;i < buf_size;i++) + { + offset += sprintf(&hex_buf[offset], "%02x ", buf[i]); + } + logitech_g27_log.error("Unhandled wheel command with size %u != 16, %s", buf_size, hex_buf); + free(hex_buf); + return; + } + + transfer->expected_count = buf_size; + + // logitech_g27_log.error("%02x %02x %02x %02x %02x %02x %02x", buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]); + // printf("%02x %02x %02x %02x %02x %02x %02x\n", buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]); + + sdl_handles_mutex.lock(); + + SDL_HapticDirection direction = { + .type = SDL_HAPTIC_POLAR, + .dir = {27000, 0} + }; + if (reverse_effects) + { + direction.dir[0] = 9000; + } + + // TODO force clipping from cfg + + // Process effects + if (buf[0] == 0xf8) + { + switch(buf[1]) + { + case 0x01: + { + // Change to DFP + logitech_g27_log.error("Drive Force Pro mode switch command ignored"); + break; + } + case 0x02: + { + // Change wheel range to 200 degrees + logitech_g27_log.error("Change wheel range to 200 degrees command not forwarded"); + wheel_range = 200; + break; + } + case 0x03: + { + // Change wheel range to 900 degrees + logitech_g27_log.error("Change wheel range to 900 degrees command not forwarded"); + wheel_range = 900; + break; + } + case 0x09: + { + // Change device mode + logitech_g27_log.error("Change device mode to %d %s detaching command ignored", buf[2], buf[3] ? "with" : "without"); + break; + } + case 0x0a: + { + // Revert indentity + logitech_g27_log.error("Revert device identity after reset %s command ignored", buf[2] ? "enable" : "disable"); + break; + } + case 0x10: + { + // Switch to G25 with detach + logitech_g27_log.error("Switch to G25 with detach command ignored"); + break; + } + case 0x11: + { + // Switch to G25 without detach + logitech_g27_log.error("Switch to G25 without detach command ignored"); + break; + } + case 0x12: + { + // Incoming data is a 5 bit mask, for each individual bulb + if (led_joystick_handle == nullptr) + { + break; + } + // Mux into total amount of bulbs on, since sdl only takes intensity + uint8_t new_led_level = 0; + for (int i = 0;i < 5;i++) + { + new_led_level += (buf[2] & (1 << i)) ? 1 : 0; + } + + uint8_t intensity = new_led_level * 255 / 5; + SDL_SetJoystickLED(led_joystick_handle, intensity, intensity, intensity); + break; + } + case 0x81: + { + // Wheel range change + wheel_range = (buf[3] << 8) | buf[2]; + logitech_g27_log.error("Wheel range change to %u command not forwarded", wheel_range); + break; + } + default: + { + logitech_g27_log.error("Unknown extended command %02x %02x %02x %02x %02x %02x %02x ignored", buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]); + break; + } + } + } + else + { + uint8_t cmd = buf[0] & 0xf; + uint8_t slot_mask = buf[0] >> 4; + switch (cmd) + { + case 0x00: + case 0x01: + case 0x0c: + { + // Download/Download play/Refresh + for (int i = 0;i < 4;i++){ + SDL_HapticEffect new_effect = {0}; + // hack: need to reduce Download play spams for some drivers + bool update_hack = false; + if (!(slot_mask & (1 << i))) + { + continue; + } + bool unknown_effect = false; + switch (buf[1]) + { + case 0x00: + { + // Constant force + new_effect.type = SDL_HAPTIC_CONSTANT; + new_effect.constant.direction = direction; + new_effect.constant.length = SDL_HAPTIC_INFINITY; + new_effect.constant.level = logitech_g27_force_to_level(buf[2 + i]); + break; + } + case 0x01: + case 0x0b: + { + // Spring/High resolution spring + new_effect.type = SDL_HAPTIC_SPRING; + new_effect.condition.direction = direction; + new_effect.condition.length = SDL_HAPTIC_INFINITY; + uint8_t s1 = buf[5] & 1; + uint8_t s2 = (buf[5] >> 4) & 1; + // TODO direction cfg + uint16_t saturation = logitech_g27_clip_to_saturation(buf[6]); + int16_t center = 0; + uint16_t deadband = 0; + int16_t left_coeff = 0; + int16_t right_coeff = 0; + if (buf[1] == 0x01) + { + uint8_t d1 = buf[2]; + uint8_t d2 = buf[3]; + uint8_t k1 = buf[4] & (0xf >> 1); + uint8_t k2 = (buf[4] >> 4) & (0xf >> 1); + center = logitech_g27_position_to_center(d1, d2); + deadband = logitech_g27_position_to_width(d1, d2); + left_coeff = logitech_g27_coeff_to_coeff(k1, s1); + right_coeff = logitech_g27_coeff_to_coeff(k2, s2); + } + else + { + uint16_t d1 = (buf[2] << 3) | ((buf[5] >> 1) & (0xf >> 1)); + uint16_t d2 = (buf[3] << 3) | (buf[5] >> 5); + uint8_t k1 = buf[4] & 0xf; + uint8_t k2 = buf[4] >> 4; + center = logitech_g27_high_resolution_position_to_center(d1, d2); + deadband = logitech_g27_high_resolution_position_to_width(d1, d2); + left_coeff = logitech_g27_high_resolution_coeff_to_coeff(k1, s1); + right_coeff = logitech_g27_high_resolution_coeff_to_coeff(k2, s2); + } + if (reverse_effects) + { + int16_t coeff = right_coeff; + right_coeff = left_coeff; + left_coeff = coeff; + } + //for(int j = 0;j < 3;j++) + for(int j = 0;j < 1;j++) + { + new_effect.condition.right_sat[j] = saturation; + new_effect.condition.left_sat[j] = saturation; + new_effect.condition.right_coeff[j] = right_coeff; + new_effect.condition.left_coeff[j] = left_coeff; + new_effect.condition.deadband[j] = deadband; + new_effect.condition.center[j] = center; + } + break; + } + case 0x02: + case 0x0c: + { + // Damper/High resolution damper + new_effect.type = SDL_HAPTIC_DAMPER; + new_effect.condition.direction = direction; + new_effect.condition.length = SDL_HAPTIC_INFINITY; + uint8_t s1 = buf[3] & 1; + uint8_t s2 = buf[5] & 1; + // TODO direction cfg + uint16_t saturation = 0x7FFF; + int16_t left_coeff = 0; + int16_t right_coeff = 0; + if (buf[1] == 0x02) + { + uint8_t k1 = buf[2] & (0xf >> 1); + uint8_t k2 = buf[4] & (0xf >> 1); + left_coeff = logitech_g27_coeff_to_coeff(k1, s1); + right_coeff = logitech_g27_coeff_to_coeff(k2, s2); + } + else + { + uint8_t k1 = buf[2] & 0xf; + uint8_t k2 = buf[4] & 0xf; + left_coeff = logitech_g27_high_resolution_coeff_to_coeff(k1, s1); + right_coeff = logitech_g27_high_resolution_coeff_to_coeff(k2, s2); + saturation = logitech_g27_clip_to_saturation(buf[6]); + } + if (reverse_effects) + { + int16_t coeff = right_coeff; + right_coeff = left_coeff; + left_coeff = coeff; + } + //for(int j = 0;j < 3;j++) + for(int j = 0;j < 1;j++) + { + new_effect.condition.right_sat[j] = saturation; + new_effect.condition.left_sat[j] = saturation; + new_effect.condition.right_coeff[j] = right_coeff; + new_effect.condition.left_coeff[j] = left_coeff; + } + break; + } + case 0x0e: + { + // Friction + new_effect.type = SDL_HAPTIC_FRICTION; + new_effect.condition.direction = direction; + new_effect.condition.length = SDL_HAPTIC_INFINITY; + uint8_t k1 = buf[2]; + uint8_t k2 = buf[3]; + uint8_t s1 = buf[5] & 1; + uint8_t s2 = (buf[5] >> 4) & 1; + // TODO direction cfg + int16_t left_coeff = logitech_g27_friction_coeff_to_coeff(k1, s1); + int16_t right_coeff = logitech_g27_friction_coeff_to_coeff(k2, s2); + int16_t saturation = logitech_g27_clip_to_saturation(buf[4]); + if (reverse_effects) + { + int16_t coeff = right_coeff; + right_coeff = left_coeff; + left_coeff = coeff; + } + //for(int j = 0;j < 3;j++) + for(int j = 0;j < 1;j++) + { + new_effect.condition.right_sat[j] = saturation; + new_effect.condition.left_sat[j] = saturation; + new_effect.condition.right_coeff[j] = right_coeff; + new_effect.condition.left_coeff[j] = left_coeff; + } + break; + } + case 0x03: + case 0x0d: + { + // Auto center spring/High resolution auto center spring + new_effect.type = SDL_HAPTIC_SPRING; + new_effect.condition.direction = direction; + new_effect.condition.length = SDL_HAPTIC_INFINITY; + // TODO direction cfg + uint16_t saturation = logitech_g27_clip_to_saturation(buf[4]); + uint16_t deadband = 2 * 0xFFFF / 255; + int16_t center = 0; + int16_t left_coeff = 0; + int16_t right_coeff = 0; + if (buf[1] == 0x03) + { + uint8_t k1 = buf[2] & (0xf >> 1); + uint8_t k2 = buf[3] & (0xf >> 1); + left_coeff = logitech_g27_coeff_to_coeff(k1, 0); + right_coeff = logitech_g27_coeff_to_coeff(k2, 0); + } + else + { + uint8_t k1 = buf[2] & 0xf; + uint8_t k2 = buf[3] & 0xf; + left_coeff = logitech_g27_high_resolution_coeff_to_coeff(k1, 0); + right_coeff = logitech_g27_high_resolution_coeff_to_coeff(k2, 0); + } + if (reverse_effects) + { + int16_t coeff = right_coeff; + right_coeff = left_coeff; + left_coeff = coeff; + } + //for(int j = 0;j < 3;j++) + for(int j = 0;j < 1;j++) + { + new_effect.condition.right_sat[j] = saturation; + new_effect.condition.left_sat[j] = saturation; + new_effect.condition.right_coeff[j] = right_coeff; + new_effect.condition.left_coeff[j] = left_coeff; + new_effect.condition.deadband[j] = deadband; + new_effect.condition.center[j] = center; + } + break; + } + case 0x04: + case 0x05: + { + // Sawtooth up/Sawtooth down + new_effect.type = buf[1] == 0x04 ? SDL_HAPTIC_SAWTOOTHUP : SDL_HAPTIC_SAWTOOTHDOWN; + new_effect.periodic.direction = direction; + new_effect.periodic.length = SDL_HAPTIC_INFINITY; + uint8_t l1 = buf[2]; + uint8_t l2 = buf[3]; + uint8_t l0 = buf[4]; + uint8_t t3 = buf[6] >> 4; + uint8_t inc = buf[6] & 0xf; + if (inc != 0) + new_effect.periodic.period = ((l1 - l2) * logitech_g27_loops_to_ms(t3, !fixed_loop)) / inc; + else + { + logitech_g27_log.error("cannot evaluate slope for saw tooth effect, loops per step %u level per step %u", t3, inc); + new_effect.periodic.period = 1000; + } + new_effect.periodic.offset = logitech_g27_force_to_level((l1 + l2) / 2); + new_effect.periodic.magnitude = logitech_g27_force_to_level(l1) - new_effect.periodic.offset; + new_effect.periodic.phase = buf[1] == 0x04 ? 36000 * (l1 - l0) / (l1 - l2) : 36000 * (l0 - l2) / (l1 - l2); + break; + } + case 0x06: + { + // Trapezoid, convert to SDL_HAPTIC_SQUARE or SDL_HAPTIC_TRIANGLE + new_effect.periodic.direction = direction; + new_effect.periodic.length = SDL_HAPTIC_INFINITY; + uint8_t l1 = buf[2]; + uint8_t l2 = buf[3]; + uint8_t t1 = buf[4]; + uint8_t t2 = buf[5]; + uint8_t t3 = buf[6] >> 4; + uint8_t s = buf[6] & 0xf; + uint16_t total_flat_time = logitech_g27_loops_to_ms(t1 + t2, !fixed_loop); + uint16_t total_slope_time = (((l1 - l2) * logitech_g27_loops_to_ms(t3, !fixed_loop)) / s) * 2; + if (total_flat_time > total_slope_time) + { + new_effect.type = SDL_HAPTIC_SQUARE; + } + else + { + new_effect.type = SDL_HAPTIC_TRIANGLE; + } + new_effect.periodic.period = total_slope_time + total_flat_time; + new_effect.periodic.offset = logitech_g27_force_to_level((l1 + l2) / 2); + new_effect.periodic.magnitude = logitech_g27_force_to_level(l1) - new_effect.periodic.offset; + break; + } + case 0x07: + { + // Rectangle, convert to SDL_HAPTIC_SQUARE + new_effect.type = SDL_HAPTIC_SQUARE; + new_effect.periodic.direction = direction; + new_effect.periodic.length = SDL_HAPTIC_INFINITY; + uint8_t l1 = buf[2]; + uint8_t l2 = buf[3]; + uint8_t t1 = buf[4]; + uint8_t t2 = buf[5]; + uint8_t p = buf[6]; + new_effect.periodic.period = logitech_g27_loops_to_ms(t1, !fixed_loop) + logitech_g27_loops_to_ms(t2, !fixed_loop); + new_effect.periodic.offset = logitech_g27_force_to_level((l1 + l2) / 2); + new_effect.periodic.magnitude = logitech_g27_force_to_level(l1) - new_effect.periodic.offset; + if (new_effect.periodic.period != 0) + new_effect.periodic.phase = 36000 * logitech_g27_loops_to_ms(p, !fixed_loop) / new_effect.periodic.period; + else + { + logitech_g27_log.error("cannot evaluate phase for square effect"); + new_effect.periodic.phase = 0; + } + break; + } + case 0x08: + case 0x09: + { + // Variable/Ramp, convert to SDL_HAPTIC_CONSTANT + if (i % 2 != 0) + { + continue; + } + new_effect.type = SDL_HAPTIC_CONSTANT; + new_effect.constant.direction = direction; + uint8_t l1 = buf[2]; + uint8_t l2 = buf[3]; + uint8_t t1 = buf[4] >> 4; + uint8_t s1 = buf[4] & 0xf; + uint8_t t2 = buf[5] >> 4; + uint8_t s2 = buf[5] & 0xf; + uint8_t d1 = buf[6] & 1; + uint8_t d2 = (buf[6] >> 4) & 1; + if (buf[1] == 0x08) + { + uint8_t t = i == 0 ? t1 : t2; + uint8_t s = i == 0 ? s1 : s2; + uint8_t d = i == 0 ? d1 : d2; + uint8_t l = i == 0 ? l1 : l2; + new_effect.constant.length = SDL_HAPTIC_INFINITY; + if (s == 0 || t == 0) + { + // gran turismo 6 does this, gives a variable force with no step so it just behaves as constant force + new_effect.constant.level = logitech_g27_force_to_level(l); + // hack: gran turismo 6 spams download and play + update_hack = true; + } + else + { + new_effect.constant.attack_level = logitech_g27_force_to_level(l); + if (d) + { + new_effect.constant.level = 0; + new_effect.constant.attack_length = l * logitech_g27_loops_to_ms(t, !fixed_loop) / s; + } + else + { + new_effect.constant.level = 0x7FFF; + new_effect.constant.attack_length = (255 - l) * logitech_g27_loops_to_ms(t, !fixed_loop) / s; + } + } + } + else + { + if (s2 == 0 || t2 == 0) + { + logitech_g27_log.error("cannot evaluate slope for ramp effect, loops per step %u level per step %u", t2, s2); + } + else + { + new_effect.constant.length = (l1 - l2) * logitech_g27_loops_to_ms(t2, !fixed_loop) / s2 ; + new_effect.constant.attack_length = new_effect.constant.length; + new_effect.constant.attack_level = d1 ? logitech_g27_force_to_level(l1) : logitech_g27_force_to_level(l2); + } + new_effect.constant.level = d1 ? logitech_g27_force_to_level(l2) : logitech_g27_force_to_level(l1); + } + break; + } + case 0x0a: + { + // Square + new_effect.type = SDL_HAPTIC_SQUARE; + new_effect.periodic.direction = direction; + uint8_t a = buf[2]; + uint8_t tl = buf[3]; + uint8_t th = buf[4]; + uint8_t n = buf[5]; + uint16_t t = (th << 8) | tl; + new_effect.periodic.period = logitech_g27_loops_to_ms(t * 2, !fixed_loop); + new_effect.periodic.magnitude = logitech_g27_amplitude_to_magnitude(a); + if (n == 0) + new_effect.periodic.length = new_effect.periodic.period * 256; + else + new_effect.periodic.length = new_effect.periodic.period * n; + break; + } + default: + { + unknown_effect = true; + } + } + + if (unknown_effect) + { + logitech_g27_log.error("Command %02x %02x %02x %02x %02x %02x %02x with unknown effect ignored", buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]); + continue; + } + + bool play_effect = (cmd == 0x01 || (cmd == 0x0c && effect_slots[i].effect_id == -1)); + + if (update_hack) + { + if (effect_slots[i].effect_id == -1) + update_hack = false; + if (effect_slots[i].last_effect.type != new_effect.type) + update_hack = false; + } + + if (cmd == 0x00 || play_effect) + { + if (effect_slots[i].effect_id != -1 && haptic_handle != nullptr && !update_hack) + { + SDL_DestroyHapticEffect(haptic_handle, effect_slots[i].effect_id); + effect_slots[i].effect_id = -1; + } + if (haptic_handle != nullptr && effect_slots[i].effect_id == -1) + { + effect_slots[i].effect_id = SDL_CreateHapticEffect(haptic_handle, &new_effect); + } + if (update_hack) + { + if (!SDL_UpdateHapticEffect(haptic_handle, effect_slots[i].effect_id, &new_effect)) + logitech_g27_log.error("Failed refreshing slot %d sdl effect %d, %s", i, new_effect.type, SDL_GetError()); + } + effect_slots[i].state = G27_FFB_DOWNLOADED; + effect_slots[i].last_effect = new_effect; + effect_slots[i].last_update = SDL_GetTicks(); + if (effect_slots[i].effect_id == -1 && haptic_handle != nullptr) + { + logitech_g27_log.error("Failed uploading effect %02x %02x %02x %02x %02x %02x %02x to slot %i, %s", buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], i, SDL_GetError()); + } + } + if (play_effect && haptic_handle != nullptr) + { + if (effect_slots[i].effect_id != -1) + { + if (!SDL_RunHapticEffect(haptic_handle, effect_slots[i].effect_id, 1)) + { + logitech_g27_log.error("Failed playing sdl effect %d on slot %d, %s\n", effect_slots[i].last_effect.type, i, SDL_GetError()); + } + } + else + { + logitech_g27_log.error("Tried to play effect slot %d with sdl effect %d, but upload failed previously", i, effect_slots[i].last_effect.type); + } + effect_slots[i].state = G27_FFB_PLAYING; + } + if (cmd == 0xc && !play_effect && haptic_handle != nullptr) + { + if (!SDL_UpdateHapticEffect(haptic_handle, effect_slots[i].effect_id, &new_effect)) + { + logitech_g27_log.error("Failed refreshing slot %d sdl effect %d, %s", i, new_effect.type, SDL_GetError()); + } + } + } + break; + } + case 0x02: + case 0x03: + { + for (int i = 0;i < 4;i++) + { + // Play/Stop + if (!(slot_mask & (1 << i))) + { + continue; + } + if (effect_slots[i].state == G27_FFB_PLAYING || effect_slots[i].state == G27_FFB_DOWNLOADED) + { + effect_slots[i].state = cmd == 0x02 ? G27_FFB_PLAYING : G27_FFB_DOWNLOADED; + if (haptic_handle != nullptr) + { + if (effect_slots[i].effect_id == -1) + { + effect_slots[i].effect_id = SDL_CreateHapticEffect(haptic_handle, &effect_slots[i].last_effect); + } + if (effect_slots[i].effect_id != -1) + { + if (cmd == 0x02) + { + if (!SDL_RunHapticEffect(haptic_handle, effect_slots[i].effect_id, 1)) + { + logitech_g27_log.error("Failed playing sdl effect %d on slot %d, %s\n", effect_slots[i].last_effect.type, i, SDL_GetError()); + } + } + else + { + if (!SDL_StopHapticEffect(haptic_handle, effect_slots[i].effect_id)) + { + logitech_g27_log.error("Failed stopping sdl effect %d on slot %d, %s\n", effect_slots[i].last_effect.type, i, SDL_GetError()); + } + } + } + else + { + if (cmd == 0x02) + { + logitech_g27_log.error("Tried to play effect slot %d with sdl effect %d, but upload failed previously", i, effect_slots[i].last_effect.type); + } + else + { + logitech_g27_log.error("Tried to stop effect slot %d with sdl effect %d, but upload failed previously", i, effect_slots[i].last_effect.type); + } + } + } + } + else + { + if (cmd == 0x02) + { + logitech_g27_log.error("Tried to play effect slot %d but it was never uploaded\n", i); + } + else + { + logitech_g27_log.error("Tried to stop effect slot %d but it was never uploaded\n", i); + } + } + } + break; + } + case 0x0e: + { + // Set Default Spring + uint8_t k1 = buf[2] & (0xf >> 1); + uint8_t k2 = buf[3] & (0xf >> 1); + uint16_t saturation = logitech_g27_clip_to_saturation(buf[4]); + int16_t left_coeff = logitech_g27_coeff_to_coeff(k1, 0); + int16_t right_coeff = logitech_g27_coeff_to_coeff(k2, 0); + uint16_t deadband = 2 * 0xFFFF / 255; + int16_t center = 0; + if (reverse_effects) + { + int16_t coeff = right_coeff; + right_coeff = left_coeff; + left_coeff = coeff; + } + //for (int i = 0;i < 3;i++){ + for (int i = 0;i < 1;i++){ + // TODO direction cfg + default_spring_effect.condition.right_sat[i] = saturation; + default_spring_effect.condition.left_sat[i] = saturation; + default_spring_effect.condition.right_coeff[i] = right_coeff; + default_spring_effect.condition.left_coeff[i] = left_coeff; + default_spring_effect.condition.deadband[i] = deadband; + default_spring_effect.condition.center[i] = center; + } + + if (haptic_handle == nullptr) + { + break; + } + + if (default_spring_effect_id == -1) + { + default_spring_effect_id = SDL_CreateHapticEffect(haptic_handle, &default_spring_effect); + if (default_spring_effect_id == -1) + { + logitech_g27_log.error("Failed creating default spring effect, %s", SDL_GetError()); + } + } + else + { + if (!SDL_UpdateHapticEffect(haptic_handle, default_spring_effect_id, &default_spring_effect)) + { + logitech_g27_log.error("Failed updating default spring effect, %s", SDL_GetError()); + } + } + break; + } + case 0x04: + case 0x05: + { + // Default spring on/Default spring off + if (haptic_handle == nullptr) + { + break; + } + + if (default_spring_effect_id == -1) + { + default_spring_effect_id = SDL_CreateHapticEffect(haptic_handle, &default_spring_effect); + if (default_spring_effect_id == -1) + { + logitech_g27_log.error("Failed creating default spring effect, %s", SDL_GetError()); + } + } + if (default_spring_effect_id != -1) + { + if (cmd == 0x04) + { + if (!SDL_RunHapticEffect(haptic_handle, default_spring_effect_id, 1)) + { + logitech_g27_log.error("Failed playing default spring effect, %s", SDL_GetError()); + } + } + else + { + if (!SDL_StopHapticEffect(haptic_handle, default_spring_effect_id)) + { + logitech_g27_log.error("Failed stopping default spring effect, %s", SDL_GetError()); + } + } + } + break; + } + case 0x08: + { + // Normal Mode / Extended + logitech_g27_log.error("Normal mode restore command ignored"); + break; + } + case 0x09: + { + // Set LED + if (led_joystick_handle == nullptr) + { + break; + } + + uint8_t new_led_level = 0; + for (int i = 0;i < 8;i++) + { + new_led_level += (buf[1] & (1 << i)) ? 1 : 0; + } + uint8_t intensity = new_led_level * 255 / 7; + SDL_SetJoystickLED(led_joystick_handle, intensity, intensity, intensity); + break; + } + case 0x0a: + { + // Set watchdog + logitech_g27_log.error("Watchdog command with duration of %u loops ignored", buf[1]); + break; + } + case 0x0b: + { + // Raw mode + logitech_g27_log.error("Raw mode command ignored"); + break; + } + case 0x0d: + { + // Fixed time loop toggle + fixed_loop = buf[1] ? true : false; + if (!fixed_loop) + { + logitech_g27_log.error("as fast as possible mode requested, effect durations might be inaccurate"); + } + break; + } + case 0x0f: + { + // Set dead band + logitech_g27_log.error("Set dead band command ignored"); + break; + } + default: + { + logitech_g27_log.error("Unknown command %02x %02x %02x %02x %02x %02x %02x ignored", buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]); + } + } + } + sdl_handles_mutex.unlock(); + } +} + +#endif diff --git a/rpcs3/Emu/Io/LogitechG27.h b/rpcs3/Emu/Io/LogitechG27.h new file mode 100644 index 0000000000..46958afc5e --- /dev/null +++ b/rpcs3/Emu/Io/LogitechG27.h @@ -0,0 +1,130 @@ +#pragma once + +#include "Emu/Io/usb_device.h" + +#include "SDL3/SDL.h" +#include +#include +#include + +enum logitech_g27_ffb_state +{ + G27_FFB_INACTIVE, + G27_FFB_DOWNLOADED, + G27_FFB_PLAYING +}; + +struct logitech_g27_ffb_slot +{ + logitech_g27_ffb_state state; + uint64_t last_update; + SDL_HapticEffect last_effect; + int effect_id; +}; + +// TODO maybe push these into cfg +enum sdl_mapping_type +{ + MAPPING_BUTTON = 0, + MAPPING_HAT, + MAPPING_AXIS, +}; + +enum hat_component +{ + HAT_NONE = 0, + HAT_UP, + HAT_DOWN, + HAT_LEFT, + HAT_RIGHT +}; + +struct sdl_mapping +{ + uint32_t device_type_id; // (vendor_id << 16) | product_id + sdl_mapping_type type; + uint64_t id; + hat_component hat; + bool reverse; + bool positive_axis; +}; + +struct logitech_g27_sdl_mapping +{ + sdl_mapping steering; + sdl_mapping throttle; + sdl_mapping brake; + sdl_mapping clutch; + sdl_mapping shift_up; + sdl_mapping shift_down; + + sdl_mapping up; + sdl_mapping down; + sdl_mapping left; + sdl_mapping right; + + sdl_mapping triangle; + sdl_mapping cross; + sdl_mapping square; + sdl_mapping circle; + + // mappings based on g27 compat mode on g29 + sdl_mapping l2; + sdl_mapping l3; + sdl_mapping r2; + sdl_mapping r3; + + sdl_mapping plus; + sdl_mapping minus; + + sdl_mapping dial_clockwise; + sdl_mapping dial_anticlockwise; + + sdl_mapping select; + sdl_mapping pause; + + sdl_mapping shifter_1; + sdl_mapping shifter_2; + sdl_mapping shifter_3; + sdl_mapping shifter_4; + sdl_mapping shifter_5; + sdl_mapping shifter_6; + sdl_mapping shifter_r; +}; + +class usb_device_logitech_g27 : public usb_device_emulated +{ +public: + usb_device_logitech_g27(u32 controller_index, const std::array& location); + ~usb_device_logitech_g27(); + + static std::shared_ptr make_instance(u32 controller_index, const std::array& location); + static u16 get_num_emu_devices(); + + void control_transfer(u8 bmRequestType, u8 bRequest, u16 wValue, u16 wIndex, u16 wLength, u32 buf_size, u8* buf, UsbTransfer* transfer) override; + void interrupt_transfer(u32 buf_size, u8* buf, u32 endpoint, UsbTransfer* transfer) override; + bool open_device() override; + + std::mutex thread_control_mutex; + bool stop_thread; + char thread_name[64]; + SDL_Thread *thread = nullptr; + void sdl_refresh(); +private: + u32 m_controller_index; + + logitech_g27_sdl_mapping mapping; + bool reverse_effects; + + std::mutex sdl_handles_mutex; + SDL_Joystick *led_joystick_handle = nullptr; + SDL_Haptic *haptic_handle = nullptr; + std::map> joysticks; + bool fixed_loop = false; + uint16_t wheel_range = 200; + logitech_g27_ffb_slot effect_slots[4]; + SDL_HapticEffect default_spring_effect = {0}; + int default_spring_effect_id = -1; + + bool enabled; +}; diff --git a/rpcs3/Emu/Io/LogitechG27Config.cpp b/rpcs3/Emu/Io/LogitechG27Config.cpp new file mode 100644 index 0000000000..78563f373b --- /dev/null +++ b/rpcs3/Emu/Io/LogitechG27Config.cpp @@ -0,0 +1,145 @@ +#include "stdafx.h" + +#ifdef HAVE_SDL3 + +#include "Utilities/File.h" +#include "LogitechG27.h" +#include "LogitechG27Config.h" + +emulated_logitech_g27_config g_cfg_logitech_g27; + +LOG_CHANNEL(cfg_log, "CFG"); + +void emulated_logitech_g27_config::fill_defaults(){ + // a shifter-less g29 with a xbox 360 controller shifter place holder... + m_mutex.lock(); + + #define INIT_AXIS_MAPPING(name, device_type_id, id, reverse) \ + { \ + name##_device_type_id.set(device_type_id); \ + name##_type.set(MAPPING_AXIS); \ + name##_id.set(id); \ + name##_hat.set(HAT_NONE); \ + name##_reverse.set(reverse); \ + } + + INIT_AXIS_MAPPING(steering, 0x046dc24f, 0, false); + INIT_AXIS_MAPPING(throttle, 0x046dc24f, 2, false); + INIT_AXIS_MAPPING(brake, 0x046dc24f, 3, false); + INIT_AXIS_MAPPING(clutch, 0x046dc24f, 1, false); + + #undef INIT_AXIS_MAPPING + + #define INIT_BUTTON_MAPPING(name, device_type_id, id, reverse) \ + { \ + name##_device_type_id.set(device_type_id); \ + name##_type.set(MAPPING_BUTTON); \ + name##_id.set(id); \ + name##_hat.set(HAT_NONE); \ + name##_reverse.set(reverse); \ + } + + INIT_BUTTON_MAPPING(shift_up, 0x046dc24f, 4, false); + INIT_BUTTON_MAPPING(shift_down, 0x046dc24f, 5, false); + + INIT_BUTTON_MAPPING(triangle, 0x046dc24f, 3, false); + INIT_BUTTON_MAPPING(cross, 0x046dc24f, 0, false); + INIT_BUTTON_MAPPING(square, 0x046dc24f, 1, false); + INIT_BUTTON_MAPPING(circle, 0x046dc24f, 2, false); + + INIT_BUTTON_MAPPING(l2, 0x046dc24f, 7, false); + INIT_BUTTON_MAPPING(l3, 0x046dc24f, 11, false); + INIT_BUTTON_MAPPING(r2, 0x046dc24f, 6, false); + INIT_BUTTON_MAPPING(r3, 0x046dc24f, 10, false); + + INIT_BUTTON_MAPPING(plus, 0x046dc24f, 19, false); + INIT_BUTTON_MAPPING(minus, 0x046dc24f, 20, false); + + INIT_BUTTON_MAPPING(dial_clockwise, 0x046dc24f, 21, false); + INIT_BUTTON_MAPPING(dial_anticlockwise, 0x046dc24f, 22, false); + + INIT_BUTTON_MAPPING(select, 0x046dc24f, 8, false); + INIT_BUTTON_MAPPING(pause, 0x046dc24f, 9, false); + + INIT_BUTTON_MAPPING(shifter_1, 0x045e028e, 3, false); + INIT_BUTTON_MAPPING(shifter_2, 0x045e028e, 0, false); + INIT_BUTTON_MAPPING(shifter_3, 0x045e028e, 2, false); + INIT_BUTTON_MAPPING(shifter_4, 0x045e028e, 1, false); + + #undef INIT_BUTTON_MAPPING + + #define INIT_HAT_MAPPING(name, device_type_id, id, hat, reverse) \ + { \ + name##_device_type_id.set(device_type_id); \ + name##_type.set(MAPPING_HAT); \ + name##_id.set(id); \ + name##_hat.set(hat); \ + name##_reverse.set(reverse); \ + } + + INIT_HAT_MAPPING(up, 0x046dc24f, 0, HAT_UP, false); + INIT_HAT_MAPPING(down, 0x046dc24f, 0, HAT_DOWN, false); + INIT_HAT_MAPPING(left, 0x046dc24f, 0, HAT_LEFT, false); + INIT_HAT_MAPPING(right, 0x046dc24f, 0, HAT_RIGHT, false); + + INIT_HAT_MAPPING(shifter_5, 0x045e028e, 0, HAT_UP, false); + INIT_HAT_MAPPING(shifter_6, 0x045e028e, 0, HAT_DOWN, false); + INIT_HAT_MAPPING(shifter_r, 0x045e028e, 0, HAT_LEFT, false); + + #undef INIT_HAT_MAPPING + + reverse_effects.set(true); + ffb_device_type_id.set(0x046dc24f); + led_device_type_id.set(0x046dc24f); + + enabled.set(false); + + m_mutex.unlock(); +} + +void emulated_logitech_g27_config::save(){ + m_mutex.lock(); + const std::string cfg_name = fmt::format("%s%s.yml", fs::get_config_dir(true), "LogitechG27"); + cfg_log.notice("Saving LogitechG27 config: %s", cfg_name); + + if (!fs::create_path(fs::get_parent_dir(cfg_name))) + { + cfg_log.fatal("Failed to create path: %s (%s)", cfg_name, fs::g_tls_error); + } + + if (!cfg::node::save(cfg_name)) + { + cfg_log.error("Failed to save LogitechG27 config to '%s' (error=%s)", cfg_name, fs::g_tls_error); + } + m_mutex.unlock(); + +} + +bool emulated_logitech_g27_config::load() +{ + bool result = false; + const std::string cfg_name = fmt::format("%s%s.yml", fs::get_config_dir(true), "LogitechG27"); + cfg_log.notice("Loading LogitechG27 config: %s", cfg_name); + + fill_defaults(); + + m_mutex.lock(); + + if (fs::file cfg_file{ cfg_name, fs::read }) + { + if (const std::string content = cfg_file.to_string(); !content.empty()) + { + result = from_string(content); + } + m_mutex.unlock(); + } + else + { + m_mutex.unlock(); + save(); + } + + return result; +} + +#endif diff --git a/rpcs3/Emu/Io/LogitechG27Config.h b/rpcs3/Emu/Io/LogitechG27Config.h new file mode 100644 index 0000000000..7e93e62ba2 --- /dev/null +++ b/rpcs3/Emu/Io/LogitechG27Config.h @@ -0,0 +1,70 @@ +#pragma once + +#include "Utilities/Config.h" + +#include + +struct emulated_logitech_g27_config : cfg::node { + std::mutex m_mutex; + bool load(); + void save(); + void fill_defaults(); + + #define STR(s) #s + #define MAPPING_ENTRY(name) \ + cfg::uint<0, 0xFFFFFFFF> name##_device_type_id{this, STR(name##_device_type_id)}; \ + cfg::uint<0, 0xFFFFFFFF> name##_type{this, STR(name##_type)}; \ + cfg::uint<0, 0xFFFFFFFFFFFFFFFF> name##_id{this, STR(name##_id)}; \ + cfg::uint<0, 0xFFFFFFFF> name##_hat{this, STR(name##_hat)}; \ + cfg::_bool name##_reverse{this, STR(name##_reverse)}; + + MAPPING_ENTRY(steering); + MAPPING_ENTRY(throttle); + MAPPING_ENTRY(brake); + MAPPING_ENTRY(clutch); + MAPPING_ENTRY(shift_up); + MAPPING_ENTRY(shift_down); + + MAPPING_ENTRY(up); + MAPPING_ENTRY(down); + MAPPING_ENTRY(left); + MAPPING_ENTRY(right); + + MAPPING_ENTRY(triangle); + MAPPING_ENTRY(cross); + MAPPING_ENTRY(square); + MAPPING_ENTRY(circle); + + MAPPING_ENTRY(l2); + MAPPING_ENTRY(l3); + MAPPING_ENTRY(r2); + MAPPING_ENTRY(r3); + + MAPPING_ENTRY(plus); + MAPPING_ENTRY(minus); + + MAPPING_ENTRY(dial_clockwise); + MAPPING_ENTRY(dial_anticlockwise); + + MAPPING_ENTRY(select); + MAPPING_ENTRY(pause); + + MAPPING_ENTRY(shifter_1); + MAPPING_ENTRY(shifter_2); + MAPPING_ENTRY(shifter_3); + MAPPING_ENTRY(shifter_4); + MAPPING_ENTRY(shifter_5); + MAPPING_ENTRY(shifter_6); + MAPPING_ENTRY(shifter_r); + + #undef MAPPING_ENTRY + #undef STR + + cfg::_bool reverse_effects{this, "reverse_effects"}; + cfg::uint<0, 0xFFFFFFFF> ffb_device_type_id{this, "ffb_device_type_id"}; + cfg::uint<0, 0xFFFFFFFF> led_device_type_id{this, "led_device_type_id"}; + + cfg::_bool enabled{this, "enabled"}; +}; + +extern emulated_logitech_g27_config g_cfg_logitech_g27; diff --git a/rpcs3/Input/sdl_instance.cpp b/rpcs3/Input/sdl_instance.cpp new file mode 100644 index 0000000000..92f91d3195 --- /dev/null +++ b/rpcs3/Input/sdl_instance.cpp @@ -0,0 +1,128 @@ +#ifdef HAVE_SDL3 + +#include "stdafx.h" + +#include "SDL3/SDL.h" + +#include "util/logs.hpp" + +#include "sdl_instance.h" + +LOG_CHANNEL(sdl_log, "SDL"); + +sdl_instance::~sdl_instance() +{ + // Only quit SDL once on exit. SDL uses a global state internally... + if (m_initialized) + { + sdl_log.notice("Quitting SDL ..."); + SDL_Quit(); + } +} + +sdl_instance& sdl_instance::get_instance() +{ + static sdl_instance instance {}; + return instance; +} + +void sdl_instance::pump_events() +{ + instance_mutex.lock(); + if (m_initialized) + SDL_PumpEvents(); + instance_mutex.unlock(); +} + +bool sdl_instance::initialize() +{ + instance_mutex.lock(); + // Only init SDL once. SDL uses a global state internally... + if (m_initialized) + { + instance_mutex.unlock(); + return true; + } + + sdl_log.notice("Initializing SDL ..."); + + // Set non-dynamic hints before SDL_Init + if (!SDL_SetHint(SDL_HINT_JOYSTICK_THREAD, "1")) + { + sdl_log.error("Could not set SDL_HINT_JOYSTICK_THREAD: %s", SDL_GetError()); + } + + if (!SDL_Init(SDL_INIT_JOYSTICK | SDL_INIT_GAMEPAD)) + { + sdl_log.error("Could not initialize! SDL Error: %s", SDL_GetError()); + instance_mutex.unlock(); + return false; + } + + SDL_SetLogPriorities(SDL_LOG_PRIORITY_VERBOSE); + SDL_SetLogOutputFunction([](void*, int category, SDL_LogPriority priority, const char* message) + { + std::string category_name; + switch (category) + { + case SDL_LOG_CATEGORY_APPLICATION: + category_name = "app"; + break; + case SDL_LOG_CATEGORY_ERROR: + category_name = "error"; + break; + case SDL_LOG_CATEGORY_ASSERT: + category_name = "assert"; + break; + case SDL_LOG_CATEGORY_SYSTEM: + category_name = "system"; + break; + case SDL_LOG_CATEGORY_AUDIO: + category_name = "audio"; + break; + case SDL_LOG_CATEGORY_VIDEO: + category_name = "video"; + break; + case SDL_LOG_CATEGORY_RENDER: + category_name = "render"; + break; + case SDL_LOG_CATEGORY_INPUT: + category_name = "input"; + break; + case SDL_LOG_CATEGORY_TEST: + category_name = "test"; + break; + default: + category_name = fmt::format("unknown(%d)", category); + break; + } + + switch (priority) + { + case SDL_LOG_PRIORITY_VERBOSE: + case SDL_LOG_PRIORITY_DEBUG: + sdl_log.trace("%s: %s", category_name, message); + break; + case SDL_LOG_PRIORITY_INFO: + sdl_log.notice("%s: %s", category_name, message); + break; + case SDL_LOG_PRIORITY_WARN: + sdl_log.warning("%s: %s", category_name, message); + break; + case SDL_LOG_PRIORITY_ERROR: + sdl_log.error("%s: %s", category_name, message); + break; + case SDL_LOG_PRIORITY_CRITICAL: + sdl_log.error("%s: %s", category_name, message); + break; + default: + break; + } + }, nullptr); + + m_initialized = true; + instance_mutex.unlock(); + return true; +} + +#endif diff --git a/rpcs3/Input/sdl_instance.h b/rpcs3/Input/sdl_instance.h new file mode 100644 index 0000000000..d74d872745 --- /dev/null +++ b/rpcs3/Input/sdl_instance.h @@ -0,0 +1,18 @@ +#pragma once + +#include + +struct sdl_instance +{ +public: + sdl_instance() = default; + ~sdl_instance(); + + static sdl_instance& get_instance(); + + bool initialize(); + void pump_events(); +private: + bool m_initialized = false; + std::mutex instance_mutex; +}; diff --git a/rpcs3/Input/sdl_pad_handler.cpp b/rpcs3/Input/sdl_pad_handler.cpp index 38bd6bc1bd..244cd6006a 100644 --- a/rpcs3/Input/sdl_pad_handler.cpp +++ b/rpcs3/Input/sdl_pad_handler.cpp @@ -5,122 +5,12 @@ #include "Emu/system_utils.hpp" #include "Emu/system_config.h" #include "Emu/System.h" +#include "sdl_instance.h" #include LOG_CHANNEL(sdl_log, "SDL"); -struct sdl_instance -{ -public: - sdl_instance() = default; - ~sdl_instance() - { - // Only quit SDL once on exit. SDL uses a global state internally... - if (m_initialized) - { - sdl_log.notice("Quitting SDL ..."); - SDL_Quit(); - } - } - - static sdl_instance& get_instance() - { - static sdl_instance instance {}; - return instance; - } - - bool initialize() - { - // Only init SDL once. SDL uses a global state internally... - if (m_initialized) - { - return true; - } - - sdl_log.notice("Initializing SDL ..."); - - // Set non-dynamic hints before SDL_Init - if (!SDL_SetHint(SDL_HINT_JOYSTICK_THREAD, "1")) - { - sdl_log.error("Could not set SDL_HINT_JOYSTICK_THREAD: %s", SDL_GetError()); - } - - if (!SDL_Init(SDL_INIT_JOYSTICK | SDL_INIT_GAMEPAD)) - { - sdl_log.error("Could not initialize! SDL Error: %s", SDL_GetError()); - return false; - } - - SDL_SetLogPriorities(SDL_LOG_PRIORITY_VERBOSE); - SDL_SetLogOutputFunction([](void*, int category, SDL_LogPriority priority, const char* message) - { - std::string category_name; - switch (category) - { - case SDL_LOG_CATEGORY_APPLICATION: - category_name = "app"; - break; - case SDL_LOG_CATEGORY_ERROR: - category_name = "error"; - break; - case SDL_LOG_CATEGORY_ASSERT: - category_name = "assert"; - break; - case SDL_LOG_CATEGORY_SYSTEM: - category_name = "system"; - break; - case SDL_LOG_CATEGORY_AUDIO: - category_name = "audio"; - break; - case SDL_LOG_CATEGORY_VIDEO: - category_name = "video"; - break; - case SDL_LOG_CATEGORY_RENDER: - category_name = "render"; - break; - case SDL_LOG_CATEGORY_INPUT: - category_name = "input"; - break; - case SDL_LOG_CATEGORY_TEST: - category_name = "test"; - break; - default: - category_name = fmt::format("unknown(%d)", category); - break; - } - - switch (priority) - { - case SDL_LOG_PRIORITY_VERBOSE: - case SDL_LOG_PRIORITY_DEBUG: - sdl_log.trace("%s: %s", category_name, message); - break; - case SDL_LOG_PRIORITY_INFO: - sdl_log.notice("%s: %s", category_name, message); - break; - case SDL_LOG_PRIORITY_WARN: - sdl_log.warning("%s: %s", category_name, message); - break; - case SDL_LOG_PRIORITY_ERROR: - sdl_log.error("%s: %s", category_name, message); - break; - case SDL_LOG_PRIORITY_CRITICAL: - sdl_log.error("%s: %s", category_name, message); - break; - default: - break; - } - }, nullptr); - - m_initialized = true; - return true; - } - -private: - bool m_initialized = false; -}; - sdl_pad_handler::sdl_pad_handler() : PadHandlerBase(pad_handler::sdl) { button_list = @@ -314,7 +204,7 @@ void sdl_pad_handler::process() if (!m_is_init) return; - SDL_PumpEvents(); + sdl_instance::get_instance().pump_events(); PadHandlerBase::process(); } @@ -771,7 +661,7 @@ void sdl_pad_handler::get_motion_sensors(const std::string& pad_id, const motion if (!m_is_init) return; - SDL_PumpEvents(); + sdl_instance::get_instance().pump_events(); PadHandlerBase::get_motion_sensors(pad_id, callback, fail_callback, preview_values, sensors); } @@ -781,7 +671,7 @@ PadHandlerBase::connection sdl_pad_handler::get_next_button_press(const std::str if (!m_is_init) return connection::disconnected; - SDL_PumpEvents(); + sdl_instance::get_instance().pump_events(); return PadHandlerBase::get_next_button_press(padId, callback, fail_callback, call_type, buttons); } diff --git a/rpcs3/emucore.vcxproj b/rpcs3/emucore.vcxproj index 6b1475aa7c..ad3aa3fae0 100644 --- a/rpcs3/emucore.vcxproj +++ b/rpcs3/emucore.vcxproj @@ -40,7 +40,7 @@ Use - ..\3rdparty\miniupnp\miniupnp\miniupnpc\include;..\3rdparty\wolfssl\wolfssl;..\3rdparty\flatbuffers\include;..\3rdparty\libusb\libusb\libusb;..\3rdparty\yaml-cpp\yaml-cpp\include;..\3rdparty\SoundTouch\soundtouch\include;..\3rdparty\rtmidi\rtmidi;..\3rdparty\zlib\zlib;$(SolutionDir)build\lib\$(Configuration)-$(Platform)\llvm_build\include;$(SolutionDir)build\lib_ext\$(Configuration)-$(Platform)\llvm_build\include;$(SolutionDir)build\lib_ext\$(Configuration)-$(Platform)\llvm\include;$(SolutionDir)build\lib_ext\$(Configuration)-$(Platform)\llvm_build\include;$(VULKAN_SDK)\Include;..\3rdparty\zstd\zstd\lib;$(SolutionDir)3rdparty\fusion\fusion\Fusion;$(SolutionDir)3rdparty\wolfssl\extra\win32 + ..\3rdparty\miniupnp\miniupnp\miniupnpc\include;..\3rdparty\wolfssl\wolfssl;..\3rdparty\flatbuffers\include;..\3rdparty\libusb\libusb\libusb;..\3rdparty\yaml-cpp\yaml-cpp\include;..\3rdparty\SoundTouch\soundtouch\include;..\3rdparty\rtmidi\rtmidi;..\3rdparty\zlib\zlib;$(SolutionDir)build\lib\$(Configuration)-$(Platform)\llvm_build\include;$(SolutionDir)build\lib_ext\$(Configuration)-$(Platform)\llvm_build\include;$(SolutionDir)build\lib_ext\$(Configuration)-$(Platform)\llvm\include;$(SolutionDir)build\lib_ext\$(Configuration)-$(Platform)\llvm_build\include;$(VULKAN_SDK)\Include;..\3rdparty\zstd\zstd\lib;$(SolutionDir)3rdparty\fusion\fusion\Fusion;$(SolutionDir)3rdparty\wolfssl\extra\win32;$(SolutionDir)3rdparty\libsdl-org\SDL\include MaxSpeed AL_LIBTYPE_STATIC;MINIUPNP_STATICLIB;HAVE_VULKAN;HAVE_SDL3;ZLIB_CONST;WOLFSSL_USER_SETTINGS;%(PreprocessorDefinitions) AL_LIBTYPE_STATIC;MINIUPNP_STATICLIB;HAVE_VULKAN;HAVE_SDL3;ZLIB_CONST;WOLFSSL_USER_SETTINGS;%(PreprocessorDefinitions) @@ -99,6 +99,8 @@ + + @@ -1070,4 +1072,4 @@ - \ No newline at end of file + diff --git a/rpcs3/rpcs3.vcxproj b/rpcs3/rpcs3.vcxproj index 02a5f7f7e0..76f29ab148 100644 --- a/rpcs3/rpcs3.vcxproj +++ b/rpcs3/rpcs3.vcxproj @@ -199,6 +199,7 @@ + @@ -797,6 +798,7 @@ + diff --git a/rpcs3/rpcs3qt/CMakeLists.txt b/rpcs3/rpcs3qt/CMakeLists.txt index 2cc02f578b..f6ba8c608f 100644 --- a/rpcs3/rpcs3qt/CMakeLists.txt +++ b/rpcs3/rpcs3qt/CMakeLists.txt @@ -22,6 +22,7 @@ add_library(rpcs3_ui STATIC emu_settings.cpp elf_memory_dumping_dialog.cpp emulated_pad_settings_dialog.cpp + emulated_logitech_g27_settings_dialog.cpp fatal_error_dialog.cpp find_dialog.cpp flow_layout.cpp @@ -158,6 +159,7 @@ add_library(rpcs3_ui STATIC ../Input/raw_mouse_config.cpp ../Input/raw_mouse_handler.cpp ../Input/sdl_pad_handler.cpp + ../Input/sdl_instance.cpp ../Input/skateboard_pad_handler.cpp ../Input/xinput_pad_handler.cpp diff --git a/rpcs3/rpcs3qt/emulated_logitech_g27_settings_dialog.cpp b/rpcs3/rpcs3qt/emulated_logitech_g27_settings_dialog.cpp new file mode 100644 index 0000000000..543dc961b1 --- /dev/null +++ b/rpcs3/rpcs3qt/emulated_logitech_g27_settings_dialog.cpp @@ -0,0 +1,902 @@ +#ifdef HAVE_SDL3 + +#include "stdafx.h" + +#include "emulated_logitech_g27_settings_dialog.h" +#include "Emu/Io/LogitechG27.cpp" +#include "Input/sdl_instance.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +LOG_CHANNEL(logitech_g27_cfg_log, "LOGIG27"); + +#define DEFAULT_STATUS " " + +struct joystick_state { + std::vector axes; + std::vector buttons; + std::vector hats; +}; + +class DeviceChoice : public QWidget +{ + +public: + DeviceChoice(QWidget *parent, uint32_t device_type_id, const char *name) + : QWidget(parent) + { + this->device_type_id = device_type_id; + + auto layout = new QHBoxLayout(this); + + QLabel *label = new QLabel(this); + label->setText(QString(name)); + layout->addWidget(label); + + display_box = new QLabel(this); + display_box->setTextFormat(Qt::RichText); + display_box->setWordWrap(true); + display_box->setFrameStyle(QFrame::Box); + display_box->setMinimumWidth(100); + layout->addWidget(display_box); + + update_display(); + } + + uint32_t get_device_type_id() + { + return device_type_id; + } + + void set_device_type_id(uint32_t device_type_id) + { + this->device_type_id = device_type_id; + update_display(); + } + +private: + uint32_t device_type_id; + QLabel *display_box; + void update_display(){ + char text_buf[32]; + sprintf(text_buf, "%04x:%04x", device_type_id >> 16, device_type_id & 0xFFFF); + display_box->setText(QString(text_buf)); + } +}; + +class Mapping : public QGroupBox +{ + +public: + Mapping(QWidget *parent, emulated_logitech_g27_settings_dialog *dialog, DeviceChoice *ffb_device, DeviceChoice *led_device, sdl_mapping mapping, bool is_axis, const char *name, bool flip_axis_display) + : QGroupBox(parent) + { + this->setting_dialog = dialog; + this->ffb_device = ffb_device; + this->led_device = led_device; + this->mapping = mapping; + this->is_axis = is_axis; + this->name = std::string(name); + this->mapping_in_progress = false; + this->flip_axis_display = flip_axis_display; + + QVBoxLayout *layout = new QVBoxLayout(this); + setLayout(layout); + + QWidget *horizontal_container = new QWidget(this); + QHBoxLayout *horizontal_layout = new QHBoxLayout(horizontal_container); + horizontal_container->setLayout(horizontal_layout); + + layout->addWidget(horizontal_container); + + QLabel *label = new QLabel(horizontal_container); + label->setText(QString(name)); + + display_box = new QLabel(horizontal_container); + display_box->setTextFormat(Qt::RichText); + display_box->setWordWrap(true); + display_box->setFrameStyle(QFrame::Box); + display_box->setMinimumWidth(150); + + ffb_set_button = new QPushButton(QString("FFB"), horizontal_container); + led_set_button = new QPushButton(QString("LED"), horizontal_container); + map_button = new QPushButton(QString("MAP"), horizontal_container); + unmap_button = new QPushButton(QString("UNMAP"), horizontal_container); + reverse_checkbox = new QCheckBox(QString("Reverse"), horizontal_container); + + if (!this->is_axis) + { + axis_status = nullptr; + button_status = new QCheckBox(QString("Pressed"), horizontal_container); + button_status->setDisabled(true); + } + else + { + button_status = nullptr; + axis_status = new QSlider(Qt::Horizontal, this); + axis_status->setDisabled(true); + axis_status->setMinimum(-0x8000); + axis_status->setMaximum(0x7FFF); + axis_status->setValue(-0x8000); + } + + update_display(); + + horizontal_layout->addWidget(label); + horizontal_layout->addWidget(display_box); + if (!this->is_axis) + horizontal_layout->addWidget(button_status); + horizontal_layout->addWidget(ffb_set_button); + horizontal_layout->addWidget(led_set_button); + horizontal_layout->addWidget(map_button); + horizontal_layout->addWidget(unmap_button); + horizontal_layout->addWidget(reverse_checkbox); + + if (this->is_axis) + layout->addWidget(axis_status); + + connect(ffb_set_button, &QPushButton::clicked, this, [this]() + { + this->ffb_device->set_device_type_id(this->mapping.device_type_id); + }); + + connect(led_set_button, &QPushButton::clicked, this, [this]() + { + this->led_device->set_device_type_id(this->mapping.device_type_id); + }); + + connect(map_button, &QPushButton::clicked, this, [this](){ + this->mapping_in_progress = true; + this->timeout_msec = 5500; + this->setting_dialog->disable(); + this->last_joystick_states = this->setting_dialog->get_joystick_states(); + }); + + connect(unmap_button, &QPushButton::clicked, this, [this](){ + this->mapping.device_type_id = 0; + update_display(); + }); + + connect(reverse_checkbox, &QCheckBox::clicked, this, [this](){ + this->mapping.reverse = this->reverse_checkbox->isChecked(); + }); + + tick_timer = new QTimer(this); + connect(tick_timer, &QTimer::timeout, this, [this]() + { + if (this->mapping_in_progress) + { + char text_buf[128]; + + int timeout_sec = this->timeout_msec / 1000; + + const std::map &new_joystick_states = this->setting_dialog->get_joystick_states(); + + sprintf(text_buf, "Input %s for %s, timeout in %d %s", this->is_axis ? "axis" : "button/hat", this->name.c_str(), timeout_sec, timeout_sec >= 2 ? "seconds" : "second"); + this->setting_dialog->set_state_text(text_buf); + + for (auto new_joystick_state = new_joystick_states.begin();new_joystick_state != new_joystick_states.end();new_joystick_state++) + { + auto last_joystick_state = this->last_joystick_states.find(new_joystick_state->first); + if (last_joystick_state == this->last_joystick_states.end()) + { + continue; + } + + if (this->is_axis) + { + const static int16_t axis_change_threshold = 0x7FFF / 5; + if (last_joystick_state->second.axes.size() != new_joystick_state->second.axes.size()) + { + logitech_g27_cfg_log.error("during input state change diff, number of axes on %04x:%04x changed", new_joystick_state->first >> 16, new_joystick_state->first & 0xFFFF); + continue; + } + for (std::vector::size_type i = 0;i < new_joystick_state->second.axes.size();i++) + { + int32_t diff = std::abs(last_joystick_state->second.axes[i] - new_joystick_state->second.axes[i]); + if (diff > axis_change_threshold) + { + this->mapping_in_progress = false; + this->setting_dialog->set_state_text(DEFAULT_STATUS); + this->setting_dialog->enable(); + this->mapping.device_type_id = new_joystick_state->first; + this->mapping.type = MAPPING_AXIS; + this->mapping.id = i; + this->mapping.hat = HAT_NONE; + break; + } + } + } + else + { + if (last_joystick_state->second.buttons.size() != new_joystick_state->second.buttons.size()) + { + logitech_g27_cfg_log.error("during input state change diff, number of buttons on %04x:%04x changed", new_joystick_state->first >> 16, new_joystick_state->first & 0xFFFF); + continue; + } + if (last_joystick_state->second.hats.size() != new_joystick_state->second.hats.size()) + { + logitech_g27_cfg_log.error("during input state change diff, number of hats on %04x:%04x changed", new_joystick_state->first >> 16, new_joystick_state->first & 0xFFFF); + continue; + } + for (std::vector::size_type i = 0;i < new_joystick_state->second.buttons.size();i++) + { + if (last_joystick_state->second.buttons[i] != new_joystick_state->second.buttons[i]) + { + this->mapping_in_progress = false; + this->setting_dialog->set_state_text(DEFAULT_STATUS); + this->setting_dialog->enable(); + this->mapping.device_type_id = new_joystick_state->first; + this->mapping.type = MAPPING_BUTTON; + this->mapping.id = i; + this->mapping.hat = HAT_NONE; + break; + } + } + for (std::vector::size_type i = 0;i < new_joystick_state->second.hats.size();i++) + { + if (last_joystick_state->second.hats[i] != new_joystick_state->second.hats[i] && new_joystick_state->second.hats[i] != HAT_NONE) + { + this->mapping_in_progress = false; + this->setting_dialog->set_state_text(DEFAULT_STATUS); + this->setting_dialog->enable(); + this->mapping.device_type_id = new_joystick_state->first; + this->mapping.type = MAPPING_HAT; + this->mapping.id = i; + this->mapping.hat = new_joystick_state->second.hats[i]; + break; + } + } + } + } + + this->timeout_msec = this->timeout_msec - 25; + if (this->timeout_msec <= 0) + { + this->mapping_in_progress = false; + this->setting_dialog->set_state_text(DEFAULT_STATUS); + this->setting_dialog->enable(); + } + } + + update_display(); + }); + tick_timer->start(25); + } + + void disable() + { + ffb_set_button->setDisabled(true); + led_set_button->setDisabled(true); + map_button->setDisabled(true); + unmap_button->setDisabled(true); + reverse_checkbox->setDisabled(true); + } + + void enable() + { + ffb_set_button->setEnabled(true); + led_set_button->setEnabled(true); + map_button->setEnabled(true); + unmap_button->setEnabled(true); + reverse_checkbox->setEnabled(true); + } + + void set_mapping(const sdl_mapping &mapping) + { + this->mapping = mapping; + update_display(); + } + + const sdl_mapping &get_mapping() + { + return mapping; + } + +private: + sdl_mapping mapping; + bool is_axis; + std::string name; + + DeviceChoice *ffb_device; + DeviceChoice *led_device; + QLabel *display_box; + QPushButton *ffb_set_button; + QPushButton *led_set_button; + QPushButton *map_button; + QPushButton *unmap_button; + QCheckBox *reverse_checkbox; + + bool mapping_in_progress; + int timeout_msec = 5000; + QTimer *tick_timer; + std::map last_joystick_states; + + QCheckBox *button_status; + QSlider *axis_status; + bool flip_axis_display; + + emulated_logitech_g27_settings_dialog *setting_dialog; + + void update_display(){ + char text_buf[64]; + const char *type_string = nullptr; + switch(mapping.type) + { + case MAPPING_BUTTON: + type_string = "button"; + break; + case MAPPING_HAT: + type_string = "hat"; + break; + case MAPPING_AXIS: + type_string = "axis"; + break; + } + const char *hat_string = nullptr; + switch(mapping.hat) + { + case HAT_UP: + hat_string = "up"; + break; + case HAT_DOWN: + hat_string = "down"; + break; + case HAT_LEFT: + hat_string = "left"; + break; + case HAT_RIGHT: + hat_string = "right"; + break; + case HAT_NONE: + hat_string = ""; + break; + } + sprintf(text_buf, "%04x:%04x, %s %u %s", mapping.device_type_id >> 16, mapping.device_type_id & 0xFFFF, type_string, mapping.id, hat_string); + display_box->setText(QString(text_buf)); + + reverse_checkbox->setChecked(mapping.reverse); + + if (button_status) + button_status->setChecked(mapping.reverse); + + if (axis_status) + { + int32_t axis_value = (-0x8000); + if (mapping.reverse) + axis_value = axis_value * (-1); + if (flip_axis_display) + axis_value = axis_value * (-1); + if (axis_value > 0x7FFF) + axis_value = 0x7FFF; + if (axis_value < (-0x8000)) + axis_value = (-0x8000); + axis_status->setValue(axis_value); + } + + const std::map &joystick_states = setting_dialog->get_joystick_states(); + auto joystick_state = joystick_states.find(mapping.device_type_id); + + if (joystick_state != joystick_states.end()) + { + switch(mapping.type) + { + case MAPPING_BUTTON: + { + if (joystick_state->second.buttons.size() <= mapping.id) + break; + bool value = joystick_state->second.buttons[mapping.id]; + if (mapping.reverse) + value = !value; + button_status->setChecked(value); + break; + } + case MAPPING_HAT: + { + if (joystick_state->second.hats.size() <= mapping.id) + break; + bool value = joystick_state->second.hats[mapping.id] == mapping.hat; + if (mapping.reverse) + value = !value; + button_status->setChecked(value); + break; + } + case MAPPING_AXIS: + { + if (joystick_state->second.axes.size() <= mapping.id) + break; + int32_t value = joystick_state->second.axes[mapping.id]; + if (mapping.reverse) + value = value * (-1); + if (flip_axis_display) + value = value * (-1); + if (value > 0x7FFF) + value = 0x7FFF; + else if (value < (-0x8000)) + value = (-0x8000); + axis_status->setValue(value); + break; + } + } + } + } +}; + +void emulated_logitech_g27_settings_dialog::save_ui_state_to_config() +{ + #define SAVE_MAPPING(name) \ + { \ + const sdl_mapping &m = name->get_mapping(); \ + g_cfg_logitech_g27.name##_device_type_id.set(m.device_type_id); \ + g_cfg_logitech_g27.name##_type.set(m.type); \ + g_cfg_logitech_g27.name##_id.set(m.id); \ + g_cfg_logitech_g27.name##_hat.set(m.hat); \ + g_cfg_logitech_g27.name##_reverse.set(m.reverse); \ + } + + SAVE_MAPPING(steering); + SAVE_MAPPING(throttle); + SAVE_MAPPING(brake); + SAVE_MAPPING(clutch); + SAVE_MAPPING(shift_up); + SAVE_MAPPING(shift_down); + + SAVE_MAPPING(up); + SAVE_MAPPING(down); + SAVE_MAPPING(left); + SAVE_MAPPING(right); + + SAVE_MAPPING(triangle); + SAVE_MAPPING(cross); + SAVE_MAPPING(square); + SAVE_MAPPING(circle); + + SAVE_MAPPING(l2); + SAVE_MAPPING(l3); + SAVE_MAPPING(r2); + SAVE_MAPPING(r3); + + SAVE_MAPPING(plus); + SAVE_MAPPING(minus); + + SAVE_MAPPING(dial_clockwise); + SAVE_MAPPING(dial_anticlockwise); + + SAVE_MAPPING(select); + SAVE_MAPPING(pause); + + SAVE_MAPPING(shifter_1); + SAVE_MAPPING(shifter_2); + SAVE_MAPPING(shifter_3); + SAVE_MAPPING(shifter_4); + SAVE_MAPPING(shifter_5); + SAVE_MAPPING(shifter_6); + SAVE_MAPPING(shifter_r); + + #undef SAVE_MAPPING + + g_cfg_logitech_g27.ffb_device_type_id.set(ffb_device->get_device_type_id()); + g_cfg_logitech_g27.led_device_type_id.set(led_device->get_device_type_id()); + + g_cfg_logitech_g27.enabled.set(enabled->isChecked()); + g_cfg_logitech_g27.reverse_effects.set(reverse_effects->isChecked()); +} + +void emulated_logitech_g27_settings_dialog::load_ui_state_from_config() +{ + #define LOAD_MAPPING(name) \ + { \ + sdl_mapping m = { \ + .device_type_id = static_cast(g_cfg_logitech_g27.name##_device_type_id.get()), \ + .type = static_cast(g_cfg_logitech_g27.name##_type.get()), \ + .id = static_cast(g_cfg_logitech_g27.name##_id.get()), \ + .hat = static_cast(g_cfg_logitech_g27.name##_hat.get()), \ + .reverse = g_cfg_logitech_g27.name##_reverse.get(), \ + .positive_axis = false \ + }; \ + name->set_mapping(m); \ + } + + LOAD_MAPPING(steering); + LOAD_MAPPING(throttle); + LOAD_MAPPING(brake); + LOAD_MAPPING(clutch); + LOAD_MAPPING(shift_up); + LOAD_MAPPING(shift_down); + + LOAD_MAPPING(up); + LOAD_MAPPING(down); + LOAD_MAPPING(left); + LOAD_MAPPING(right); + + LOAD_MAPPING(triangle); + LOAD_MAPPING(cross); + LOAD_MAPPING(square); + LOAD_MAPPING(circle); + + LOAD_MAPPING(l2); + LOAD_MAPPING(l3); + LOAD_MAPPING(r2); + LOAD_MAPPING(r3); + + LOAD_MAPPING(plus); + LOAD_MAPPING(minus); + + LOAD_MAPPING(dial_clockwise); + LOAD_MAPPING(dial_anticlockwise); + + LOAD_MAPPING(select); + LOAD_MAPPING(pause); + + LOAD_MAPPING(shifter_1); + LOAD_MAPPING(shifter_2); + LOAD_MAPPING(shifter_3); + LOAD_MAPPING(shifter_4); + LOAD_MAPPING(shifter_5); + LOAD_MAPPING(shifter_6); + LOAD_MAPPING(shifter_r); + + #undef LOAD_MAPPING + + ffb_device->set_device_type_id(static_cast(g_cfg_logitech_g27.ffb_device_type_id.get())); + led_device->set_device_type_id(static_cast(g_cfg_logitech_g27.led_device_type_id.get())); + + enabled->setChecked(g_cfg_logitech_g27.enabled.get()); + reverse_effects->setChecked(g_cfg_logitech_g27.reverse_effects.get()); +} + +emulated_logitech_g27_settings_dialog::emulated_logitech_g27_settings_dialog(QWidget* parent) + : QDialog(parent) +{ + setObjectName("emulated_logitech_g27_settings_dialog"); + setWindowTitle(tr("Configure Emulated Logitech G27 Wheel")); + setAttribute(Qt::WA_DeleteOnClose); + setAttribute(Qt::WA_StyledBackground); + setModal(true); + + QVBoxLayout* v_layout = new QVBoxLayout(this); + + QDialogButtonBox* buttons = new QDialogButtonBox(this); + buttons->setStandardButtons(QDialogButtonBox::Apply | QDialogButtonBox::Cancel | QDialogButtonBox::Save | QDialogButtonBox::RestoreDefaults); + + g_cfg_logitech_g27.load(); + + connect(buttons, &QDialogButtonBox::clicked, this, [this, buttons](QAbstractButton* button) + { + if (button == buttons->button(QDialogButtonBox::Apply)) + { + save_ui_state_to_config(); + g_cfg_logitech_g27.save(); + load_ui_state_from_config(); + } + else if (button == buttons->button(QDialogButtonBox::Save)) + { + save_ui_state_to_config(); + g_cfg_logitech_g27.save(); + accept(); + } + else if (button == buttons->button(QDialogButtonBox::RestoreDefaults)) + { + if (QMessageBox::question(this, tr("Confirm Reset"), tr("Reset all?")) != QMessageBox::Yes) + return; + g_cfg_logitech_g27.fill_defaults(); + load_ui_state_from_config(); + g_cfg_logitech_g27.save(); + } + else if (button == buttons->button(QDialogButtonBox::Cancel)) + { + reject(); + } + }); + + QLabel *warning = new QLabel(QString("Warning: Force feedback output were meant for Logitech G27, on stronger wheels please adjust force strength accordingly in your wheel software."), this); + warning->setStyleSheet("color: red;"); + v_layout->addWidget(warning); + + enabled = new QCheckBox(QString("Enabled (requires game restart)"), this); + enabled->setChecked(g_cfg_logitech_g27.enabled.get()); + v_layout->addWidget(enabled); + + reverse_effects = new QCheckBox(QString("Reverse force feedback effects"), this); + reverse_effects->setChecked(g_cfg_logitech_g27.reverse_effects.get()); + v_layout->addWidget(reverse_effects); + + state_text = new QLabel(QString(DEFAULT_STATUS), this); + v_layout->addWidget(state_text); + + ffb_device = new DeviceChoice(this, g_cfg_logitech_g27.ffb_device_type_id.get(), "Force Feedback Device"); + led_device = new DeviceChoice(this, g_cfg_logitech_g27.led_device_type_id.get(), "LED Device"); + + mapping_scroll_area = new QScrollArea(this); + QWidget *mapping_widget = new QWidget(mapping_scroll_area); + QVBoxLayout* mapping_layout = new QVBoxLayout(mapping_widget); + mapping_widget->setLayout(mapping_layout); + mapping_scroll_area->setWidget(mapping_widget); + mapping_scroll_area->setWidgetResizable(true); + mapping_scroll_area->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); + mapping_scroll_area->setMinimumHeight(400); + mapping_scroll_area->setMinimumWidth(800); + + v_layout->addWidget(mapping_scroll_area); + + #define ADD_MAPPING_SETTING(name, is_axis, display_name, flip_axis_display) \ + { \ + sdl_mapping m = { \ + .device_type_id = static_cast(g_cfg_logitech_g27.name##_device_type_id.get()), \ + .type = static_cast(g_cfg_logitech_g27.name##_type.get()), \ + .id = static_cast(g_cfg_logitech_g27.name##_id.get()), \ + .hat = static_cast(g_cfg_logitech_g27.name##_hat.get()), \ + .reverse = g_cfg_logitech_g27.name##_reverse.get(), \ + .positive_axis = false \ + }; \ + name = new Mapping(mapping_widget, this, ffb_device, led_device, m, is_axis, display_name, flip_axis_display); \ + mapping_layout->addWidget(name); \ + } + + QLabel *axis_label = new QLabel(QString("Axes:"), mapping_widget); + mapping_layout->addWidget(axis_label); + + ADD_MAPPING_SETTING(steering, true, "Steering", false); + ADD_MAPPING_SETTING(throttle, true, "Throttle", true); + ADD_MAPPING_SETTING(brake, true, "Brake", true); + ADD_MAPPING_SETTING(clutch, true, "Clutch", true); + + QLabel *button_label = new QLabel(QString("Buttons:"), mapping_widget); + mapping_layout->addWidget(button_label); + + ADD_MAPPING_SETTING(shift_up, false, "Shift up", false); + ADD_MAPPING_SETTING(shift_down, false, "Shift down", false); + + ADD_MAPPING_SETTING(up, false, "Up", false); + ADD_MAPPING_SETTING(down, false, "Down", false); + ADD_MAPPING_SETTING(left, false, "Left", false); + ADD_MAPPING_SETTING(right, false, "Right", false); + + ADD_MAPPING_SETTING(triangle, false, "Triangle", false); + ADD_MAPPING_SETTING(cross, false, "Cross", false); + ADD_MAPPING_SETTING(square, false, "Square", false); + ADD_MAPPING_SETTING(circle, false, "Circle", false); + + ADD_MAPPING_SETTING(l2, false, "L2", false); + ADD_MAPPING_SETTING(l3, false, "L3", false); + ADD_MAPPING_SETTING(r2, false, "R2", false); + ADD_MAPPING_SETTING(r3, false, "R3", false); + + ADD_MAPPING_SETTING(plus, false, "L4", false); + ADD_MAPPING_SETTING(minus, false, "L5", false); + + ADD_MAPPING_SETTING(dial_clockwise, false, "R4", false); + ADD_MAPPING_SETTING(dial_anticlockwise, false, "R5", false); + + ADD_MAPPING_SETTING(select, false, "Select", false); + ADD_MAPPING_SETTING(pause, false, "Start", false); + + ADD_MAPPING_SETTING(shifter_1, false, "Gear 1", false); + ADD_MAPPING_SETTING(shifter_2, false, "Gear 2", false); + ADD_MAPPING_SETTING(shifter_3, false, "Gear 3", false); + ADD_MAPPING_SETTING(shifter_4, false, "Gear 4", false); + ADD_MAPPING_SETTING(shifter_5, false, "Gear 5", false); + ADD_MAPPING_SETTING(shifter_6, false, "Gear 6", false); + ADD_MAPPING_SETTING(shifter_r, false, "Gear R", false); + + #undef ADD_MAPPING_SETTING + + v_layout->addWidget(ffb_device); + v_layout->addWidget(led_device); + + v_layout->addWidget(buttons); + setLayout(v_layout); + + sdl_initialized = sdl_instance::get_instance().initialize(); + + if (sdl_initialized) + get_joystick_states(); +} + +emulated_logitech_g27_settings_dialog::~emulated_logitech_g27_settings_dialog() +{ + for (auto joystick_handle = joystick_handles.begin();joystick_handle != joystick_handles.end();joystick_handle++) + { + SDL_CloseJoystick(*joystick_handle); + } +} + +static inline hat_component get_sdl_hat_component(uint8_t sdl_hat) +{ + if (sdl_hat & SDL_HAT_UP) + { + return HAT_UP; + } + + if (sdl_hat & SDL_HAT_DOWN) + { + return HAT_DOWN; + } + + if (sdl_hat & SDL_HAT_LEFT) + { + return HAT_LEFT; + } + + if (sdl_hat & SDL_HAT_RIGHT) + { + return HAT_RIGHT; + } + + return HAT_NONE; +} + +const std::map &emulated_logitech_g27_settings_dialog::get_joystick_states() +{ + if (!sdl_initialized) + { + return last_joystick_states; + } + + uint64_t now = SDL_GetTicks(); + + if (SDL_GetTicks() - last_joystick_states_update < 25) + { + return last_joystick_states; + } + + last_joystick_states_update = now; + + std::map new_joystick_states; + + sdl_instance::get_instance().pump_events(); + + int joystick_count; + SDL_JoystickID *joystick_ids = SDL_GetJoysticks(&joystick_count); + + std::vector new_joystick_handles; + + if (joystick_ids != nullptr) + { + for (int i = 0;i < joystick_count;i++) + { + SDL_Joystick *cur_joystick = SDL_OpenJoystick(joystick_ids[i]); + if (cur_joystick == nullptr) + { + continue; + } + new_joystick_handles.push_back(cur_joystick); + + uint32_t device_type_id = (SDL_GetJoystickVendor(cur_joystick) << 16) | SDL_GetJoystickProduct(cur_joystick); + + auto cur_state = new_joystick_states.find(device_type_id); + if (cur_state == new_joystick_states.end()) + { + joystick_state s; + int num_axes = SDL_GetNumJoystickAxes(cur_joystick); + int num_buttons = SDL_GetNumJoystickButtons(cur_joystick); + int num_hats = SDL_GetNumJoystickHats(cur_joystick); + for (int j = 0;j < num_axes;j++) + { + s.axes.push_back(SDL_GetJoystickAxis(cur_joystick, j)); + } + for (int j = 0;j < num_buttons;j++) + { + s.buttons.push_back(SDL_GetJoystickButton(cur_joystick, j)); + } + for (int j = 0;j < num_hats;j++) + { + uint8_t sdl_hat = SDL_GetJoystickHat(cur_joystick, j); + s.hats.push_back(get_sdl_hat_component(sdl_hat)); + } + new_joystick_states[device_type_id] = s; + } + else + { + for (std::vector::size_type j = 0;j < cur_state->second.axes.size();j++) + { + cur_state->second.axes[j] = (cur_state->second.axes[j] + SDL_GetJoystickAxis(cur_joystick, j)) / 2; + } + for (std::vector::size_type j = 0;j < cur_state->second.buttons.size();j++) + { + cur_state->second.buttons[j] = cur_state->second.buttons[j] || SDL_GetJoystickButton(cur_joystick, j); + } + for (std::vector::size_type j = 0;j < cur_state->second.hats.size();j++) + { + if (cur_state->second.hats[j] != HAT_NONE) + continue; + uint8_t sdl_hat = SDL_GetJoystickHat(cur_joystick, j); + cur_state->second.hats[j] = get_sdl_hat_component(sdl_hat); + } + } + } + } + + for (auto joystick_handle = joystick_handles.begin(); joystick_handle != joystick_handles.end();joystick_handle++) + { + SDL_CloseJoystick(*joystick_handle); + } + + joystick_handles = new_joystick_handles; + last_joystick_states = new_joystick_states; + + return last_joystick_states; +} + +void emulated_logitech_g27_settings_dialog::set_state_text(const char *text) +{ + state_text->setText(QString(text)); +} + +void emulated_logitech_g27_settings_dialog::toggle_state(bool enable) +{ + + int slider_position = mapping_scroll_area->verticalScrollBar()->sliderPosition(); + + #define TOGGLE_STATE(name) \ + { \ + if (enable) \ + name->enable(); \ + else \ + name->disable(); \ + } + TOGGLE_STATE(steering); + TOGGLE_STATE(throttle); + TOGGLE_STATE(brake); + TOGGLE_STATE(clutch); + TOGGLE_STATE(shift_up); + TOGGLE_STATE(shift_down); + + TOGGLE_STATE(up); + TOGGLE_STATE(down); + TOGGLE_STATE(left); + TOGGLE_STATE(right); + + TOGGLE_STATE(triangle); + TOGGLE_STATE(cross); + TOGGLE_STATE(square); + TOGGLE_STATE(circle); + + TOGGLE_STATE(l2); + TOGGLE_STATE(l3); + TOGGLE_STATE(r2); + TOGGLE_STATE(r3); + + TOGGLE_STATE(plus); + TOGGLE_STATE(minus); + + TOGGLE_STATE(dial_clockwise); + TOGGLE_STATE(dial_anticlockwise); + + TOGGLE_STATE(select); + TOGGLE_STATE(pause); + + TOGGLE_STATE(shifter_1); + TOGGLE_STATE(shifter_2); + TOGGLE_STATE(shifter_3); + TOGGLE_STATE(shifter_4); + TOGGLE_STATE(shifter_5); + TOGGLE_STATE(shifter_6); + TOGGLE_STATE(shifter_r); + + #undef TOGGLE_STATE + + enabled->setEnabled(enable); + reverse_effects->setEnabled(enable); + + mapping_scroll_area->verticalScrollBar()->setEnabled(enable); + mapping_scroll_area->verticalScrollBar()->setSliderPosition(slider_position); +} + +void emulated_logitech_g27_settings_dialog::enable(){ + toggle_state(true); +} + +void emulated_logitech_g27_settings_dialog::disable(){ + toggle_state(false); +} + +#endif diff --git a/rpcs3/rpcs3qt/emulated_logitech_g27_settings_dialog.h b/rpcs3/rpcs3qt/emulated_logitech_g27_settings_dialog.h new file mode 100644 index 0000000000..d76a5e6a0c --- /dev/null +++ b/rpcs3/rpcs3qt/emulated_logitech_g27_settings_dialog.h @@ -0,0 +1,87 @@ +#pragma once + +#include +#include +#include +#include + +#include +#include +#include + +#include + +struct joystick_state; + +class Mapping; +class DeviceChoice; + +class emulated_logitech_g27_settings_dialog : public QDialog +{ +public: + emulated_logitech_g27_settings_dialog(QWidget* parent = nullptr); + ~emulated_logitech_g27_settings_dialog(); + void disable(); + void enable(); + void set_state_text(const char *); + const std::map &get_joystick_states(); +private: + void toggle_state(bool enable); + void load_ui_state_from_config(); + void save_ui_state_to_config(); + + std::map last_joystick_states; + std::vector joystick_handles; + uint64_t last_joystick_states_update = 0; + bool sdl_initialized = false; + + // ui elements + QLabel *state_text; + + QCheckBox *enabled; + QCheckBox *reverse_effects; + + Mapping *steering; + Mapping *throttle; + Mapping *brake; + Mapping *clutch; + Mapping *shift_up; + Mapping *shift_down; + + Mapping *up; + Mapping *down; + Mapping *left; + Mapping *right; + + Mapping *triangle; + Mapping *cross; + Mapping *square; + Mapping *circle; + + Mapping *l2; + Mapping *l3; + Mapping *r2; + Mapping *r3; + + Mapping *plus; + Mapping *minus; + + Mapping *dial_clockwise; + Mapping *dial_anticlockwise; + + Mapping *select; + Mapping *pause; + + Mapping *shifter_1; + Mapping *shifter_2; + Mapping *shifter_3; + Mapping *shifter_4; + Mapping *shifter_5; + Mapping *shifter_6; + Mapping *shifter_r; + + DeviceChoice *ffb_device; + DeviceChoice *led_device; + + QScrollArea *mapping_scroll_area; +}; diff --git a/rpcs3/rpcs3qt/main_window.cpp b/rpcs3/rpcs3qt/main_window.cpp index 5fd5bac9c6..b4e3865736 100644 --- a/rpcs3/rpcs3qt/main_window.cpp +++ b/rpcs3/rpcs3qt/main_window.cpp @@ -38,6 +38,7 @@ #include "shortcut_dialog.h" #include "system_cmd_dialog.h" #include "emulated_pad_settings_dialog.h" +#include "emulated_logitech_g27_settings_dialog.h" #include "basic_mouse_settings_dialog.h" #include "vfs_tool_dialog.h" #include "welcome_dialog.h" @@ -2902,6 +2903,16 @@ void main_window::CreateConnects() dlg->show(); }); +#ifndef HAVE_SDL3 + ui->confLogitechG27Act->setVisible(false); +#else + connect(ui->confLogitechG27Act, &QAction::triggered, this, [this] + { + emulated_logitech_g27_settings_dialog *dlg = new emulated_logitech_g27_settings_dialog(this); + dlg->show(); + }); +#endif + connect(ui->actionBasic_Mouse, &QAction::triggered, this, [this] { basic_mouse_settings_dialog* dlg = new basic_mouse_settings_dialog(this); diff --git a/rpcs3/rpcs3qt/main_window.ui b/rpcs3/rpcs3qt/main_window.ui index 845874d00b..91654cbb67 100644 --- a/rpcs3/rpcs3qt/main_window.ui +++ b/rpcs3/rpcs3qt/main_window.ui @@ -257,6 +257,7 @@ + @@ -1366,6 +1367,11 @@ Top Shot Fearmaster + + + Logitech G27 Wheel + + Basic Mouse