The-Homebrew-Cloud/controller_patcher
2
0
Fork 0
mirror of https://github.com/Maschell/controller_patcher.git synced 2024-11-25 13:36:53 +01:00
Code Issues Packages Projects Releases Wiki Activity

Fix types

Browse Source
This commit is contained in:
Maschell 2018-06-20 15:07:15 +02:00
parent 9aab796735
commit ac2ec82779
21 changed files with 733 additions and 733 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
include/controller_patcher/ControllerPatcher.hpp
View File

@ -48,7 +48,7 @@ public:
devoptabs! If no configuration should be loaded from the SD Card, set this parameter to NULL. devoptabs! If no configuration should be loaded from the SD Card, set this parameter to NULL.
**/ **/
static bool Init(const char * pathToConfig); static BOOL Init(const char * pathToConfig);
/** /**
\brief De-Initialises the controller_patcher \brief De-Initialises the controller_patcher
@ -84,7 +84,7 @@ public:
@return When the functions failed result < 0 is returned. If the result is == 0 the function was successful. @return When the functions failed result < 0 is returned. If the result is == 0 the function was successful.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR setProControllerDataFromHID(void * data,s32 chan,s32 mode = PRO_CONTROLLER_MODE_KPADDATA); static CONTROLLER_PATCHER_RESULT_OR_ERROR setProControllerDataFromHID(void * data,int32_t chan,int32_t mode = PRO_CONTROLLER_MODE_KPADDATA);
/** /**
@ -151,14 +151,14 @@ public:
@return The first active mapping slot for the given controller type will be returned. If the controller type is not set active, -1 will be returned. @return The first active mapping slot for the given controller type will be returned. If the controller type is not set active, -1 will be returned.
**/ **/
static s32 getActiveMappingSlot(UController_Type type); static int32_t getActiveMappingSlot(UController_Type type);
/** /**
@param type: The type of the controller. @param type: The type of the controller.
@param mapping_slot: information about the added controller. @param mapping_slot: information about the added controller.
@return When the functions failed result < 0 is returned. Otherwise a pointer to a ControllerMappingPADInfo is returned. @return When the functions failed result < 0 is returned. Otherwise a pointer to a ControllerMappingPADInfo is returned.
**/ **/
static ControllerMappingPADInfo * getControllerMappingInfo(UController_Type type,s32 mapping_slot); static ControllerMappingPADInfo * getControllerMappingInfo(UController_Type type,int32_t mapping_slot);
/** /**
Checks if a emulated controller is connected for the given controller type / mapping slot. Checks if a emulated controller is connected for the given controller type / mapping slot.
@ -168,7 +168,7 @@ public:
@return @return
**/ **/
static bool isControllerConnectedAndActive(UController_Type type,s32 mapping_slot = 0); static BOOL isControllerConnectedAndActive(UController_Type type,int32_t mapping_slot = 0);
/** /**
Search for a connected mouse and returns a pointer to it's data. Search for a connected mouse and returns a pointer to it's data.
@ -184,7 +184,7 @@ public:
@return When the functions failed result < 0 is returned. If the result is == 0 the function was successful. @return When the functions failed result < 0 is returned. If the result is == 0 the function was successful.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR setRumble(UController_Type type,u32 status); static CONTROLLER_PATCHER_RESULT_OR_ERROR setRumble(UController_Type type,uint32_t status);
/** /**
Reads the input of all connected HID devices. Each attached controller will write his date into given array until it's full. Reads the input of all connected HID devices. Each attached controller will write his date into given array until it's full.
@ -194,7 +194,7 @@ public:
@return When the functions failed result < 0 is returned. If the result is == 0 the function was successful. If the result is > 0 the number of stored sets in the array is returned. @return When the functions failed result < 0 is returned. If the result is == 0 the function was successful. If the result is > 0 the number of stored sets in the array is returned.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR gettingInputAllDevices(InputData * output,s32 array_size); static CONTROLLER_PATCHER_RESULT_OR_ERROR gettingInputAllDevices(InputData * output,int32_t array_size);
/** /**
Remaps the buttons in the given \p VPADStatus pointer. InitButtonMapping() needs to be called before calling this. The information about the remapping is stored in the config_controller array. Remaps the buttons in the given \p VPADStatus pointer. InitButtonMapping() needs to be called before calling this. The information about the remapping is stored in the config_controller array.
@ -204,7 +204,7 @@ public:
@return When the functions failed result < 0 is returned. If the result is == 0 the function was successful. @return When the functions failed result < 0 is returned. If the result is == 0 the function was successful.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR buttonRemapping(VPADStatus * buffer, s32 buffer_count); static CONTROLLER_PATCHER_RESULT_OR_ERROR buttonRemapping(VPADStatus * buffer, int32_t buffer_count);
/** /**
Prints the current pressed down buttons of the given \p VPADStatus pointer. Uses the utils/logger.c UDP logger.. Prints the current pressed down buttons of the given \p VPADStatus pointer. Uses the utils/logger.c UDP logger..
@ -215,35 +215,35 @@ public:
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR printVPADButtons(VPADStatus * buffer); static CONTROLLER_PATCHER_RESULT_OR_ERROR printVPADButtons(VPADStatus * buffer);
static std::string getIdentifierByVIDPID(u16 vid,u16 pid); static std::string getIdentifierByVIDPID(uint16_t vid,uint16_t pid);
static void destroyConfigHelper(); static void destroyConfigHelper();
static CONTROLLER_PATCHER_RESULT_OR_ERROR doSamplingForDeviceSlot(u16 device_slot); static CONTROLLER_PATCHER_RESULT_OR_ERROR doSamplingForDeviceSlot(uint16_t device_slot);
static CONTROLLER_PATCHER_RESULT_OR_ERROR setRumbleActivated(bool value); static CONTROLLER_PATCHER_RESULT_OR_ERROR setRumbleActivated(BOOL value);
static CONTROLLER_PATCHER_RESULT_OR_ERROR setNetworkControllerActivated(bool value); static CONTROLLER_PATCHER_RESULT_OR_ERROR setNetworkControllerActivated(BOOL value);
static bool isRumbleActivated(); static BOOL isRumbleActivated();
static bool isButtonRemappingDone(); static BOOL isButtonRemappingDone();
static bool isKeyboardConnected(); static BOOL isKeyboardConnected();
static bool areControllersConnected(); static BOOL areControllersConnected();
static CONTROLLER_PATCHER_RESULT_OR_ERROR sampleKeyboardData(); static CONTROLLER_PATCHER_RESULT_OR_ERROR sampleKeyboardData();
static CONTROLLER_PATCHER_RESULT_OR_ERROR resetCallbackData(); static CONTROLLER_PATCHER_RESULT_OR_ERROR resetCallbackData();
static CONTROLLER_PATCHER_RESULT_OR_ERROR setKPADConnectedCallback(s32 chan, WPADConnectCallback callback); static CONTROLLER_PATCHER_RESULT_OR_ERROR setKPADConnectedCallback(int32_t chan, WPADConnectCallback callback);
static CONTROLLER_PATCHER_RESULT_OR_ERROR setKPADExtensionCallback(s32 chan, WPADConnectCallback callback); static CONTROLLER_PATCHER_RESULT_OR_ERROR setKPADExtensionCallback(int32_t chan, WPADConnectCallback callback);
static CONTROLLER_PATCHER_RESULT_OR_ERROR setWPADConnectCallback(s32 chan, WPADConnectCallback callback); static CONTROLLER_PATCHER_RESULT_OR_ERROR setWPADConnectCallback(int32_t chan, WPADConnectCallback callback);
static CONTROLLER_PATCHER_RESULT_OR_ERROR handleCallbackData(bool button_pressed); static CONTROLLER_PATCHER_RESULT_OR_ERROR handleCallbackData(BOOL button_pressed);
static CONTROLLER_PATCHER_RESULT_OR_ERROR handleCallbackDataInternal(WPADChan chan); static CONTROLLER_PATCHER_RESULT_OR_ERROR handleCallbackDataInternal(WPADChan chan);
}; };

64
include/controller_patcher/ControllerPatcherDefs.h
View File

@ -218,35 +218,35 @@ enum Controller_Patcher_DPAD_Settings {
* @brief Stores data if the Slot the device is using in gHID_Devices * @brief Stores data if the Slot the device is using in gHID_Devices
*/ */
typedef struct _HIDSlotData { typedef struct _HIDSlotData {
u16 deviceslot; /**< deviceslot number */ uint16_t deviceslot; /**< deviceslot number */
u32 hidmask; /**< Used HID-Mask */ uint32_t hidmask; /**< Used HID-Mask */
} HIDSlotData; } HIDSlotData;
/** /**
* @brief Struct where the data for the callback funtion is stored * @brief Struct where the data for the callback funtion is stored
*/ */
typedef struct _my_cb_user { typedef struct _my_cb_user {
u8 *buf; /**< pointer the buffer that is used */ uint8_t *buf; /**< pointer the buffer that is used */
u32 transfersize; /**< number of transfered data */ uint32_t transfersize; /**< number of transfered data */
u32 handle; /**< HID handle */ uint32_t handle; /**< HID handle */
HIDSlotData slotdata; /**< Information about the deviceslot and hidmask */ HIDSlotData slotdata; /**< Information about the deviceslot and hidmask */
u32 pads_per_device; /**< Number of maximum pads of this device */ uint32_t pads_per_device; /**< Number of maximum pads of this device */
u8 pad_slot; /**< number of the pad that will be used */ uint8_t pad_slot; /**< number of the pad that will be used */
u8 rumblestatus[HID_MAX_PADS_COUNT]; /**< Current status of the device rumble */ uint8_t rumblestatus[HID_MAX_PADS_COUNT]; /**< Current status of the device rumble */
u8 forceRumbleInTicks[HID_MAX_PADS_COUNT]; uint8_t forceRumbleInTicks[HID_MAX_PADS_COUNT];
} my_cb_user; } my_cb_user;
/** /**
* @brief Stores data for the mouse * @brief Stores data for the mouse
*/ */
typedef struct _HID_Mouse_Data { typedef struct _HID_Mouse_Data {
u8 left_click; /**< Is 1 when the left mouse button is pressed */ uint8_t left_click; /**< Is 1 when the left mouse button is pressed */
u8 right_click; /**< Is 1 when the right mouse button is pressed */ uint8_t right_click; /**< Is 1 when the right mouse button is pressed */
s16 X; /**< X position of the cursor */ int16_t X; /**< X position of the cursor */
s16 Y; /**< Y position of the cursor */ int16_t Y; /**< Y position of the cursor */
s16 deltaX; /**< difference of the X value since the last call */ int16_t deltaX; /**< difference of the X value since the last call */
s16 deltaY; /**< difference of the Y value since the last call */ int16_t deltaY; /**< difference of the Y value since the last call */
u8 valuedChanged; /**< Is 1 when the value has changed */ uint8_t valuedChanged; /**< Is 1 when the value has changed */
} HID_Mouse_Data; } HID_Mouse_Data;
/** /**
@ -261,14 +261,14 @@ enum DEVICE_TYPE {
* @brief Stores all data of the HID Device for accessing * @brief Stores all data of the HID Device for accessing
*/ */
typedef struct _HID_Data { typedef struct _HID_Data {
u32 handle; /**< The HID-handle this device is using */ uint32_t handle; /**< The HID-handle this device is using */
u8 rumbleActive; /**< 1 when rumble is active */ uint8_t rumbleActive; /**< 1 when rumble is active */
u32 last_buttons; /**< The last pressed buttons, based on VPAD_BUTTON_XXX data */ uint32_t last_buttons; /**< The last pressed buttons, based on VPAD_BUTTON_XXX data */
union { union {
struct { struct {
u8 cur_hid_data[HID_MAX_DATA_LENGTH_PER_PAD]; /**< Array where the current controller data is stored */ uint8_t cur_hid_data[HID_MAX_DATA_LENGTH_PER_PAD]; /**< Array where the current controller data is stored */
u8 last_hid_data[HID_MAX_DATA_LENGTH_PER_PAD]; /**< Array where the last controller data is stored */ uint8_t last_hid_data[HID_MAX_DATA_LENGTH_PER_PAD]; /**< Array where the last controller data is stored */
} controller; /**< Used when the device in a controller. Using u8 array where the raw data of the controller is placed. */ } controller; /**< Used when the device in a controller. Using uint8_t array where the raw data of the controller is placed. */
struct { struct {
HID_Mouse_Data cur_mouse_data; /**< Struct where the current mouse data is stored */ HID_Mouse_Data cur_mouse_data; /**< Struct where the current mouse data is stored */
HID_Mouse_Data last_mouse_data; /**< Struct where the last mouse data is stored */ HID_Mouse_Data last_mouse_data; /**< Struct where the last mouse data is stored */
@ -292,8 +292,8 @@ typedef struct _HID_DEVICE_DATA {
* @brief Stores a VID and PID * @brief Stores a VID and PID
*/ */
typedef struct _DeviceVIDPIDInfo { typedef struct _DeviceVIDPIDInfo {
u16 vid; /**< Vendor ID of this device */ uint16_t vid; /**< Vendor ID of this device */
u16 pid; /**< Product ID of this device */ uint16_t pid; /**< Product ID of this device */
} DeviceVIDPIDInfo; } DeviceVIDPIDInfo;
/** /**
@ -302,7 +302,7 @@ typedef struct _DeviceVIDPIDInfo {
typedef struct _DeviceInfo { typedef struct _DeviceInfo {
HIDSlotData slotdata; /**< The slot used by this device */ HIDSlotData slotdata; /**< The slot used by this device */
DeviceVIDPIDInfo vidpid; /**< The VID/PID of the device */ DeviceVIDPIDInfo vidpid; /**< The VID/PID of the device */
u8 pad_count; /**< Number of maximum pads this device can have*/ uint8_t pad_count; /**< Number of maximum pads this device can have*/
} DeviceInfo; } DeviceInfo;
/** /**
@ -319,10 +319,10 @@ enum ControllerMapping_Type_Defines {
* @brief Infos of a mapped controller * @brief Infos of a mapped controller
*/ */
typedef struct _ControllerMappingPADInfo { typedef struct _ControllerMappingPADInfo {
u8 active; /**< Set to one if mapped */ uint8_t active; /**< Set to one if mapped */
ControllerMapping_Type_Defines type; /**< Type of the controller mapping */ ControllerMapping_Type_Defines type; /**< Type of the controller mapping */
DeviceVIDPIDInfo vidpid; /**< The VID/PID of the device */ DeviceVIDPIDInfo vidpid; /**< The VID/PID of the device */
u8 pad; /**< Stores which pad it mapped */ uint8_t pad; /**< Stores which pad it mapped */
} ControllerMappingPADInfo; } ControllerMappingPADInfo;
/** /**
@ -330,8 +330,8 @@ typedef struct _ControllerMappingPADInfo {
*/ */
typedef struct _ControllerMappingPAD { typedef struct _ControllerMappingPAD {
ControllerMappingPADInfo pad_infos[HID_MAX_DEVICES_PER_SLOT]; //lets limit this to HID_MAX_DEVICES_PER_SLOT. ControllerMappingPADInfo pad_infos[HID_MAX_DEVICES_PER_SLOT]; //lets limit this to HID_MAX_DEVICES_PER_SLOT.
u8 useAll; uint8_t useAll;
u8 rumble; /**< Set when the controller should rumble */ uint8_t rumble; /**< Set when the controller should rumble */
} ControllerMappingPAD; } ControllerMappingPAD;
/** /**
@ -346,9 +346,9 @@ typedef struct _ControllerMapping {
* @brief Pressed/Released/Down Button data. * @brief Pressed/Released/Down Button data.
*/ */
typedef struct _InputButtonData { typedef struct _InputButtonData {
u32 btn_h; /**< Buttons beeing hold */ uint32_t btn_h; /**< Buttons beeing hold */
u32 btn_d; /**< Buttons that started pressing */ uint32_t btn_d; /**< Buttons that started pressing */
u32 btn_r; /**< Buttons that were button released */ uint32_t btn_r; /**< Buttons that were button released */
} InputButtonData; } InputButtonData;
/** /**

8
source/ConfigReader.cpp
View File

@ -31,13 +31,13 @@
#include <utils/logger.h> #include <utils/logger.h>
s32 ConfigReader::numberValidFiles = 0; int32_t ConfigReader::numberValidFiles = 0;
ConfigReader *ConfigReader::instance = NULL; ConfigReader *ConfigReader::instance = NULL;
ConfigReader::ConfigReader() { ConfigReader::ConfigReader() {
} }
bool ConfigReader::ReadConfigs(std::string path) { BOOL ConfigReader::ReadConfigs(std::string path) {
std::vector<std::string> fileList = ScanFolder(path); std::vector<std::string> fileList = ScanFolder(path);
if(fileList.size() == 1 && fileList[0].compare("ERROR") == 0) { if(fileList.size() == 1 && fileList[0].compare("ERROR") == 0) {
return false; return false;
@ -70,7 +70,7 @@ std::vector<std::string> ConfigReader::ScanFolder(std::string path) {
return config_files; return config_files;
} }
while ((dirent = readdir(dirHandle)) != 0) { while ((dirent = readdir(dirHandle)) != 0) {
bool isDir = dirent->d_type & DT_DIR; BOOL isDir = dirent->d_type & DT_DIR;
const char *filename = dirent->d_name; const char *filename = dirent->d_name;
if(strcmp(filename,".") == 0 || strcmp(filename,"..") == 0) { if(strcmp(filename,".") == 0 || strcmp(filename,"..") == 0) {
@ -102,7 +102,7 @@ void ConfigReader::processFileList(std::vector<std::string> path) {
std::string ConfigReader::loadFileToString(std::string path) { std::string ConfigReader::loadFileToString(std::string path) {
std::string strBuffer = ""; std::string strBuffer = "";
u8 * buffer = NULL; uint8_t * buffer = NULL;
if(FSUtils::LoadFileToMem(path.c_str(),&buffer,NULL) > 0) { if(FSUtils::LoadFileToMem(path.c_str(),&buffer,NULL) > 0) {
strBuffer = std::string((char *)buffer); strBuffer = std::string((char *)buffer);
strBuffer = StringTools::removeCharFromString(strBuffer,'\r'); strBuffer = StringTools::removeCharFromString(strBuffer,'\r');

8
source/ConfigReader.hpp
View File

@ -40,22 +40,22 @@ class ConfigReader{
} }
} }
static s32 getNumberOfLoadedFiles(){ static int32_t getNumberOfLoadedFiles(){
return ConfigReader::numberValidFiles; return ConfigReader::numberValidFiles;
} }
static void increaseNumberOfLoadedFiles(){ static void increaseNumberOfLoadedFiles(){
ConfigReader::numberValidFiles++; ConfigReader::numberValidFiles++;
} }
bool ReadConfigs(std::string path); BOOL ReadConfigs(std::string path);
static s32 numberValidFiles; static int32_t numberValidFiles;
//!Constructor //!Constructor
ConfigReader(); ConfigReader();
//!Destructor //!Destructor
~ConfigReader(); ~ConfigReader();
s32 InitSDCard(); int32_t InitSDCard();
static ConfigReader *instance; static ConfigReader *instance;

628
source/ControllerPatcher.cpp
View File

@ -27,12 +27,12 @@
#include <utils/logger.h> #include <utils/logger.h>
// This stores the holded buttons for the gamepad after the button remapping. // This stores the holded buttons for the gamepad after the button remapping.
static u32 buttonRemapping_lastButtonsHold = 0; static uint32_t buttonRemapping_lastButtonsHold = 0;
/* To set the controls of an Pro Controler, we first get the result for an Gamepad and convert them later. This way both can share the same functions.*/ /* To set the controls of an Pro Controler, we first get the result for an Gamepad and convert them later. This way both can share the same functions.*/
// This arrays stores the last hold buttons of the Pro Controllers. One u32 for each channel of the controllers // This arrays stores the last hold buttons of the Pro Controllers. One uint32_t for each channel of the controllers
static u32 last_button_hold[4] = {0,0,0,0}; static uint32_t last_button_hold[4] = {0,0,0,0};
// This arrays stores the VPADStatus that will be used to get the HID Data for the Pro Controllers. One for each channel. // This arrays stores the VPADStatus that will be used to get the HID Data for the Pro Controllers. One for each channel.
static VPADStatus myVPADBuffer[4]; static VPADStatus myVPADBuffer[4];
@ -118,8 +118,8 @@ void ControllerPatcher::ResetConfig() {
} }
ControllerPatcherUtils::getNextSlotData(&slotdata); ControllerPatcherUtils::getNextSlotData(&slotdata);
u32 keyboard_slot = slotdata.deviceslot; uint32_t keyboard_slot = slotdata.deviceslot;
u32 keyboard_hid = slotdata.hidmask; uint32_t keyboard_hid = slotdata.hidmask;
gHID_LIST_KEYBOARD = keyboard_hid; gHID_LIST_KEYBOARD = keyboard_hid;
gHID_SLOT_KEYBOARD = keyboard_slot; gHID_SLOT_KEYBOARD = keyboard_slot;
@ -128,8 +128,8 @@ void ControllerPatcher::ResetConfig() {
} }
ControllerPatcherUtils::getNextSlotData(&slotdata); ControllerPatcherUtils::getNextSlotData(&slotdata);
u32 gc_slot = slotdata.deviceslot; uint32_t gc_slot = slotdata.deviceslot;
u32 gc_hid = slotdata.hidmask; uint32_t gc_hid = slotdata.hidmask;
gHID_LIST_GC = gc_hid; gHID_LIST_GC = gc_hid;
gHID_SLOT_GC = gc_slot; gHID_SLOT_GC = gc_slot;
if(HID_DEBUG) { if(HID_DEBUG) {
@ -137,30 +137,30 @@ void ControllerPatcher::ResetConfig() {
} }
ControllerPatcherUtils::getNextSlotData(&slotdata); ControllerPatcherUtils::getNextSlotData(&slotdata);
u32 ds3_slot = slotdata.deviceslot; uint32_t ds3_slot = slotdata.deviceslot;
u32 ds3_hid = slotdata.hidmask; uint32_t ds3_hid = slotdata.hidmask;
gHID_LIST_DS3 = ds3_hid; gHID_LIST_DS3 = ds3_hid;
if(HID_DEBUG) { if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("Register DS3-Config. HID-Mask %s Device-Slot: %d\n",StringTools::byte_to_binary(gHID_LIST_DS3),ds3_slot); DEBUG_FUNCTION_LINE("Register DS3-Config. HID-Mask %s Device-Slot: %d\n",StringTools::byte_to_binary(gHID_LIST_DS3),ds3_slot);
} }
ControllerPatcherUtils::getNextSlotData(&slotdata); ControllerPatcherUtils::getNextSlotData(&slotdata);
u32 ds4_slot = slotdata.deviceslot; uint32_t ds4_slot = slotdata.deviceslot;
u32 ds4_hid = slotdata.hidmask; uint32_t ds4_hid = slotdata.hidmask;
gHID_LIST_DS4 = ds4_hid; gHID_LIST_DS4 = ds4_hid;
if(HID_DEBUG) { if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("Register DS4-Config. HID-Mask %s Device-Slot: %d\n",StringTools::byte_to_binary(ds4_hid),ds4_slot); DEBUG_FUNCTION_LINE("Register DS4-Config. HID-Mask %s Device-Slot: %d\n",StringTools::byte_to_binary(ds4_hid),ds4_slot);
} }
ControllerPatcherUtils::getNextSlotData(&slotdata); ControllerPatcherUtils::getNextSlotData(&slotdata);
u32 xinput_slot = slotdata.deviceslot; uint32_t xinput_slot = slotdata.deviceslot;
u32 xinput_hid = slotdata.hidmask; uint32_t xinput_hid = slotdata.hidmask;
if(HID_DEBUG) { if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("Register XInput-Config. HID-Mask %s Device-Slot: %d\n",StringTools::byte_to_binary(xinput_hid),xinput_slot); DEBUG_FUNCTION_LINE("Register XInput-Config. HID-Mask %s Device-Slot: %d\n",StringTools::byte_to_binary(xinput_hid),xinput_slot);
} }
ControllerPatcherUtils::getNextSlotData(&slotdata); ControllerPatcherUtils::getNextSlotData(&slotdata);
u32 switch_pro_slot = slotdata.deviceslot; uint32_t switch_pro_slot = slotdata.deviceslot;
gHID_LIST_SWITCH_PRO = slotdata.hidmask; gHID_LIST_SWITCH_PRO = slotdata.hidmask;
DEBUG_FUNCTION_LINE("Register Switch-Pro-Config. HID-Mask %s Device-Slot: %d\n",StringTools::byte_to_binary(gHID_LIST_SWITCH_PRO),switch_pro_slot); DEBUG_FUNCTION_LINE("Register Switch-Pro-Config. HID-Mask %s Device-Slot: %d\n",StringTools::byte_to_binary(gHID_LIST_SWITCH_PRO),switch_pro_slot);
@ -177,325 +177,325 @@ void ControllerPatcher::ResetConfig() {
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//! GamePad //! GamePad
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gGamePadSlot][CONTRPS_VID], 0xAF,0xFE); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gGamePadSlot][CONTRPS_VID], 0xAF,0xFE);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gGamePadSlot][CONTRPS_PID], 0xAA,0xAA); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gGamePadSlot][CONTRPS_PID], 0xAA,0xAA);
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//! Switch Pro Controller //! Switch Pro Controller
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VID], (HID_SWITCH_PRO_VID>>8)&0xFF, HID_SWITCH_PRO_VID&0xFF); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VID], (HID_SWITCH_PRO_VID>>8)&0xFF, HID_SWITCH_PRO_VID&0xFF);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_PID], (HID_SWITCH_PRO_PID>>8)&0xFF, HID_SWITCH_PRO_PID&0xFF); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_PID], (HID_SWITCH_PRO_PID>>8)&0xFF, HID_SWITCH_PRO_PID&0xFF);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_A], HID_SWITCH_PRO_BT_BUTTON_A[0], HID_SWITCH_PRO_BT_BUTTON_A[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_A], HID_SWITCH_PRO_BT_BUTTON_A[0], HID_SWITCH_PRO_BT_BUTTON_A[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_B], HID_SWITCH_PRO_BT_BUTTON_B[0], HID_SWITCH_PRO_BT_BUTTON_B[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_B], HID_SWITCH_PRO_BT_BUTTON_B[0], HID_SWITCH_PRO_BT_BUTTON_B[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_X], HID_SWITCH_PRO_BT_BUTTON_X[0], HID_SWITCH_PRO_BT_BUTTON_X[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_X], HID_SWITCH_PRO_BT_BUTTON_X[0], HID_SWITCH_PRO_BT_BUTTON_X[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_Y], HID_SWITCH_PRO_BT_BUTTON_Y[0], HID_SWITCH_PRO_BT_BUTTON_Y[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_Y], HID_SWITCH_PRO_BT_BUTTON_Y[0], HID_SWITCH_PRO_BT_BUTTON_Y[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_DPAD_MODE], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_BUTTON_DPAD_TYPE[CONTRDPAD_MODE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_DPAD_MODE], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_BUTTON_DPAD_TYPE[CONTRDPAD_MODE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_DPAD_MASK], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_BUTTON_DPAD_TYPE[CONTRDPAD_MASK]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_DPAD_MASK], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_BUTTON_DPAD_TYPE[CONTRDPAD_MASK]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_DPAD_N], HID_SWITCH_PRO_BT_BUTTON_DPAD_N[0], HID_SWITCH_PRO_BT_BUTTON_DPAD_N[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_DPAD_N], HID_SWITCH_PRO_BT_BUTTON_DPAD_N[0], HID_SWITCH_PRO_BT_BUTTON_DPAD_N[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_DPAD_NE], HID_SWITCH_PRO_BT_BUTTON_DPAD_NE[0], HID_SWITCH_PRO_BT_BUTTON_DPAD_NE[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_DPAD_NE], HID_SWITCH_PRO_BT_BUTTON_DPAD_NE[0], HID_SWITCH_PRO_BT_BUTTON_DPAD_NE[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_DPAD_E], HID_SWITCH_PRO_BT_BUTTON_DPAD_E[0], HID_SWITCH_PRO_BT_BUTTON_DPAD_E[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_DPAD_E], HID_SWITCH_PRO_BT_BUTTON_DPAD_E[0], HID_SWITCH_PRO_BT_BUTTON_DPAD_E[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_DPAD_SE], HID_SWITCH_PRO_BT_BUTTON_DPAD_SE[0], HID_SWITCH_PRO_BT_BUTTON_DPAD_SE[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_DPAD_SE], HID_SWITCH_PRO_BT_BUTTON_DPAD_SE[0], HID_SWITCH_PRO_BT_BUTTON_DPAD_SE[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_DPAD_S], HID_SWITCH_PRO_BT_BUTTON_DPAD_S[0], HID_SWITCH_PRO_BT_BUTTON_DPAD_S[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_DPAD_S], HID_SWITCH_PRO_BT_BUTTON_DPAD_S[0], HID_SWITCH_PRO_BT_BUTTON_DPAD_S[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_DPAD_SW], HID_SWITCH_PRO_BT_BUTTON_DPAD_SW[0], HID_SWITCH_PRO_BT_BUTTON_DPAD_SW[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_DPAD_SW], HID_SWITCH_PRO_BT_BUTTON_DPAD_SW[0], HID_SWITCH_PRO_BT_BUTTON_DPAD_SW[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_DPAD_W], HID_SWITCH_PRO_BT_BUTTON_DPAD_W[0], HID_SWITCH_PRO_BT_BUTTON_DPAD_W[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_DPAD_W], HID_SWITCH_PRO_BT_BUTTON_DPAD_W[0], HID_SWITCH_PRO_BT_BUTTON_DPAD_W[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_DPAD_NW], HID_SWITCH_PRO_BT_BUTTON_DPAD_NW[0], HID_SWITCH_PRO_BT_BUTTON_DPAD_NW[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_DPAD_NW], HID_SWITCH_PRO_BT_BUTTON_DPAD_NW[0], HID_SWITCH_PRO_BT_BUTTON_DPAD_NW[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_DPAD_NEUTRAL], HID_SWITCH_PRO_BT_BUTTON_DPAD_NEUTRAL[0], HID_SWITCH_PRO_BT_BUTTON_DPAD_NEUTRAL[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_DPAD_NEUTRAL], HID_SWITCH_PRO_BT_BUTTON_DPAD_NEUTRAL[0], HID_SWITCH_PRO_BT_BUTTON_DPAD_NEUTRAL[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_PLUS], HID_SWITCH_PRO_BT_BUTTON_PLUS[0], HID_SWITCH_PRO_BT_BUTTON_PLUS[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_PLUS], HID_SWITCH_PRO_BT_BUTTON_PLUS[0], HID_SWITCH_PRO_BT_BUTTON_PLUS[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_MINUS], HID_SWITCH_PRO_BT_BUTTON_MINUS[0], HID_SWITCH_PRO_BT_BUTTON_MINUS[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_MINUS], HID_SWITCH_PRO_BT_BUTTON_MINUS[0], HID_SWITCH_PRO_BT_BUTTON_MINUS[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_L], HID_SWITCH_PRO_BT_BUTTON_L[0], HID_SWITCH_PRO_BT_BUTTON_L[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_L], HID_SWITCH_PRO_BT_BUTTON_L[0], HID_SWITCH_PRO_BT_BUTTON_L[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_R], HID_SWITCH_PRO_BT_BUTTON_R[0], HID_SWITCH_PRO_BT_BUTTON_R[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_R], HID_SWITCH_PRO_BT_BUTTON_R[0], HID_SWITCH_PRO_BT_BUTTON_R[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_ZL], HID_SWITCH_PRO_BT_BUTTON_ZL[0], HID_SWITCH_PRO_BT_BUTTON_ZL[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_ZL], HID_SWITCH_PRO_BT_BUTTON_ZL[0], HID_SWITCH_PRO_BT_BUTTON_ZL[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_ZR], HID_SWITCH_PRO_BT_BUTTON_ZR[0], HID_SWITCH_PRO_BT_BUTTON_ZR[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_ZR], HID_SWITCH_PRO_BT_BUTTON_ZR[0], HID_SWITCH_PRO_BT_BUTTON_ZR[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_STICK_L], HID_SWITCH_PRO_BT_BUTTON_STICK_L[0], HID_SWITCH_PRO_BT_BUTTON_STICK_L[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_STICK_L], HID_SWITCH_PRO_BT_BUTTON_STICK_L[0], HID_SWITCH_PRO_BT_BUTTON_STICK_L[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_STICK_R], HID_SWITCH_PRO_BT_BUTTON_STICK_R[0], HID_SWITCH_PRO_BT_BUTTON_STICK_R[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_STICK_R], HID_SWITCH_PRO_BT_BUTTON_STICK_R[0], HID_SWITCH_PRO_BT_BUTTON_STICK_R[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_HOME], HID_SWITCH_PRO_BT_BUTTON_HOME[0], HID_SWITCH_PRO_BT_BUTTON_HOME[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_HOME], HID_SWITCH_PRO_BT_BUTTON_HOME[0], HID_SWITCH_PRO_BT_BUTTON_HOME[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_PAD_COUNT], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_PAD_COUNT); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_PAD_COUNT], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_PAD_COUNT);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_L_STICK_X], HID_SWITCH_PRO_BT_STICK_L_X[STICK_CONF_BYTE], HID_SWITCH_PRO_BT_STICK_L_X[STICK_CONF_DEFAULT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_L_STICK_X], HID_SWITCH_PRO_BT_STICK_L_X[STICK_CONF_BYTE], HID_SWITCH_PRO_BT_STICK_L_X[STICK_CONF_DEFAULT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_STICK_L_X[STICK_CONF_DEADZONE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_STICK_L_X[STICK_CONF_DEADZONE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_MINMAX], HID_SWITCH_PRO_BT_STICK_L_X[STICK_CONF_MIN], HID_SWITCH_PRO_BT_STICK_L_X[STICK_CONF_MAX]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_MINMAX], HID_SWITCH_PRO_BT_STICK_L_X[STICK_CONF_MIN], HID_SWITCH_PRO_BT_STICK_L_X[STICK_CONF_MAX]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_STICK_L_X[STICK_CONF_INVERT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_STICK_L_X[STICK_CONF_INVERT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y], HID_SWITCH_PRO_BT_STICK_L_Y[STICK_CONF_BYTE], HID_SWITCH_PRO_BT_STICK_L_Y[STICK_CONF_DEFAULT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y], HID_SWITCH_PRO_BT_STICK_L_Y[STICK_CONF_BYTE], HID_SWITCH_PRO_BT_STICK_L_Y[STICK_CONF_DEFAULT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_STICK_L_Y[STICK_CONF_DEADZONE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_STICK_L_Y[STICK_CONF_DEADZONE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_MINMAX], HID_SWITCH_PRO_BT_STICK_L_Y[STICK_CONF_MIN], HID_SWITCH_PRO_BT_STICK_L_Y[STICK_CONF_MAX]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_MINMAX], HID_SWITCH_PRO_BT_STICK_L_Y[STICK_CONF_MIN], HID_SWITCH_PRO_BT_STICK_L_Y[STICK_CONF_MAX]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_STICK_L_Y[STICK_CONF_INVERT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_STICK_L_Y[STICK_CONF_INVERT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_R_STICK_X], HID_SWITCH_PRO_BT_STICK_R_X[STICK_CONF_BYTE], HID_SWITCH_PRO_BT_STICK_R_X[STICK_CONF_DEFAULT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_R_STICK_X], HID_SWITCH_PRO_BT_STICK_R_X[STICK_CONF_BYTE], HID_SWITCH_PRO_BT_STICK_R_X[STICK_CONF_DEFAULT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_STICK_R_X[STICK_CONF_DEADZONE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_STICK_R_X[STICK_CONF_DEADZONE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_MINMAX], HID_SWITCH_PRO_BT_STICK_R_X[STICK_CONF_MIN], HID_SWITCH_PRO_BT_STICK_R_X[STICK_CONF_MAX]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_MINMAX], HID_SWITCH_PRO_BT_STICK_R_X[STICK_CONF_MIN], HID_SWITCH_PRO_BT_STICK_R_X[STICK_CONF_MAX]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_STICK_R_X[STICK_CONF_INVERT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_STICK_R_X[STICK_CONF_INVERT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y], HID_SWITCH_PRO_BT_STICK_R_Y[STICK_CONF_BYTE], HID_SWITCH_PRO_BT_STICK_R_Y[STICK_CONF_DEFAULT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y], HID_SWITCH_PRO_BT_STICK_R_Y[STICK_CONF_BYTE], HID_SWITCH_PRO_BT_STICK_R_Y[STICK_CONF_DEFAULT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_STICK_R_Y[STICK_CONF_DEADZONE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_STICK_R_Y[STICK_CONF_DEADZONE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_MINMAX], HID_SWITCH_PRO_BT_STICK_R_Y[STICK_CONF_MIN], HID_SWITCH_PRO_BT_STICK_R_Y[STICK_CONF_MAX]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_MINMAX], HID_SWITCH_PRO_BT_STICK_R_Y[STICK_CONF_MIN], HID_SWITCH_PRO_BT_STICK_R_Y[STICK_CONF_MAX]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_STICK_R_Y[STICK_CONF_INVERT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[switch_pro_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_SWITCH_PRO_BT_STICK_R_Y[STICK_CONF_INVERT]);
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//! Mouse //! Mouse
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gMouseSlot][CONTRPS_VID], (HID_MOUSE_VID>>8)&0xFF, HID_MOUSE_VID&0xFF); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gMouseSlot][CONTRPS_VID], (HID_MOUSE_VID>>8)&0xFF, HID_MOUSE_VID&0xFF);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gMouseSlot][CONTRPS_PID], (HID_MOUSE_PID>>8)&0xFF, HID_MOUSE_PID&0xFF); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gMouseSlot][CONTRPS_PID], (HID_MOUSE_PID>>8)&0xFF, HID_MOUSE_PID&0xFF);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gMouseSlot][CONTRPS_VPAD_BUTTON_LEFT], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_ZR); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gMouseSlot][CONTRPS_VPAD_BUTTON_LEFT], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_ZR);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gMouseSlot][CONTRPS_VPAD_BUTTON_RIGHT], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_R); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gMouseSlot][CONTRPS_VPAD_BUTTON_RIGHT], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_R);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gMouseSlot][CONTRPS_PAD_COUNT], CONTROLLER_PATCHER_VALUE_SET, HID_MOUSE_PAD_COUNT); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gMouseSlot][CONTRPS_PAD_COUNT], CONTROLLER_PATCHER_VALUE_SET, HID_MOUSE_PAD_COUNT);
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//! Keyboard //! Keyboard
//!--------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VID], (HID_KEYBOARD_VID>>8)&0xFF, HID_KEYBOARD_VID&0xFF); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VID], (HID_KEYBOARD_VID>>8)&0xFF, HID_KEYBOARD_VID&0xFF);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_PID], (HID_KEYBOARD_PID>>8)&0xFF, HID_KEYBOARD_PID&0xFF); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_PID], (HID_KEYBOARD_PID>>8)&0xFF, HID_KEYBOARD_PID&0xFF);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_A], 0x00, HID_KEYBOARD_BUTTON_E); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_A], 0x00, HID_KEYBOARD_BUTTON_E);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_B], 0x00, HID_KEYBOARD_BUTTON_Q); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_B], 0x00, HID_KEYBOARD_BUTTON_Q);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_X], 0x00, HID_KEYBOARD_BUTTON_SPACEBAR); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_X], 0x00, HID_KEYBOARD_BUTTON_SPACEBAR);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_Y], 0x00, HID_KEYBOARD_BUTTON_R); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_Y], 0x00, HID_KEYBOARD_BUTTON_R);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_DPAD_MODE], CONTROLLER_PATCHER_VALUE_SET,CONTRPDM_Normal); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_DPAD_MODE], CONTROLLER_PATCHER_VALUE_SET,CONTRPDM_Normal);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_LEFT], 0x00, HID_KEYBOARD_BUTTON_LEFT); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_LEFT], 0x00, HID_KEYBOARD_BUTTON_LEFT);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_RIGHT], 0x00, HID_KEYBOARD_BUTTON_RIGHT); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_RIGHT], 0x00, HID_KEYBOARD_BUTTON_RIGHT);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_DOWN], 0x00, HID_KEYBOARD_BUTTON_DOWN); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_DOWN], 0x00, HID_KEYBOARD_BUTTON_DOWN);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_UP], 0x00, HID_KEYBOARD_BUTTON_UP); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_UP], 0x00, HID_KEYBOARD_BUTTON_UP);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_PLUS], 0x00, HID_KEYBOARD_BUTTON_RETURN); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_PLUS], 0x00, HID_KEYBOARD_BUTTON_RETURN);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_MINUS], 0x00, HID_KEYBOARD_KEYPAD_BUTTON_MINUS); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_MINUS], 0x00, HID_KEYBOARD_KEYPAD_BUTTON_MINUS);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_L], 0x00, HID_KEYBOARD_BUTTON_V); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_L], 0x00, HID_KEYBOARD_BUTTON_V);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_R], 0x00, HID_KEYBOARD_BUTTON_B); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_R], 0x00, HID_KEYBOARD_BUTTON_B);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_ZL], 0x00, HID_KEYBOARD_BUTTON_SHIFT); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_ZL], 0x00, HID_KEYBOARD_BUTTON_SHIFT);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_ZR], 0x00, HID_KEYBOARD_BUTTON_N); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_ZR], 0x00, HID_KEYBOARD_BUTTON_N);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_STICK_L], 0x00, HID_KEYBOARD_BUTTON_F); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_STICK_L], 0x00, HID_KEYBOARD_BUTTON_F);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_STICK_R], 0x00, HID_KEYBOARD_BUTTON_TAB); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_STICK_R], 0x00, HID_KEYBOARD_BUTTON_TAB);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_L_STICK_UP], 0x00, HID_KEYBOARD_BUTTON_W); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_L_STICK_UP], 0x00, HID_KEYBOARD_BUTTON_W);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_L_STICK_DOWN], 0x00, HID_KEYBOARD_BUTTON_S); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_L_STICK_DOWN], 0x00, HID_KEYBOARD_BUTTON_S);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_L_STICK_LEFT], 0x00, HID_KEYBOARD_BUTTON_A); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_L_STICK_LEFT], 0x00, HID_KEYBOARD_BUTTON_A);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_L_STICK_RIGHT], 0x00, HID_KEYBOARD_BUTTON_D); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_L_STICK_RIGHT], 0x00, HID_KEYBOARD_BUTTON_D);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_R_STICK_UP], 0x00, HID_KEYBOARD_KEYPAD_BUTTON_8); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_R_STICK_UP], 0x00, HID_KEYBOARD_KEYPAD_BUTTON_8);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_R_STICK_DOWN], 0x00, HID_KEYBOARD_KEYPAD_BUTTON_2); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_R_STICK_DOWN], 0x00, HID_KEYBOARD_KEYPAD_BUTTON_2);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_R_STICK_LEFT], 0x00, HID_KEYBOARD_KEYPAD_BUTTON_4); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_R_STICK_LEFT], 0x00, HID_KEYBOARD_KEYPAD_BUTTON_4);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_R_STICK_RIGHT], 0x00, HID_KEYBOARD_KEYPAD_BUTTON_6); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_VPAD_BUTTON_R_STICK_RIGHT], 0x00, HID_KEYBOARD_KEYPAD_BUTTON_6);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_PAD_COUNT], CONTROLLER_PATCHER_VALUE_SET,HID_KEYBOARD_PAD_COUNT); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_KEYBOARD][CONTRPS_PAD_COUNT], CONTROLLER_PATCHER_VALUE_SET,HID_KEYBOARD_PAD_COUNT);
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//! GC-Adapter //! GC-Adapter
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VID], (HID_GC_VID>>8)&0xFF, HID_GC_VID&0xFF); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VID], (HID_GC_VID>>8)&0xFF, HID_GC_VID&0xFF);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_PID], (HID_GC_PID>>8)&0xFF, HID_GC_PID&0xFF); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_PID], (HID_GC_PID>>8)&0xFF, HID_GC_PID&0xFF);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_A], HID_GC_BUTTON_A[0], HID_GC_BUTTON_A[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_A], HID_GC_BUTTON_A[0], HID_GC_BUTTON_A[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_B], HID_GC_BUTTON_B[0], HID_GC_BUTTON_B[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_B], HID_GC_BUTTON_B[0], HID_GC_BUTTON_B[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_X], HID_GC_BUTTON_X[0], HID_GC_BUTTON_X[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_X], HID_GC_BUTTON_X[0], HID_GC_BUTTON_X[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_Y], HID_GC_BUTTON_Y[0], HID_GC_BUTTON_Y[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_Y], HID_GC_BUTTON_Y[0], HID_GC_BUTTON_Y[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_DPAD_MODE], CONTROLLER_PATCHER_VALUE_SET, HID_GC_BUTTON_DPAD_TYPE[CONTRDPAD_MODE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_DPAD_MODE], CONTROLLER_PATCHER_VALUE_SET, HID_GC_BUTTON_DPAD_TYPE[CONTRDPAD_MODE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_DPAD_MASK], CONTROLLER_PATCHER_VALUE_SET, HID_GC_BUTTON_DPAD_TYPE[CONTRDPAD_MASK]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_DPAD_MASK], CONTROLLER_PATCHER_VALUE_SET, HID_GC_BUTTON_DPAD_TYPE[CONTRDPAD_MASK]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_LEFT], HID_GC_BUTTON_LEFT[0], HID_GC_BUTTON_LEFT[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_LEFT], HID_GC_BUTTON_LEFT[0], HID_GC_BUTTON_LEFT[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_RIGHT], HID_GC_BUTTON_RIGHT[0], HID_GC_BUTTON_RIGHT[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_RIGHT], HID_GC_BUTTON_RIGHT[0], HID_GC_BUTTON_RIGHT[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_DOWN], HID_GC_BUTTON_DOWN[0], HID_GC_BUTTON_DOWN[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_DOWN], HID_GC_BUTTON_DOWN[0], HID_GC_BUTTON_DOWN[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_UP], HID_GC_BUTTON_UP[0], HID_GC_BUTTON_UP[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_UP], HID_GC_BUTTON_UP[0], HID_GC_BUTTON_UP[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_MINUS], HID_GC_BUTTON_START[0], HID_GC_BUTTON_START[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_MINUS], HID_GC_BUTTON_START[0], HID_GC_BUTTON_START[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_L], HID_GC_BUTTON_L[0], HID_GC_BUTTON_L[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_L], HID_GC_BUTTON_L[0], HID_GC_BUTTON_L[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_R], HID_GC_BUTTON_R[0], HID_GC_BUTTON_R[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_R], HID_GC_BUTTON_R[0], HID_GC_BUTTON_R[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_PLUS], HID_GC_BUTTON_START[0], HID_GC_BUTTON_START[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_PLUS], HID_GC_BUTTON_START[0], HID_GC_BUTTON_START[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_ZL], HID_GC_BUTTON_L[0], HID_GC_BUTTON_L[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_ZL], HID_GC_BUTTON_L[0], HID_GC_BUTTON_L[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_ZR], HID_GC_BUTTON_R[0], HID_GC_BUTTON_R[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_ZR], HID_GC_BUTTON_R[0], HID_GC_BUTTON_R[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_STICK_L], HID_GC_BUTTON_A[0], HID_GC_BUTTON_A[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_STICK_L], HID_GC_BUTTON_A[0], HID_GC_BUTTON_A[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_STICK_R], HID_GC_BUTTON_B[0], HID_GC_BUTTON_B[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_STICK_R], HID_GC_BUTTON_B[0], HID_GC_BUTTON_B[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE], CONTROLLER_PATCHER_VALUE_SET, CONTROLLER_PATCHER_GC_DOUBLE_USE); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE], CONTROLLER_PATCHER_VALUE_SET, CONTROLLER_PATCHER_GC_DOUBLE_USE);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_ACTIVATOR], HID_GC_BUTTON_Z[0], HID_GC_BUTTON_Z[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_ACTIVATOR], HID_GC_BUTTON_Z[0], HID_GC_BUTTON_Z[1]);
//Buttons that will be ignored when the CONTRPS_DOUBLE_USE_BUTTON_ACTIVATOR is pressed //Buttons that will be ignored when the CONTRPS_DOUBLE_USE_BUTTON_ACTIVATOR is pressed
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_1_PRESSED], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_MINUS); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_1_PRESSED], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_MINUS);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_2_PRESSED], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_L); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_2_PRESSED], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_L);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_3_PRESSED], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_R); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_3_PRESSED], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_R);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_4_PRESSED], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_STICK_L); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_4_PRESSED], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_STICK_L);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_5_PRESSED], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_STICK_R); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_5_PRESSED], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_STICK_R);
//Buttons that will be ignored when the CONTRPS_DOUBLE_USE_BUTTON_ACTIVATOR is released //Buttons that will be ignored when the CONTRPS_DOUBLE_USE_BUTTON_ACTIVATOR is released
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_1_RELEASED], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_PLUS); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_1_RELEASED], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_PLUS);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_2_RELEASED], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_ZL); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_2_RELEASED], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_ZL);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_3_RELEASED], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_ZR); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_3_RELEASED], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_ZR);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_4_RELEASED], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_A); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_4_RELEASED], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_A);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_5_RELEASED], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_B); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_DOUBLE_USE_BUTTON_5_RELEASED], CONTROLLER_PATCHER_VALUE_SET, CONTRPS_VPAD_BUTTON_B);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_PAD_COUNT], CONTROLLER_PATCHER_VALUE_SET, HID_GC_PAD_COUNT); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_PAD_COUNT], CONTROLLER_PATCHER_VALUE_SET, HID_GC_PAD_COUNT);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_L_STICK_X], HID_GC_STICK_L_X[STICK_CONF_BYTE],HID_GC_STICK_L_X[STICK_CONF_DEFAULT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_L_STICK_X], HID_GC_STICK_L_X[STICK_CONF_BYTE],HID_GC_STICK_L_X[STICK_CONF_DEFAULT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_L_STICK_X_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_GC_STICK_L_X[STICK_CONF_DEADZONE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_L_STICK_X_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_GC_STICK_L_X[STICK_CONF_DEADZONE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_L_STICK_X_MINMAX], HID_GC_STICK_L_X[STICK_CONF_MIN], HID_GC_STICK_L_X[STICK_CONF_MAX]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_L_STICK_X_MINMAX], HID_GC_STICK_L_X[STICK_CONF_MIN], HID_GC_STICK_L_X[STICK_CONF_MAX]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_L_STICK_X_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_GC_STICK_L_X[STICK_CONF_INVERT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_L_STICK_X_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_GC_STICK_L_X[STICK_CONF_INVERT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_L_STICK_Y], HID_GC_STICK_L_Y[STICK_CONF_BYTE],HID_GC_STICK_L_Y[STICK_CONF_DEFAULT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_L_STICK_Y], HID_GC_STICK_L_Y[STICK_CONF_BYTE],HID_GC_STICK_L_Y[STICK_CONF_DEFAULT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_L_STICK_Y_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_GC_STICK_L_Y[STICK_CONF_DEADZONE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_L_STICK_Y_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_GC_STICK_L_Y[STICK_CONF_DEADZONE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_L_STICK_Y_MINMAX], HID_GC_STICK_L_Y[STICK_CONF_MIN], HID_GC_STICK_L_Y[STICK_CONF_MAX]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_L_STICK_Y_MINMAX], HID_GC_STICK_L_Y[STICK_CONF_MIN], HID_GC_STICK_L_Y[STICK_CONF_MAX]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_L_STICK_Y_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_GC_STICK_L_Y[STICK_CONF_INVERT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_L_STICK_Y_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_GC_STICK_L_Y[STICK_CONF_INVERT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_R_STICK_X], HID_GC_STICK_R_X[STICK_CONF_BYTE],HID_GC_STICK_R_X[STICK_CONF_DEFAULT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_R_STICK_X], HID_GC_STICK_R_X[STICK_CONF_BYTE],HID_GC_STICK_R_X[STICK_CONF_DEFAULT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_R_STICK_X_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_GC_STICK_R_X[STICK_CONF_DEADZONE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_R_STICK_X_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_GC_STICK_R_X[STICK_CONF_DEADZONE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_R_STICK_X_MINMAX], HID_GC_STICK_R_X[STICK_CONF_MIN], HID_GC_STICK_R_X[STICK_CONF_MAX]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_R_STICK_X_MINMAX], HID_GC_STICK_R_X[STICK_CONF_MIN], HID_GC_STICK_R_X[STICK_CONF_MAX]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_R_STICK_X_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_GC_STICK_R_X[STICK_CONF_INVERT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_R_STICK_X_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_GC_STICK_R_X[STICK_CONF_INVERT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_R_STICK_Y], HID_GC_STICK_R_Y[STICK_CONF_BYTE],HID_GC_STICK_R_Y[STICK_CONF_DEFAULT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_R_STICK_Y], HID_GC_STICK_R_Y[STICK_CONF_BYTE],HID_GC_STICK_R_Y[STICK_CONF_DEFAULT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_R_STICK_Y_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_GC_STICK_R_Y[STICK_CONF_DEADZONE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_R_STICK_Y_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_GC_STICK_R_Y[STICK_CONF_DEADZONE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_R_STICK_Y_MINMAX], HID_GC_STICK_R_Y[STICK_CONF_MIN], HID_GC_STICK_R_Y[STICK_CONF_MAX]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_R_STICK_Y_MINMAX], HID_GC_STICK_R_Y[STICK_CONF_MIN], HID_GC_STICK_R_Y[STICK_CONF_MAX]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_R_STICK_Y_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_GC_STICK_R_Y[STICK_CONF_INVERT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[gHID_SLOT_GC][CONTRPS_VPAD_BUTTON_R_STICK_Y_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_GC_STICK_R_Y[STICK_CONF_INVERT]);
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//! DS3 //! DS3
//!--------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VID], (HID_DS3_VID>>8)&0xFF, HID_DS3_VID&0xFF); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VID], (HID_DS3_VID>>8)&0xFF, HID_DS3_VID&0xFF);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_PID], (HID_DS3_PID>>8)&0xFF, HID_DS3_PID&0xFF); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_PID], (HID_DS3_PID>>8)&0xFF, HID_DS3_PID&0xFF);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_BUF_SIZE], CONTROLLER_PATCHER_VALUE_SET, 128); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_BUF_SIZE], CONTROLLER_PATCHER_VALUE_SET, 128);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_A], HID_DS3_BUTTON_CIRCLE[0], HID_DS3_BUTTON_CIRCLE[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_A], HID_DS3_BUTTON_CIRCLE[0], HID_DS3_BUTTON_CIRCLE[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_B], HID_DS3_BUTTON_CROSS[0], HID_DS3_BUTTON_CROSS[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_B], HID_DS3_BUTTON_CROSS[0], HID_DS3_BUTTON_CROSS[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_X], HID_DS3_BUTTON_TRIANGLE[0], HID_DS3_BUTTON_TRIANGLE[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_X], HID_DS3_BUTTON_TRIANGLE[0], HID_DS3_BUTTON_TRIANGLE[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_Y], HID_DS3_BUTTON_SQUARE[0], HID_DS3_BUTTON_SQUARE[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_Y], HID_DS3_BUTTON_SQUARE[0], HID_DS3_BUTTON_SQUARE[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_DPAD_MODE], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_BUTTON_DPAD_TYPE[CONTRDPAD_MODE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_DPAD_MODE], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_BUTTON_DPAD_TYPE[CONTRDPAD_MODE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_DPAD_MASK], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_BUTTON_DPAD_TYPE[CONTRDPAD_MASK]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_DPAD_MASK], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_BUTTON_DPAD_TYPE[CONTRDPAD_MASK]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_LEFT], HID_DS3_BUTTON_LEFT[0], HID_DS3_BUTTON_LEFT[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_LEFT], HID_DS3_BUTTON_LEFT[0], HID_DS3_BUTTON_LEFT[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_RIGHT], HID_DS3_BUTTON_RIGHT[0], HID_DS3_BUTTON_RIGHT[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_RIGHT], HID_DS3_BUTTON_RIGHT[0], HID_DS3_BUTTON_RIGHT[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_DOWN], HID_DS3_BUTTON_DOWN[0], HID_DS3_BUTTON_DOWN[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_DOWN], HID_DS3_BUTTON_DOWN[0], HID_DS3_BUTTON_DOWN[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_UP], HID_DS3_BUTTON_UP[0], HID_DS3_BUTTON_UP[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_UP], HID_DS3_BUTTON_UP[0], HID_DS3_BUTTON_UP[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_PLUS], HID_DS3_BUTTON_START[0], HID_DS3_BUTTON_START[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_PLUS], HID_DS3_BUTTON_START[0], HID_DS3_BUTTON_START[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_MINUS], HID_DS3_BUTTON_SELECT[0], HID_DS3_BUTTON_SELECT[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_MINUS], HID_DS3_BUTTON_SELECT[0], HID_DS3_BUTTON_SELECT[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_L], HID_DS3_BUTTON_L1[0], HID_DS3_BUTTON_L1[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_L], HID_DS3_BUTTON_L1[0], HID_DS3_BUTTON_L1[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_R], HID_DS3_BUTTON_R1[0], HID_DS3_BUTTON_R1[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_R], HID_DS3_BUTTON_R1[0], HID_DS3_BUTTON_R1[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_ZL], HID_DS3_BUTTON_L2[0], HID_DS3_BUTTON_L2[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_ZL], HID_DS3_BUTTON_L2[0], HID_DS3_BUTTON_L2[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_ZR], HID_DS3_BUTTON_R2[0], HID_DS3_BUTTON_R2[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_ZR], HID_DS3_BUTTON_R2[0], HID_DS3_BUTTON_R2[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_STICK_L], HID_DS3_BUTTON_L3[0], HID_DS3_BUTTON_L3[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_STICK_L], HID_DS3_BUTTON_L3[0], HID_DS3_BUTTON_L3[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_STICK_R], HID_DS3_BUTTON_R3[0], HID_DS3_BUTTON_R3[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_STICK_R], HID_DS3_BUTTON_R3[0], HID_DS3_BUTTON_R3[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_HOME], HID_DS3_BUTTON_GUIDE[0], HID_DS3_BUTTON_GUIDE[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_HOME], HID_DS3_BUTTON_GUIDE[0], HID_DS3_BUTTON_GUIDE[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_PAD_COUNT], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_PAD_COUNT); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_PAD_COUNT], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_PAD_COUNT);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_L_STICK_X], HID_DS3_STICK_L_X[STICK_CONF_BYTE], HID_DS3_STICK_L_X[STICK_CONF_DEFAULT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_L_STICK_X], HID_DS3_STICK_L_X[STICK_CONF_BYTE], HID_DS3_STICK_L_X[STICK_CONF_DEFAULT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_STICK_L_X[STICK_CONF_DEADZONE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_STICK_L_X[STICK_CONF_DEADZONE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_MINMAX], HID_DS3_STICK_L_X[STICK_CONF_MIN], HID_DS3_STICK_L_X[STICK_CONF_MAX]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_MINMAX], HID_DS3_STICK_L_X[STICK_CONF_MIN], HID_DS3_STICK_L_X[STICK_CONF_MAX]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_STICK_L_X[STICK_CONF_INVERT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_STICK_L_X[STICK_CONF_INVERT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y], HID_DS3_STICK_L_Y[STICK_CONF_BYTE], HID_DS3_STICK_L_Y[STICK_CONF_DEFAULT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y], HID_DS3_STICK_L_Y[STICK_CONF_BYTE], HID_DS3_STICK_L_Y[STICK_CONF_DEFAULT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_STICK_L_Y[STICK_CONF_DEADZONE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_STICK_L_Y[STICK_CONF_DEADZONE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_MINMAX], HID_DS3_STICK_L_Y[STICK_CONF_MIN], HID_DS3_STICK_L_Y[STICK_CONF_MAX]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_MINMAX], HID_DS3_STICK_L_Y[STICK_CONF_MIN], HID_DS3_STICK_L_Y[STICK_CONF_MAX]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_STICK_L_Y[STICK_CONF_INVERT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_STICK_L_Y[STICK_CONF_INVERT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_R_STICK_X], HID_DS3_STICK_R_X[STICK_CONF_BYTE], HID_DS3_STICK_R_X[STICK_CONF_DEFAULT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_R_STICK_X], HID_DS3_STICK_R_X[STICK_CONF_BYTE], HID_DS3_STICK_R_X[STICK_CONF_DEFAULT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_STICK_R_X[STICK_CONF_DEADZONE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_STICK_R_X[STICK_CONF_DEADZONE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_MINMAX], HID_DS3_STICK_R_X[STICK_CONF_MIN], HID_DS3_STICK_R_X[STICK_CONF_MAX]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_MINMAX], HID_DS3_STICK_R_X[STICK_CONF_MIN], HID_DS3_STICK_R_X[STICK_CONF_MAX]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_STICK_R_X[STICK_CONF_INVERT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_STICK_R_X[STICK_CONF_INVERT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y], HID_DS3_STICK_R_Y[STICK_CONF_BYTE], HID_DS3_STICK_R_Y[STICK_CONF_DEFAULT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y], HID_DS3_STICK_R_Y[STICK_CONF_BYTE], HID_DS3_STICK_R_Y[STICK_CONF_DEFAULT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_STICK_R_Y[STICK_CONF_DEADZONE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_STICK_R_Y[STICK_CONF_DEADZONE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_MINMAX], HID_DS3_STICK_R_Y[STICK_CONF_MIN], HID_DS3_STICK_R_Y[STICK_CONF_MAX]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_MINMAX], HID_DS3_STICK_R_Y[STICK_CONF_MIN], HID_DS3_STICK_R_Y[STICK_CONF_MAX]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_STICK_R_Y[STICK_CONF_INVERT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds3_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_DS3_STICK_R_Y[STICK_CONF_INVERT]);
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//! DS4 //! DS4
//!--------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VID], (HID_DS4_VID>>8)&0xFF, HID_DS4_VID&0xFF); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VID], (HID_DS4_VID>>8)&0xFF, HID_DS4_VID&0xFF);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_PID], (HID_DS4_PID>>8)&0xFF, HID_DS4_PID&0xFF); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_PID], (HID_DS4_PID>>8)&0xFF, HID_DS4_PID&0xFF);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_BUF_SIZE], CONTROLLER_PATCHER_VALUE_SET, 128); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_BUF_SIZE], CONTROLLER_PATCHER_VALUE_SET, 128);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_A], HID_DS4_BUTTON_CIRCLE[0], HID_DS4_BUTTON_CIRCLE[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_A], HID_DS4_BUTTON_CIRCLE[0], HID_DS4_BUTTON_CIRCLE[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_B], HID_DS4_BUTTON_CROSS[0], HID_DS4_BUTTON_CROSS[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_B], HID_DS4_BUTTON_CROSS[0], HID_DS4_BUTTON_CROSS[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_X], HID_DS4_BUTTON_TRIANGLE[0], HID_DS4_BUTTON_TRIANGLE[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_X], HID_DS4_BUTTON_TRIANGLE[0], HID_DS4_BUTTON_TRIANGLE[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_Y], HID_DS4_BUTTON_SQUARE[0], HID_DS4_BUTTON_SQUARE[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_Y], HID_DS4_BUTTON_SQUARE[0], HID_DS4_BUTTON_SQUARE[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_DPAD_MODE], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_BUTTON_DPAD_TYPE[CONTRDPAD_MODE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_DPAD_MODE], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_BUTTON_DPAD_TYPE[CONTRDPAD_MODE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_DPAD_MASK], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_BUTTON_DPAD_TYPE[CONTRDPAD_MASK]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_DPAD_MASK], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_BUTTON_DPAD_TYPE[CONTRDPAD_MASK]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_DPAD_N], HID_DS4_BUTTON_DPAD_N[0], HID_DS4_BUTTON_DPAD_N[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_DPAD_N], HID_DS4_BUTTON_DPAD_N[0], HID_DS4_BUTTON_DPAD_N[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_DPAD_NE], HID_DS4_BUTTON_DPAD_NE[0], HID_DS4_BUTTON_DPAD_NE[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_DPAD_NE], HID_DS4_BUTTON_DPAD_NE[0], HID_DS4_BUTTON_DPAD_NE[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_DPAD_E], HID_DS4_BUTTON_DPAD_E[0], HID_DS4_BUTTON_DPAD_E[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_DPAD_E], HID_DS4_BUTTON_DPAD_E[0], HID_DS4_BUTTON_DPAD_E[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_DPAD_SE], HID_DS4_BUTTON_DPAD_SE[0], HID_DS4_BUTTON_DPAD_SE[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_DPAD_SE], HID_DS4_BUTTON_DPAD_SE[0], HID_DS4_BUTTON_DPAD_SE[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_DPAD_S], HID_DS4_BUTTON_DPAD_S[0], HID_DS4_BUTTON_DPAD_S[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_DPAD_S], HID_DS4_BUTTON_DPAD_S[0], HID_DS4_BUTTON_DPAD_S[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_DPAD_SW], HID_DS4_BUTTON_DPAD_SW[0], HID_DS4_BUTTON_DPAD_SW[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_DPAD_SW], HID_DS4_BUTTON_DPAD_SW[0], HID_DS4_BUTTON_DPAD_SW[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_DPAD_W], HID_DS4_BUTTON_DPAD_W[0], HID_DS4_BUTTON_DPAD_W[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_DPAD_W], HID_DS4_BUTTON_DPAD_W[0], HID_DS4_BUTTON_DPAD_W[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_DPAD_NW], HID_DS4_BUTTON_DPAD_NW[0], HID_DS4_BUTTON_DPAD_NW[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_DPAD_NW], HID_DS4_BUTTON_DPAD_NW[0], HID_DS4_BUTTON_DPAD_NW[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_DPAD_NEUTRAL], HID_DS4_BUTTON_DPAD_NEUTRAL[0], HID_DS4_BUTTON_DPAD_NEUTRAL[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_DPAD_NEUTRAL], HID_DS4_BUTTON_DPAD_NEUTRAL[0], HID_DS4_BUTTON_DPAD_NEUTRAL[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_PLUS], HID_DS4_BUTTON_OPTIONS[0], HID_DS4_BUTTON_OPTIONS[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_PLUS], HID_DS4_BUTTON_OPTIONS[0], HID_DS4_BUTTON_OPTIONS[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_MINUS], HID_DS4_BUTTON_SHARE[0], HID_DS4_BUTTON_SHARE[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_MINUS], HID_DS4_BUTTON_SHARE[0], HID_DS4_BUTTON_SHARE[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_L], HID_DS4_BUTTON_L1[0], HID_DS4_BUTTON_L1[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_L], HID_DS4_BUTTON_L1[0], HID_DS4_BUTTON_L1[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_R], HID_DS4_BUTTON_R1[0], HID_DS4_BUTTON_R1[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_R], HID_DS4_BUTTON_R1[0], HID_DS4_BUTTON_R1[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_ZL], HID_DS4_BUTTON_L2[0], HID_DS4_BUTTON_L2[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_ZL], HID_DS4_BUTTON_L2[0], HID_DS4_BUTTON_L2[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_ZR], HID_DS4_BUTTON_R2[0], HID_DS4_BUTTON_R2[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_ZR], HID_DS4_BUTTON_R2[0], HID_DS4_BUTTON_R2[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_STICK_L], HID_DS4_BUTTON_L3[0], HID_DS4_BUTTON_L3[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_STICK_L], HID_DS4_BUTTON_L3[0], HID_DS4_BUTTON_L3[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_STICK_R], HID_DS4_BUTTON_R3[0], HID_DS4_BUTTON_R3[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_STICK_R], HID_DS4_BUTTON_R3[0], HID_DS4_BUTTON_R3[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_HOME], HID_DS4_BUTTON_GUIDE[0], HID_DS4_BUTTON_GUIDE[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_HOME], HID_DS4_BUTTON_GUIDE[0], HID_DS4_BUTTON_GUIDE[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_PAD_COUNT], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_PAD_COUNT); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_PAD_COUNT], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_PAD_COUNT);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_L_STICK_X], HID_DS4_STICK_L_X[STICK_CONF_BYTE], HID_DS4_STICK_L_X[STICK_CONF_DEFAULT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_L_STICK_X], HID_DS4_STICK_L_X[STICK_CONF_BYTE], HID_DS4_STICK_L_X[STICK_CONF_DEFAULT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_STICK_L_X[STICK_CONF_DEADZONE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_STICK_L_X[STICK_CONF_DEADZONE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_MINMAX], HID_DS4_STICK_L_X[STICK_CONF_MIN], HID_DS4_STICK_L_X[STICK_CONF_MAX]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_MINMAX], HID_DS4_STICK_L_X[STICK_CONF_MIN], HID_DS4_STICK_L_X[STICK_CONF_MAX]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_STICK_L_X[STICK_CONF_INVERT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_STICK_L_X[STICK_CONF_INVERT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y], HID_DS4_STICK_L_Y[STICK_CONF_BYTE], HID_DS4_STICK_L_Y[STICK_CONF_DEFAULT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y], HID_DS4_STICK_L_Y[STICK_CONF_BYTE], HID_DS4_STICK_L_Y[STICK_CONF_DEFAULT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_STICK_L_Y[STICK_CONF_DEADZONE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_STICK_L_Y[STICK_CONF_DEADZONE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_MINMAX], HID_DS4_STICK_L_Y[STICK_CONF_MIN], HID_DS4_STICK_L_Y[STICK_CONF_MAX]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_MINMAX], HID_DS4_STICK_L_Y[STICK_CONF_MIN], HID_DS4_STICK_L_Y[STICK_CONF_MAX]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_STICK_L_Y[STICK_CONF_INVERT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_STICK_L_Y[STICK_CONF_INVERT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_R_STICK_X], HID_DS4_STICK_R_X[STICK_CONF_BYTE], HID_DS4_STICK_R_X[STICK_CONF_DEFAULT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_R_STICK_X], HID_DS4_STICK_R_X[STICK_CONF_BYTE], HID_DS4_STICK_R_X[STICK_CONF_DEFAULT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_STICK_R_X[STICK_CONF_DEADZONE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_STICK_R_X[STICK_CONF_DEADZONE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_MINMAX], HID_DS4_STICK_R_X[STICK_CONF_MIN], HID_DS4_STICK_R_X[STICK_CONF_MAX]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_MINMAX], HID_DS4_STICK_R_X[STICK_CONF_MIN], HID_DS4_STICK_R_X[STICK_CONF_MAX]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_STICK_R_X[STICK_CONF_INVERT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_STICK_R_X[STICK_CONF_INVERT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y], HID_DS4_STICK_R_Y[STICK_CONF_BYTE], HID_DS4_STICK_R_Y[STICK_CONF_DEFAULT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y], HID_DS4_STICK_R_Y[STICK_CONF_BYTE], HID_DS4_STICK_R_Y[STICK_CONF_DEFAULT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_STICK_R_Y[STICK_CONF_DEADZONE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_STICK_R_Y[STICK_CONF_DEADZONE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_MINMAX], HID_DS4_STICK_R_Y[STICK_CONF_MIN], HID_DS4_STICK_R_Y[STICK_CONF_MAX]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_MINMAX], HID_DS4_STICK_R_Y[STICK_CONF_MIN], HID_DS4_STICK_R_Y[STICK_CONF_MAX]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_STICK_R_Y[STICK_CONF_INVERT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[ds4_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_DS4_STICK_R_Y[STICK_CONF_INVERT]);
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//! XInput //! XInput
//!--------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VID], (HID_XINPUT_VID>>8)&0xFF, HID_XINPUT_VID&0xFF); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VID], (HID_XINPUT_VID>>8)&0xFF, HID_XINPUT_VID&0xFF);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_PID], (HID_XINPUT_PID>>8)&0xFF, HID_XINPUT_PID&0xFF); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_PID], (HID_XINPUT_PID>>8)&0xFF, HID_XINPUT_PID&0xFF);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_BUF_SIZE], CONTROLLER_PATCHER_VALUE_SET, 128); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_BUF_SIZE], CONTROLLER_PATCHER_VALUE_SET, 128);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_A], HID_XINPUT_BUTTON_B[0], HID_XINPUT_BUTTON_B[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_A], HID_XINPUT_BUTTON_B[0], HID_XINPUT_BUTTON_B[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_B], HID_XINPUT_BUTTON_A[0], HID_XINPUT_BUTTON_A[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_B], HID_XINPUT_BUTTON_A[0], HID_XINPUT_BUTTON_A[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_X], HID_XINPUT_BUTTON_Y[0], HID_XINPUT_BUTTON_Y[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_X], HID_XINPUT_BUTTON_Y[0], HID_XINPUT_BUTTON_Y[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_Y], HID_XINPUT_BUTTON_X[0], HID_XINPUT_BUTTON_X[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_Y], HID_XINPUT_BUTTON_X[0], HID_XINPUT_BUTTON_X[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_DPAD_MODE], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_BUTTON_DPAD_TYPE[CONTRDPAD_MODE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_DPAD_MODE], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_BUTTON_DPAD_TYPE[CONTRDPAD_MODE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_DPAD_MASK], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_BUTTON_DPAD_TYPE[CONTRDPAD_MASK]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_DPAD_MASK], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_BUTTON_DPAD_TYPE[CONTRDPAD_MASK]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_UP], HID_XINPUT_BUTTON_UP[0], HID_XINPUT_BUTTON_UP[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_UP], HID_XINPUT_BUTTON_UP[0], HID_XINPUT_BUTTON_UP[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_DOWN], HID_XINPUT_BUTTON_DOWN[0], HID_XINPUT_BUTTON_DOWN[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_DOWN], HID_XINPUT_BUTTON_DOWN[0], HID_XINPUT_BUTTON_DOWN[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_LEFT], HID_XINPUT_BUTTON_LEFT[0], HID_XINPUT_BUTTON_LEFT[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_LEFT], HID_XINPUT_BUTTON_LEFT[0], HID_XINPUT_BUTTON_LEFT[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_RIGHT], HID_XINPUT_BUTTON_RIGHT[0], HID_XINPUT_BUTTON_RIGHT[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_RIGHT], HID_XINPUT_BUTTON_RIGHT[0], HID_XINPUT_BUTTON_RIGHT[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_PLUS], HID_XINPUT_BUTTON_START[0], HID_XINPUT_BUTTON_START[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_PLUS], HID_XINPUT_BUTTON_START[0], HID_XINPUT_BUTTON_START[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_MINUS], HID_XINPUT_BUTTON_BACK[0], HID_XINPUT_BUTTON_BACK[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_MINUS], HID_XINPUT_BUTTON_BACK[0], HID_XINPUT_BUTTON_BACK[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_L], HID_XINPUT_BUTTON_LB[0], HID_XINPUT_BUTTON_LB[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_L], HID_XINPUT_BUTTON_LB[0], HID_XINPUT_BUTTON_LB[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_R], HID_XINPUT_BUTTON_RB[0], HID_XINPUT_BUTTON_RB[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_R], HID_XINPUT_BUTTON_RB[0], HID_XINPUT_BUTTON_RB[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_ZL], HID_XINPUT_BUTTON_LT[0], HID_XINPUT_BUTTON_LT[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_ZL], HID_XINPUT_BUTTON_LT[0], HID_XINPUT_BUTTON_LT[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_ZR], HID_XINPUT_BUTTON_RT[0], HID_XINPUT_BUTTON_RT[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_ZR], HID_XINPUT_BUTTON_RT[0], HID_XINPUT_BUTTON_RT[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_STICK_L], HID_XINPUT_BUTTON_L3[0], HID_XINPUT_BUTTON_L3[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_STICK_L], HID_XINPUT_BUTTON_L3[0], HID_XINPUT_BUTTON_L3[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_STICK_R], HID_XINPUT_BUTTON_R3[0], HID_XINPUT_BUTTON_R3[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_STICK_R], HID_XINPUT_BUTTON_R3[0], HID_XINPUT_BUTTON_R3[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_HOME], HID_XINPUT_BUTTON_GUIDE[0], HID_XINPUT_BUTTON_GUIDE[1]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_HOME], HID_XINPUT_BUTTON_GUIDE[0], HID_XINPUT_BUTTON_GUIDE[1]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_PAD_COUNT], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_PAD_COUNT); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_PAD_COUNT], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_PAD_COUNT);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_L_STICK_X], HID_XINPUT_STICK_L_X[STICK_CONF_BYTE], HID_XINPUT_STICK_L_X[STICK_CONF_DEFAULT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_L_STICK_X], HID_XINPUT_STICK_L_X[STICK_CONF_BYTE], HID_XINPUT_STICK_L_X[STICK_CONF_DEFAULT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_STICK_L_X[STICK_CONF_DEADZONE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_STICK_L_X[STICK_CONF_DEADZONE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_MINMAX], HID_XINPUT_STICK_L_X[STICK_CONF_MIN], HID_XINPUT_STICK_L_X[STICK_CONF_MAX]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_MINMAX], HID_XINPUT_STICK_L_X[STICK_CONF_MIN], HID_XINPUT_STICK_L_X[STICK_CONF_MAX]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_STICK_L_X[STICK_CONF_INVERT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_L_STICK_X_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_STICK_L_X[STICK_CONF_INVERT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y], HID_XINPUT_STICK_L_Y[STICK_CONF_BYTE], HID_XINPUT_STICK_L_Y[STICK_CONF_DEFAULT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y], HID_XINPUT_STICK_L_Y[STICK_CONF_BYTE], HID_XINPUT_STICK_L_Y[STICK_CONF_DEFAULT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_STICK_L_Y[STICK_CONF_DEADZONE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_STICK_L_Y[STICK_CONF_DEADZONE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_MINMAX], HID_XINPUT_STICK_L_Y[STICK_CONF_MIN], HID_XINPUT_STICK_L_Y[STICK_CONF_MAX]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_MINMAX], HID_XINPUT_STICK_L_Y[STICK_CONF_MIN], HID_XINPUT_STICK_L_Y[STICK_CONF_MAX]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_STICK_L_Y[STICK_CONF_INVERT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_L_STICK_Y_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_STICK_L_Y[STICK_CONF_INVERT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_R_STICK_X], HID_XINPUT_STICK_R_X[STICK_CONF_BYTE], HID_XINPUT_STICK_R_X[STICK_CONF_DEFAULT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_R_STICK_X], HID_XINPUT_STICK_R_X[STICK_CONF_BYTE], HID_XINPUT_STICK_R_X[STICK_CONF_DEFAULT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_STICK_R_X[STICK_CONF_DEADZONE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_STICK_R_X[STICK_CONF_DEADZONE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_MINMAX], HID_XINPUT_STICK_R_X[STICK_CONF_MIN], HID_XINPUT_STICK_R_X[STICK_CONF_MAX]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_MINMAX], HID_XINPUT_STICK_R_X[STICK_CONF_MIN], HID_XINPUT_STICK_R_X[STICK_CONF_MAX]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_STICK_R_X[STICK_CONF_INVERT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_R_STICK_X_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_STICK_R_X[STICK_CONF_INVERT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y], HID_XINPUT_STICK_R_Y[STICK_CONF_BYTE], HID_XINPUT_STICK_R_Y[STICK_CONF_DEFAULT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y], HID_XINPUT_STICK_R_Y[STICK_CONF_BYTE], HID_XINPUT_STICK_R_Y[STICK_CONF_DEFAULT]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_STICK_R_Y[STICK_CONF_DEADZONE]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_DEADZONE], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_STICK_R_Y[STICK_CONF_DEADZONE]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_MINMAX], HID_XINPUT_STICK_R_Y[STICK_CONF_MIN], HID_XINPUT_STICK_R_Y[STICK_CONF_MAX]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_MINMAX], HID_XINPUT_STICK_R_Y[STICK_CONF_MIN], HID_XINPUT_STICK_R_Y[STICK_CONF_MAX]);
ControllerPatcherUtils::setConfigValue((u8*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_STICK_R_Y[STICK_CONF_INVERT]); ControllerPatcherUtils::setConfigValue((uint8_t*)&config_controller[xinput_slot][CONTRPS_VPAD_BUTTON_R_STICK_Y_INVERT], CONTROLLER_PATCHER_VALUE_SET, HID_XINPUT_STICK_R_Y[STICK_CONF_INVERT]);
} }
bool ControllerPatcher::Init(const char * pathToConfig) { BOOL ControllerPatcher::Init(const char * pathToConfig) {
OSDynLoad_Module handle; OSDynLoad_Module handle;
void* kpad_ptr; void* kpad_ptr;
OSDynLoad_Acquire("padscore",&handle); OSDynLoad_Acquire("padscore",&handle);
OSDynLoad_FindExport(handle, 0 ,"KPADRead",&kpad_ptr); OSDynLoad_FindExport(handle, 0 ,"KPADRead",&kpad_ptr);
gSamplingCallback = (WPADSamplingCallback)((u32)kpad_ptr + 0x1F0); gSamplingCallback = (WPADSamplingCallback)((uint32_t)kpad_ptr + 0x1F0);
if(*(u32*)gSamplingCallback != FIRST_INSTRUCTION_IN_SAMPLING_CALLBACK) { if(*(uint32_t*)gSamplingCallback != FIRST_INSTRUCTION_IN_SAMPLING_CALLBACK) {
//In Firmware <= 5.1.2 the offset changes //In Firmware <= 5.1.2 the offset changes
gSamplingCallback = (WPADSamplingCallback)((u32)kpad_ptr + 0x1F8); gSamplingCallback = (WPADSamplingCallback)((uint32_t)kpad_ptr + 0x1F8);
if(*(u32*)gSamplingCallback != FIRST_INSTRUCTION_IN_SAMPLING_CALLBACK) { if(*(uint32_t*)gSamplingCallback != FIRST_INSTRUCTION_IN_SAMPLING_CALLBACK) {
//Should never happen. I looked into the padscore.rpl of ALL firmwares. //Should never happen. I looked into the padscore.rpl of ALL firmwares.
gSamplingCallback = NULL; gSamplingCallback = NULL;
} }
@ -668,9 +668,9 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::resetControllerMapping(UCo
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::addControllerMapping(UController_Type type,ControllerMappingPADInfo config) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::addControllerMapping(UController_Type type,ControllerMappingPADInfo config) {
ControllerMappingPAD * cm_map_pad = ControllerPatcherUtils::getControllerMappingByType(type); ControllerMappingPAD * cm_map_pad = ControllerPatcherUtils::getControllerMappingByType(type);
s32 result = 0; int32_t result = 0;
for(s32 i=0; i<HID_MAX_DEVICES_PER_SLOT; i++) { for(int32_t i=0; i<HID_MAX_DEVICES_PER_SLOT; i++) {
ControllerMappingPADInfo * info = &(cm_map_pad->pad_infos[i]); ControllerMappingPADInfo * info = &(cm_map_pad->pad_infos[i]);
if(info != NULL && !info->active) { if(info != NULL && !info->active) {
info->active = 1; info->active = 1;
@ -691,15 +691,15 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::addControllerMapping(UCont
return CONTROLLER_PATCHER_ERROR_NONE; return CONTROLLER_PATCHER_ERROR_NONE;
} }
s32 ControllerPatcher::getActiveMappingSlot(UController_Type type) { int32_t ControllerPatcher::getActiveMappingSlot(UController_Type type) {
ControllerMappingPAD * cm_map_pad = ControllerPatcherUtils::getControllerMappingByType(type); ControllerMappingPAD * cm_map_pad = ControllerPatcherUtils::getControllerMappingByType(type);
if(cm_map_pad == NULL) { if(cm_map_pad == NULL) {
return -1; return -1;
} }
s32 connected = -1; int32_t connected = -1;
for(s32 i =0; i<HID_MAX_DEVICES_PER_SLOT; i++) { for(int32_t i =0; i<HID_MAX_DEVICES_PER_SLOT; i++) {
if(cm_map_pad->pad_infos[i].active || cm_map_pad->pad_infos[i].type == CM_Type_RealController) { if(cm_map_pad->pad_infos[i].active || cm_map_pad->pad_infos[i].type == CM_Type_RealController) {
connected = i; connected = i;
break; break;
@ -709,7 +709,7 @@ s32 ControllerPatcher::getActiveMappingSlot(UController_Type type) {
return connected; return connected;
} }
bool ControllerPatcher::isControllerConnectedAndActive(UController_Type type,s32 mapping_slot) { BOOL ControllerPatcher::isControllerConnectedAndActive(UController_Type type,int32_t mapping_slot) {
ControllerMappingPADInfo * padinfo = getControllerMappingInfo(type,mapping_slot); ControllerMappingPADInfo * padinfo = getControllerMappingInfo(type,mapping_slot);
if(!padinfo) { if(!padinfo) {
return false; return false;
@ -721,13 +721,13 @@ bool ControllerPatcher::isControllerConnectedAndActive(UController_Type type,s32
device_info.vidpid = padinfo->vidpid; device_info.vidpid = padinfo->vidpid;
s32 res; int32_t res;
if((res = ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info)) < 0) { if((res = ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info)) < 0) {
return false; return false;
} }
u32 hidmask = device_info.slotdata.hidmask; uint32_t hidmask = device_info.slotdata.hidmask;
u32 pad = padinfo->pad; uint32_t pad = padinfo->pad;
HID_Data * data_cur; HID_Data * data_cur;
@ -740,7 +740,7 @@ bool ControllerPatcher::isControllerConnectedAndActive(UController_Type type,s32
return false; return false;
} }
ControllerMappingPADInfo * ControllerPatcher::getControllerMappingInfo(UController_Type type,s32 mapping_slot) { ControllerMappingPADInfo * ControllerPatcher::getControllerMappingInfo(UController_Type type,int32_t mapping_slot) {
ControllerMappingPAD * cm_map_pad = ControllerPatcherUtils::getControllerMappingByType(type); ControllerMappingPAD * cm_map_pad = ControllerPatcherUtils::getControllerMappingByType(type);
if(cm_map_pad == NULL) { if(cm_map_pad == NULL) {
@ -764,7 +764,7 @@ HID_Mouse_Data * ControllerPatcher::getMouseData() {
HID_Mouse_Data * result = NULL; HID_Mouse_Data * result = NULL;
for(s32 i = 0; i<HID_MAX_DEVICES_PER_SLOT; i++) { for(int32_t i = 0; i<HID_MAX_DEVICES_PER_SLOT; i++) {
ControllerMappingPADInfo * padinfo = &(CMPAD->pad_infos[i]); ControllerMappingPADInfo * padinfo = &(CMPAD->pad_infos[i]);
if(!padinfo->active) { if(!padinfo->active) {
break; break;
@ -779,7 +779,7 @@ HID_Mouse_Data * ControllerPatcher::getMouseData() {
return result; return result;
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setRumble(UController_Type type,u32 status) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setRumble(UController_Type type,uint32_t status) {
ControllerMappingPAD * cm_map_pad = ControllerPatcherUtils::getControllerMappingByType(type); ControllerMappingPAD * cm_map_pad = ControllerPatcherUtils::getControllerMappingByType(type);
if(cm_map_pad == NULL) { if(cm_map_pad == NULL) {
return -1; return -1;
@ -788,18 +788,18 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setRumble(UController_Type
return CONTROLLER_PATCHER_ERROR_NONE; return CONTROLLER_PATCHER_ERROR_NONE;
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::gettingInputAllDevices(InputData * output,s32 array_size) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::gettingInputAllDevices(InputData * output,int32_t array_size) {
s32 hid = gHIDCurrentDevice; int32_t hid = gHIDCurrentDevice;
HID_Data * data_cur; HID_Data * data_cur;
VPADStatus pad_buffer; VPADStatus pad_buffer;
VPADStatus * buffer = &pad_buffer; VPADStatus * buffer = &pad_buffer;
s32 result = CONTROLLER_PATCHER_ERROR_NONE; int32_t result = CONTROLLER_PATCHER_ERROR_NONE;
for(s32 i = 0; i< gHIDMaxDevices; i++) { for(int32_t i = 0; i< gHIDMaxDevices; i++) {
if((hid & (1 << i)) != 0) { if((hid & (1 << i)) != 0) {
memset(buffer,0,sizeof(*buffer)); memset(buffer,0,sizeof(*buffer));
s32 newhid = (1 << i); int32_t newhid = (1 << i);
s32 deviceslot = ControllerPatcherUtils::getDeviceSlot(newhid); int32_t deviceslot = ControllerPatcherUtils::getDeviceSlot(newhid);
if(deviceslot < 0) continue; if(deviceslot < 0) continue;
output[result].type = CM_Type_Controller; output[result].type = CM_Type_Controller;
@ -826,14 +826,14 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::gettingInputAllDevices(Inp
deviceinfo->pad_count = HID_MAX_PADS_COUNT; deviceinfo->pad_count = HID_MAX_PADS_COUNT;
}*/ }*/
s32 buttons_hold = 0; int32_t buttons_hold = 0;
for(s32 pad = 0; pad<HID_MAX_PADS_COUNT; pad++) { for(int32_t pad = 0; pad<HID_MAX_PADS_COUNT; pad++) {
buttons_hold = 0; buttons_hold = 0;
buttondata[pad].btn_h = 0; buttondata[pad].btn_h = 0;
buttondata[pad].btn_d = 0; buttondata[pad].btn_d = 0;
buttondata[pad].btn_r = 0; buttondata[pad].btn_r = 0;
s32 res; int32_t res;
if((res = ControllerPatcherHID::getHIDData(deviceinfo->slotdata.hidmask,pad,&data_cur)) < 0) { if((res = ControllerPatcherHID::getHIDData(deviceinfo->slotdata.hidmask,pad,&data_cur)) < 0) {
continue; continue;
@ -878,7 +878,7 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::gettingInputAllDevices(Inp
return result; return result;
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setProControllerDataFromHID(void * data,s32 chan, s32 mode) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setProControllerDataFromHID(void * data,int32_t chan, int32_t mode) {
if(data == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(data == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
if(chan < 0 || chan > 3) return CONTROLLER_PATCHER_ERROR_INVALID_CHAN; if(chan < 0 || chan > 3) return CONTROLLER_PATCHER_ERROR_INVALID_CHAN;
//if(gControllerMapping.proController[chan].enabled == 0) return CONTROLLER_PATCHER_ERROR_MAPPING_DISABLED; //if(gControllerMapping.proController[chan].enabled == 0) return CONTROLLER_PATCHER_ERROR_MAPPING_DISABLED;
@ -888,7 +888,7 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setProControllerDataFromHI
std::vector<HID_Data *> data_list; std::vector<HID_Data *> data_list;
for(s32 i = 0; i<HID_MAX_DEVICES_PER_SLOT; i++) { for(int32_t i = 0; i<HID_MAX_DEVICES_PER_SLOT; i++) {
ControllerMappingPADInfo cm_map_pad_info = gControllerMapping.proController[chan].pad_infos[i]; ControllerMappingPADInfo cm_map_pad_info = gControllerMapping.proController[chan].pad_infos[i];
if(!cm_map_pad_info.active) { if(!cm_map_pad_info.active) {
continue; continue;
@ -898,14 +898,14 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setProControllerDataFromHI
device_info.vidpid = cm_map_pad_info.vidpid; device_info.vidpid = cm_map_pad_info.vidpid;
s32 res; int32_t res;
if((res = ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info)) < 0) { if((res = ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info)) < 0) {
DEBUG_FUNCTION_LINE("ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info) = %d\n",res); DEBUG_FUNCTION_LINE("ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info) = %d\n",res);
continue; continue;
} }
s32 hidmask = device_info.slotdata.hidmask; int32_t hidmask = device_info.slotdata.hidmask;
s32 pad = cm_map_pad_info.pad; int32_t pad = cm_map_pad_info.pad;
HID_Data * data_cur; HID_Data * data_cur;
@ -919,7 +919,7 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setProControllerDataFromHI
if(data_list.empty()) { if(data_list.empty()) {
return CONTROLLER_PATCHER_ERROR_FAILED_TO_GET_HIDDATA; return CONTROLLER_PATCHER_ERROR_FAILED_TO_GET_HIDDATA;
} }
s32 res = 0; int32_t res = 0;
if((res = ControllerPatcherHID::setVPADControllerData(vpad_buffer,data_list)) < 0) return res; if((res = ControllerPatcherHID::setVPADControllerData(vpad_buffer,data_list)) < 0) return res;
//make it configurable? //make it configurable?
//ControllerPatcher::printVPADButtons(vpad_buffer); //Leads to random crashes on transitions. //ControllerPatcher::printVPADButtons(vpad_buffer); //Leads to random crashes on transitions.
@ -944,8 +944,8 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setControllerDataFromHID(V
if(buffer == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(buffer == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
//if(gControllerMapping.gamepad.enabled == 0) return CONTROLLER_PATCHER_ERROR_MAPPING_DISABLED; //if(gControllerMapping.gamepad.enabled == 0) return CONTROLLER_PATCHER_ERROR_MAPPING_DISABLED;
s32 hidmask = 0; int32_t hidmask = 0;
s32 pad = 0; int32_t pad = 0;
ControllerMappingPAD cm_map_pad = gControllerMapping.gamepad; ControllerMappingPAD cm_map_pad = gControllerMapping.gamepad;
std::vector<HID_Data *> data_list; std::vector<HID_Data *> data_list;
@ -953,7 +953,7 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setControllerDataFromHID(V
if (cm_map_pad.useAll == 1) { if (cm_map_pad.useAll == 1) {
data_list = ControllerPatcherHID::getHIDDataAll(); data_list = ControllerPatcherHID::getHIDDataAll();
} else { } else {
for(s32 i = 0; i<HID_MAX_DEVICES_PER_SLOT; i++) { for(int32_t i = 0; i<HID_MAX_DEVICES_PER_SLOT; i++) {
ControllerMappingPADInfo cm_map_pad_info = cm_map_pad.pad_infos[i]; ControllerMappingPADInfo cm_map_pad_info = cm_map_pad.pad_infos[i];
if(cm_map_pad_info.active) { if(cm_map_pad_info.active) {
DeviceInfo device_info; DeviceInfo device_info;
@ -970,7 +970,7 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setControllerDataFromHID(V
HID_Data * data; HID_Data * data;
pad = cm_map_pad_info.pad; pad = cm_map_pad_info.pad;
s32 res = ControllerPatcherHID::getHIDData(hidmask,pad,&data); int32_t res = ControllerPatcherHID::getHIDData(hidmask,pad,&data);
if(res < 0) { if(res < 0) {
continue; continue;
//return CONTROLLER_PATCHER_ERROR_FAILED_TO_GET_HIDDATA; //return CONTROLLER_PATCHER_ERROR_FAILED_TO_GET_HIDDATA;
@ -985,7 +985,7 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setControllerDataFromHID(V
ControllerPatcherHID::setVPADControllerData(buffer,data_list); ControllerPatcherHID::setVPADControllerData(buffer,data_list);
for(u32 i = 0; i < data_list.size(); i++) { for(uint32_t i = 0; i < data_list.size(); i++) {
data_list[i]->rumbleActive = !!gControllerMapping.gamepad.rumble; data_list[i]->rumbleActive = !!gControllerMapping.gamepad.rumble;
} }
@ -1033,10 +1033,10 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::printVPADButtons(VPADStatu
return CONTROLLER_PATCHER_ERROR_NONE; return CONTROLLER_PATCHER_ERROR_NONE;
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::buttonRemapping(VPADStatus * buffer,s32 buffer_count) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::buttonRemapping(VPADStatus * buffer,int32_t buffer_count) {
if(!gButtonRemappingConfigDone) return CONTROLLER_PATCHER_ERROR_CONFIG_NOT_DONE; if(!gButtonRemappingConfigDone) return CONTROLLER_PATCHER_ERROR_CONFIG_NOT_DONE;
if(buffer == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(buffer == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
for(s32 i = 0; i < buffer_count; i++) { for(int32_t i = 0; i < buffer_count; i++) {
VPADStatus new_data; VPADStatus new_data;
memset(&new_data,0,sizeof(new_data)); memset(&new_data,0,sizeof(new_data));
@ -1088,7 +1088,7 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::buttonRemapping(VPADStatus
return CONTROLLER_PATCHER_ERROR_NONE; return CONTROLLER_PATCHER_ERROR_NONE;
} }
std::string ControllerPatcher::getIdentifierByVIDPID(u16 vid,u16 pid) { std::string ControllerPatcher::getIdentifierByVIDPID(uint16_t vid,uint16_t pid) {
return ConfigValues::getStringByVIDPID(vid,pid); return ConfigValues::getStringByVIDPID(vid,pid);
} }
@ -1097,34 +1097,34 @@ void ControllerPatcher::destroyConfigHelper() {
ConfigValues::destroyInstance(); ConfigValues::destroyInstance();
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::doSamplingForDeviceSlot(u16 device_slot) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::doSamplingForDeviceSlot(uint16_t device_slot) {
return ControllerPatcherUtils::doSampling(device_slot,0,true); return ControllerPatcherUtils::doSampling(device_slot,0,true);
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setRumbleActivated(bool value) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setRumbleActivated(BOOL value) {
gGlobalRumbleActivated = value; gGlobalRumbleActivated = value;
return CONTROLLER_PATCHER_ERROR_NONE; return CONTROLLER_PATCHER_ERROR_NONE;
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setNetworkControllerActivated(bool value) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setNetworkControllerActivated(BOOL value) {
gNetworkControllerActivated = value; gNetworkControllerActivated = value;
return CONTROLLER_PATCHER_ERROR_NONE; return CONTROLLER_PATCHER_ERROR_NONE;
} }
bool ControllerPatcher::isRumbleActivated() { BOOL ControllerPatcher::isRumbleActivated() {
return gGlobalRumbleActivated; return gGlobalRumbleActivated;
} }
bool ControllerPatcher::isButtonRemappingDone() { BOOL ControllerPatcher::isButtonRemappingDone() {
return gButtonRemappingConfigDone; return gButtonRemappingConfigDone;
} }
bool ControllerPatcher::isKeyboardConnected() { BOOL ControllerPatcher::isKeyboardConnected() {
return (gHIDCurrentDevice & gHID_LIST_KEYBOARD) == gHID_LIST_KEYBOARD; return (gHIDCurrentDevice & gHID_LIST_KEYBOARD) == gHID_LIST_KEYBOARD;
} }
bool ControllerPatcher::areControllersConnected() { BOOL ControllerPatcher::areControllersConnected() {
return gHIDAttached > 0; return gHIDAttached > 0;
} }
@ -1145,7 +1145,7 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::resetCallbackData() {
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setKPADConnectedCallback(s32 chan, WPADConnectCallback callback) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setKPADConnectedCallback(int32_t chan, WPADConnectCallback callback) {
if(chan >= 4) { if(chan >= 4) {
return CONTROLLER_PATCHER_ERROR_INVALID_CHAN; return CONTROLLER_PATCHER_ERROR_INVALID_CHAN;
} }
@ -1153,7 +1153,7 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setKPADConnectedCallback(s
return CONTROLLER_PATCHER_ERROR_NONE; return CONTROLLER_PATCHER_ERROR_NONE;
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setKPADExtensionCallback(s32 chan, WPADConnectCallback callback) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setKPADExtensionCallback(int32_t chan, WPADConnectCallback callback) {
if(chan >= 4) { if(chan >= 4) {
return CONTROLLER_PATCHER_ERROR_INVALID_CHAN; return CONTROLLER_PATCHER_ERROR_INVALID_CHAN;
} }
@ -1161,7 +1161,7 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setKPADExtensionCallback(s
return CONTROLLER_PATCHER_ERROR_NONE; return CONTROLLER_PATCHER_ERROR_NONE;
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setWPADConnectCallback(s32 chan, WPADConnectCallback callback) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setWPADConnectCallback(int32_t chan, WPADConnectCallback callback) {
if(chan >= 4) { if(chan >= 4) {
return CONTROLLER_PATCHER_ERROR_INVALID_CHAN; return CONTROLLER_PATCHER_ERROR_INVALID_CHAN;
} }
@ -1169,7 +1169,7 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setWPADConnectCallback(s32
return CONTROLLER_PATCHER_ERROR_NONE; return CONTROLLER_PATCHER_ERROR_NONE;
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::handleCallbackData(bool button_pressed) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::handleCallbackData(BOOL button_pressed) {
if(button_pressed && gCallbackCooldown == 0) { if(button_pressed && gCallbackCooldown == 0) {
gCallbackCooldown = 0xFF; gCallbackCooldown = 0xFF;

48
source/config/ConfigParser.cpp
View File

@ -30,7 +30,7 @@ ConfigParser::ConfigParser(std::string configData) {
} }
//remove the comments and make everything uppercase //remove the comments and make everything uppercase
for(u32 i = 0; i < contentLines.size(); i++) { for(uint32_t i = 0; i < contentLines.size(); i++) {
std::vector<std::string> comments = StringTools::stringSplit(contentLines[i], "//"); std::vector<std::string> comments = StringTools::stringSplit(contentLines[i], "//");
if(!comments.empty()) { if(!comments.empty()) {
contentLines[i] = comments[0]; contentLines[i] = comments[0];
@ -41,7 +41,7 @@ ConfigParser::ConfigParser(std::string configData) {
//remove empty lines //remove empty lines
std::vector<std::string> contentline2; std::vector<std::string> contentline2;
for(u32 i = 0; i < contentLines.size(); i++) { for(uint32_t i = 0; i < contentLines.size(); i++) {
if(strlen(contentLines[i].c_str()) > 0) { if(strlen(contentLines[i].c_str()) > 0) {
contentline2.push_back(contentLines[i]); contentline2.push_back(contentLines[i]);
} }
@ -62,21 +62,21 @@ void ConfigParser::setType(PARSE_TYPE newType) {
this->type_b = newType; this->type_b = newType;
} }
u16 ConfigParser::getSlot() { uint16_t ConfigParser::getSlot() {
return this->slot_b; return this->slot_b;
} }
void ConfigParser::setSlot(u16 newSlot) { void ConfigParser::setSlot(uint16_t newSlot) {
this->slot_b = newSlot; this->slot_b = newSlot;
} }
bool ConfigParser::Init() { BOOL ConfigParser::Init() {
if(contentLines.size() == 0) { if(contentLines.size() == 0) {
DEBUG_FUNCTION_LINE("File seems to be empty. Make sure to have a proper header\n"); DEBUG_FUNCTION_LINE("File seems to be empty. Make sure to have a proper header\n");
return false; return false;
} }
const char * line = contentLines[0].c_str(); const char * line = contentLines[0].c_str();
s32 len = strlen(line); int32_t len = strlen(line);
if(len <= 4) { if(len <= 4) {
DEBUG_FUNCTION_LINE("Header is too short.\n"); DEBUG_FUNCTION_LINE("Header is too short.\n");
return false; return false;
@ -133,7 +133,7 @@ void ConfigParser::parseSingleLine(std::string line) {
} }
return; return;
} else { } else {
u16 hid_slot = getSlot(); uint16_t hid_slot = getSlot();
if(HID_DEBUG) { if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("leftpart = \"%s\" \n",cur_values[0].c_str()); DEBUG_FUNCTION_LINE("leftpart = \"%s\" \n",cur_values[0].c_str());
@ -141,7 +141,7 @@ void ConfigParser::parseSingleLine(std::string line) {
if(HID_DEBUG) { if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("rightpart = \"%s\" \n",cur_values[1].c_str()); DEBUG_FUNCTION_LINE("rightpart = \"%s\" \n",cur_values[1].c_str());
} }
s32 keyslot = -1; int32_t keyslot = -1;
if(HID_DEBUG) { if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("Checking single value\n"); DEBUG_FUNCTION_LINE("Checking single value\n");
@ -158,9 +158,9 @@ void ConfigParser::parseSingleLine(std::string line) {
DEBUG_FUNCTION_LINE("Its a single value\n"); DEBUG_FUNCTION_LINE("Its a single value\n");
} }
long rightValue = -1; long rightValue = -1;
bool valueSet = false; BOOL valueSet = false;
if(cur_values[0].compare("DPAD_MODE") == 0) { if(cur_values[0].compare("DPAD_MODE") == 0) {
const u8 * values_ = NULL; const uint8_t * values_ = NULL;
if((values_ = ConfigValues::getValuesStickPreset(cur_values[1])) != NULL) { if((values_ = ConfigValues::getValuesStickPreset(cur_values[1])) != NULL) {
if(values_[STICK_CONF_MAGIC_VERSION] != STICK_CONF_MAGIC_VALUE) if(values_[STICK_CONF_MAGIC_VERSION] != STICK_CONF_MAGIC_VALUE)
if(HID_DEBUG) { if(HID_DEBUG) {
@ -258,17 +258,17 @@ void ConfigParser::parseSingleLine(std::string line) {
} }
} }
bool ConfigParser::resetConfig() { BOOL ConfigParser::resetConfig() {
s32 slot = getSlot(); int32_t slot = getSlot();
if((slot == HID_INVALID_SLOT) || (slot >= gHIDMaxDevices)) return false; if((slot == HID_INVALID_SLOT) || (slot >= gHIDMaxDevices)) return false;
for(s32 j = (CONTRPS_PID+1); j< CONTRPS_MAX_VALUE; j++) { for(int32_t j = (CONTRPS_PID+1); j< CONTRPS_MAX_VALUE; j++) {
config_controller[slot][j][0] = CONTROLLER_PATCHER_INVALIDVALUE; config_controller[slot][j][0] = CONTROLLER_PATCHER_INVALIDVALUE;
config_controller[slot][j][1] = CONTROLLER_PATCHER_INVALIDVALUE; config_controller[slot][j][1] = CONTROLLER_PATCHER_INVALIDVALUE;
} }
return true; return true;
} }
s32 ConfigParser::getSlotController(std::string identify) { int32_t ConfigParser::getSlotController(std::string identify) {
if(HID_DEBUG) { if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("Getting Controller Slot\n"); DEBUG_FUNCTION_LINE("Getting Controller Slot\n");
} }
@ -280,11 +280,11 @@ s32 ConfigParser::getSlotController(std::string identify) {
return HID_INVALID_SLOT; return HID_INVALID_SLOT;
} }
s32 vid = getValueFromKeyValue(values[0],"VID","="); int32_t vid = getValueFromKeyValue(values[0],"VID","=");
if(vid < 0) { if(vid < 0) {
return HID_INVALID_SLOT; return HID_INVALID_SLOT;
} }
s32 pid = getValueFromKeyValue(values[1],"PID","="); int32_t pid = getValueFromKeyValue(values[1],"PID","=");
if(pid < 0) { if(pid < 0) {
return HID_INVALID_SLOT; return HID_INVALID_SLOT;
} }
@ -296,9 +296,9 @@ s32 ConfigParser::getSlotController(std::string identify) {
memset(&deviceinfo,0,sizeof(deviceinfo)); memset(&deviceinfo,0,sizeof(deviceinfo));
deviceinfo.vidpid.vid = vid; deviceinfo.vidpid.vid = vid;
deviceinfo.vidpid.pid = pid; deviceinfo.vidpid.pid = pid;
s32 result = ControllerPatcherUtils::getDeviceInfoFromVidPid(&deviceinfo); int32_t result = ControllerPatcherUtils::getDeviceInfoFromVidPid(&deviceinfo);
s32 slot = deviceinfo.slotdata.deviceslot; int32_t slot = deviceinfo.slotdata.deviceslot;
s32 hid = 0; int32_t hid = 0;
if(result < 0) { if(result < 0) {
if(HID_DEBUG) { if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("Its a new controller, lets save it\n"); DEBUG_FUNCTION_LINE("Its a new controller, lets save it\n");
@ -350,7 +350,7 @@ s32 ConfigParser::getSlotController(std::string identify) {
return slot; return slot;
} }
bool ConfigParser::parseIni() { BOOL ConfigParser::parseIni() {
if(getSlot() == HID_INVALID_SLOT) { if(getSlot() == HID_INVALID_SLOT) {
DEBUG_FUNCTION_LINE("Couldn't parse file. Not a valid slot. Probably broken config. Or you tried to have more than %d devices\n",getType(),gHIDMaxDevices); DEBUG_FUNCTION_LINE("Couldn't parse file. Not a valid slot. Probably broken config. Or you tried to have more than %d devices\n",getType(),gHIDMaxDevices);
return false; return false;
@ -361,7 +361,7 @@ bool ConfigParser::parseIni() {
DEBUG_FUNCTION_LINE("Parsing content, type %d\n",getType()); DEBUG_FUNCTION_LINE("Parsing content, type %d\n",getType());
} }
s32 start = 1; int32_t start = 1;
if(contentLines.size() <= 1) { if(contentLines.size() <= 1) {
DEBUG_FUNCTION_LINE("File only contains a header.\n"); DEBUG_FUNCTION_LINE("File only contains a header.\n");
return false; return false;
@ -372,7 +372,7 @@ bool ConfigParser::parseIni() {
start++; start++;
} }
for(u32 i = start; i < contentLines.size(); i++) { for(uint32_t i = start; i < contentLines.size(); i++) {
if(HID_DEBUG) { if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("line %d: \"%s\" \n",(i+1),contentLines[i].c_str()); DEBUG_FUNCTION_LINE("line %d: \"%s\" \n",(i+1),contentLines[i].c_str());
} }
@ -385,7 +385,7 @@ bool ConfigParser::parseIni() {
return true; return true;
} }
s32 ConfigParser::getValueFromKeyValue(std::string value_pair,std::string expectedKey,std::string delimiter) { int32_t ConfigParser::getValueFromKeyValue(std::string value_pair,std::string expectedKey,std::string delimiter) {
std::vector<std::string> string_value = StringTools::stringSplit(value_pair,delimiter); std::vector<std::string> string_value = StringTools::stringSplit(value_pair,delimiter);
if(string_value.size() != 2) { if(string_value.size() != 2) {
if(HID_DEBUG || string_value.size() > 2) { if(HID_DEBUG || string_value.size() > 2) {
@ -398,7 +398,7 @@ s32 ConfigParser::getValueFromKeyValue(std::string value_pair,std::string expect
return -1; return -1;
} }
char * ptr; char * ptr;
s32 value = strtol(string_value[1].c_str(),&ptr,16); int32_t value = strtol(string_value[1].c_str(),&ptr,16);
return value; return value;
} }

24
source/config/ConfigParser.hpp
View File

@ -46,29 +46,29 @@ private:
PARSE_TYPE getType(); PARSE_TYPE getType();
void setType(PARSE_TYPE newType); void setType(PARSE_TYPE newType);
u16 getSlot(); uint16_t getSlot();
void setSlot(u16 newSlot); void setSlot(uint16_t newSlot);
bool parseIni(); BOOL parseIni();
bool Init(); BOOL Init();
bool parseConfigString(std::string content); BOOL parseConfigString(std::string content);
s32 getSlotController(std::string identify); int32_t getSlotController(std::string identify);
s32 checkExistingController(s32 vid, s32 pid); int32_t checkExistingController(int32_t vid, int32_t pid);
s32 getValueFromKeyValue(std::string value_pair,std::string expectedKey,std::string delimiter); int32_t getValueFromKeyValue(std::string value_pair,std::string expectedKey,std::string delimiter);
bool resetConfig(); BOOL resetConfig();
void parseSingleLine(std::string line); void parseSingleLine(std::string line);
u16 slot_b; uint16_t slot_b;
PARSE_TYPE type_b; PARSE_TYPE type_b;
u16 vid; uint16_t vid;
u16 pid; uint16_t pid;
std::string content; std::string content;
std::vector<std::string> contentLines; std::vector<std::string> contentLines;

20
source/config/ConfigValues.cpp
View File

@ -33,8 +33,8 @@ ConfigValues::~ConfigValues() {
} }
} }
const u8 * ConfigValues::getValuesForPreset(std::map<std::string,const u8*> values,std::string possibleValue) { const uint8_t * ConfigValues::getValuesForPreset(std::map<std::string,const uint8_t*> values,std::string possibleValue) {
std::map<std::string,const u8*>::iterator it; std::map<std::string,const uint8_t*>::iterator it;
it = values.find(possibleValue); it = values.find(possibleValue);
if (it != values.end()) { if (it != values.end()) {
return it->second; return it->second;
@ -42,7 +42,7 @@ const u8 * ConfigValues::getValuesForPreset(std::map<std::string,const u8*> valu
return NULL; return NULL;
} }
bool ConfigValues::setIfValueIsAControllerPresetEx(std::string value,s32 slot,s32 keyslot) { BOOL ConfigValues::setIfValueIsAControllerPresetEx(std::string value,int32_t slot,int32_t keyslot) {
if(setIfValueIsPreset(presetGCValues,value,slot,keyslot)) return true; if(setIfValueIsPreset(presetGCValues,value,slot,keyslot)) return true;
if(setIfValueIsPreset(presetDS3Values,value,slot,keyslot)) return true; if(setIfValueIsPreset(presetDS3Values,value,slot,keyslot)) return true;
if(setIfValueIsPreset(presetDS4Values,value,slot,keyslot)) return true; if(setIfValueIsPreset(presetDS4Values,value,slot,keyslot)) return true;
@ -52,11 +52,11 @@ bool ConfigValues::setIfValueIsAControllerPresetEx(std::string value,s32 slot,s3
} }
//We need this function here so we can use preset sticks. //We need this function here so we can use preset sticks.
bool ConfigValues::setIfValueIsPreset(std::map<std::string,const u8*> values,std::string possibleValue,s32 slot,s32 keyslot) { BOOL ConfigValues::setIfValueIsPreset(std::map<std::string,const uint8_t*> values,std::string possibleValue,int32_t slot,int32_t keyslot) {
if(slot > gHIDMaxDevices || slot < 0 || keyslot < 0 || keyslot >= CONTRPS_MAX_VALUE) { if(slot > gHIDMaxDevices || slot < 0 || keyslot < 0 || keyslot >= CONTRPS_MAX_VALUE) {
return false; return false;
} }
const u8 * values_ = NULL; const uint8_t * values_ = NULL;
if( keyslot == CONTRPS_VPAD_BUTTON_L_STICK_X || if( keyslot == CONTRPS_VPAD_BUTTON_L_STICK_X ||
keyslot == CONTRPS_VPAD_BUTTON_L_STICK_Y || keyslot == CONTRPS_VPAD_BUTTON_L_STICK_Y ||
keyslot == CONTRPS_VPAD_BUTTON_R_STICK_X || keyslot == CONTRPS_VPAD_BUTTON_R_STICK_X ||
@ -90,7 +90,7 @@ bool ConfigValues::setIfValueIsPreset(std::map<std::string,const u8*> values,std
} }
s32 ConfigValues::getValueFromMap(std::map<std::string,int> values,std::string nameOfString) { int32_t ConfigValues::getValueFromMap(std::map<std::string,int> values,std::string nameOfString) {
std::map<std::string,int>::iterator it; std::map<std::string,int>::iterator it;
it = values.find(nameOfString); it = values.find(nameOfString);
if (it != values.end()) { if (it != values.end()) {
@ -101,8 +101,8 @@ s32 ConfigValues::getValueFromMap(std::map<std::string,int> values,std::string n
return -1; return -1;
} }
s32 ConfigValues::getPresetValueEx(std::string possibleString) { int32_t ConfigValues::getPresetValueEx(std::string possibleString) {
s32 rightValue = -1; int32_t rightValue = -1;
if((rightValue = getValueFromMap(gGamePadValuesToCONTRPSString,possibleString))!= -1) { if((rightValue = getValueFromMap(gGamePadValuesToCONTRPSString,possibleString))!= -1) {
if(HID_DEBUG) { if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("Used pre-defined VPAD_VALUE! \"%s\" is %d\n",possibleString.c_str(),rightValue); DEBUG_FUNCTION_LINE("Used pre-defined VPAD_VALUE! \"%s\" is %d\n",possibleString.c_str(),rightValue);
@ -115,11 +115,11 @@ s32 ConfigValues::getPresetValueEx(std::string possibleString) {
return rightValue; return rightValue;
} }
void ConfigValues::addDeviceNameEx(u16 vid,u16 pid,std::string value) { void ConfigValues::addDeviceNameEx(uint16_t vid,uint16_t pid,std::string value) {
deviceNames[StringTools::strfmt("%04X%04X",vid,pid).c_str()] = value; deviceNames[StringTools::strfmt("%04X%04X",vid,pid).c_str()] = value;
} }
std::string ConfigValues::getStringByVIDPIDEx(u16 vid,u16 pid) { std::string ConfigValues::getStringByVIDPIDEx(uint16_t vid,uint16_t pid) {
std::string result = ""; std::string result = "";
std::map<std::string,std::string>::iterator it; std::map<std::string,std::string>::iterator it;

48
source/config/ConfigValues.hpp
View File

@ -48,7 +48,7 @@ private:
/** /**
Returns NULL if not a preset! Returns NULL if not a preset!
**/ **/
static const u8 * getValuesStickPreset(std::string possibleValue) static const uint8_t * getValuesStickPreset(std::string possibleValue)
{ {
ConfigValues * cur_instance = getInstance(); ConfigValues * cur_instance = getInstance();
if(cur_instance == NULL) return NULL; if(cur_instance == NULL) return NULL;
@ -58,7 +58,7 @@ private:
/** /**
Returns -1 if not found Returns -1 if not found
**/ **/
static s32 getKeySlotGamePad(std::string possibleValue) static int32_t getKeySlotGamePad(std::string possibleValue)
{ {
ConfigValues * cur_instance = getInstance(); ConfigValues * cur_instance = getInstance();
if(cur_instance == NULL) return -1; if(cur_instance == NULL) return -1;
@ -67,7 +67,7 @@ private:
/** /**
Returns -1 if not found Returns -1 if not found
**/ **/
static s32 getKeySlotMouse(std::string possibleValue) static int32_t getKeySlotMouse(std::string possibleValue)
{ {
ConfigValues * cur_instance = getInstance(); ConfigValues * cur_instance = getInstance();
if(cur_instance == NULL) return -1; if(cur_instance == NULL) return -1;
@ -77,7 +77,7 @@ private:
/** /**
Returns -1 if not found Returns -1 if not found
**/ **/
static s32 getKeySlotDefaultSingleValue(std::string possibleValue) static int32_t getKeySlotDefaultSingleValue(std::string possibleValue)
{ {
ConfigValues * cur_instance = getInstance(); ConfigValues * cur_instance = getInstance();
if(cur_instance == NULL) return -1; if(cur_instance == NULL) return -1;
@ -87,7 +87,7 @@ private:
/** /**
Returns -1 if not found Returns -1 if not found
**/ **/
static s32 getKeySlotDefaultPairedValue(std::string possibleValue) static int32_t getKeySlotDefaultPairedValue(std::string possibleValue)
{ {
ConfigValues * cur_instance = getInstance(); ConfigValues * cur_instance = getInstance();
if(cur_instance == NULL) return -1; if(cur_instance == NULL) return -1;
@ -97,7 +97,7 @@ private:
/** /**
Returns -1 if not found Returns -1 if not found
**/ **/
static s32 getPresetValuesKeyboard(std::string possibleValue) static int32_t getPresetValuesKeyboard(std::string possibleValue)
{ {
ConfigValues * cur_instance = getInstance(); ConfigValues * cur_instance = getInstance();
if(cur_instance == NULL) return -1; if(cur_instance == NULL) return -1;
@ -107,7 +107,7 @@ private:
/** /**
Returns -1 if not found Returns -1 if not found
**/ **/
static s32 getPresetValue(std::string possibleValue) static int32_t getPresetValue(std::string possibleValue)
{ {
ConfigValues * cur_instance = getInstance(); ConfigValues * cur_instance = getInstance();
if(cur_instance == NULL) return -1; if(cur_instance == NULL) return -1;
@ -117,14 +117,14 @@ private:
/** /**
Returns -1 if not found Returns -1 if not found
**/ **/
static s32 setIfValueIsAControllerPreset(std::string value,s32 slot,s32 keyslot) static int32_t setIfValueIsAControllerPreset(std::string value,int32_t slot,int32_t keyslot)
{ {
ConfigValues * cur_instance = getInstance(); ConfigValues * cur_instance = getInstance();
if(cur_instance == NULL) return -1; if(cur_instance == NULL) return -1;
return cur_instance->setIfValueIsAControllerPresetEx(value,slot,keyslot); return cur_instance->setIfValueIsAControllerPresetEx(value,slot,keyslot);
} }
static void addDeviceName(u16 vid,u16 pid,std::string value){ static void addDeviceName(uint16_t vid,uint16_t pid,std::string value){
ConfigValues * cur_instance = getInstance(); ConfigValues * cur_instance = getInstance();
if(cur_instance != NULL){ if(cur_instance != NULL){
cur_instance->addDeviceNameEx(vid,pid,value); cur_instance->addDeviceNameEx(vid,pid,value);
@ -134,7 +134,7 @@ private:
/** /**
Returns empty String if not found Returns empty String if not found
**/ **/
static std::string getStringByVIDPID(u16 vid,u16 pid){ static std::string getStringByVIDPID(uint16_t vid,uint16_t pid){
ConfigValues * cur_instance = getInstance(); ConfigValues * cur_instance = getInstance();
if(cur_instance == NULL) return ""; if(cur_instance == NULL) return "";
return cur_instance->getStringByVIDPIDEx(vid,pid); return cur_instance->getStringByVIDPIDEx(vid,pid);
@ -156,18 +156,18 @@ private:
std::map<std::string,std::string> deviceNames; std::map<std::string,std::string> deviceNames;
std::map<std::string,const u8*> presetGCValues; std::map<std::string,const uint8_t*> presetGCValues;
std::map<std::string,const u8*> presetDS3Values; std::map<std::string,const uint8_t*> presetDS3Values;
std::map<std::string,const u8*> presetDS4Values; std::map<std::string,const uint8_t*> presetDS4Values;
std::map<std::string,const u8*> presetXInputValues; std::map<std::string,const uint8_t*> presetXInputValues;
std::map<std::string,const u8*> presetSwitchProValues; std::map<std::string,const uint8_t*> presetSwitchProValues;
std::map<std::string,const u8*> presetSticks; std::map<std::string,const uint8_t*> presetSticks;
s32 getValueFromMap(std::map<std::string,int> values,std::string nameOfString); int32_t getValueFromMap(std::map<std::string,int> values,std::string nameOfString);
bool checkIfValueIsAControllerPreset(std::string value,s32 slot,s32 keyslot); BOOL checkIfValueIsAControllerPreset(std::string value,int32_t slot,int32_t keyslot);
s32 getPresetValueEx(std::string possibleString); int32_t getPresetValueEx(std::string possibleString);
void InitValues(){ void InitValues(){
DEBUG_FUNCTION_LINE("Init values for the configuration\n"); DEBUG_FUNCTION_LINE("Init values for the configuration\n");
@ -563,12 +563,12 @@ private:
deviceNames[StringTools::strfmt("%04X%04X",HID_SWITCH_PRO_VID,HID_SWITCH_PRO_PID).c_str()] = HID_SWITCH_PRO_STRING; deviceNames[StringTools::strfmt("%04X%04X",HID_SWITCH_PRO_VID,HID_SWITCH_PRO_PID).c_str()] = HID_SWITCH_PRO_STRING;
} }
const u8 * getValuesForPreset(std::map<std::string,const u8*> values,std::string possibleValue); const uint8_t * getValuesForPreset(std::map<std::string,const uint8_t*> values,std::string possibleValue);
bool setIfValueIsPreset(std::map<std::string,const u8*> values,std::string possibleValue,s32 slot,s32 keyslot); BOOL setIfValueIsPreset(std::map<std::string,const uint8_t*> values,std::string possibleValue,int32_t slot,int32_t keyslot);
bool setIfValueIsAControllerPresetEx(std::string value,s32 slot,s32 keyslot); BOOL setIfValueIsAControllerPresetEx(std::string value,int32_t slot,int32_t keyslot);
void addDeviceNameEx(u16 vid,u16 pid,std::string value); void addDeviceNameEx(uint16_t vid,uint16_t pid,std::string value);
std::string getStringByVIDPIDEx(u16 vid,u16 pid); std::string getStringByVIDPIDEx(uint16_t vid,uint16_t pid);
}; };
#endif #endif

34
source/network/CPTCPServer.cpp
View File

@ -23,7 +23,7 @@
CPTCPServer * CPTCPServer::instance = NULL; CPTCPServer * CPTCPServer::instance = NULL;
CPTCPServer::CPTCPServer(s32 port): TCPServer(port,CPTCPServer::getPriority()) { CPTCPServer::CPTCPServer(int32_t port): TCPServer(port,CPTCPServer::getPriority()) {
CPTCPServer::AttachDetach(HID_DEVICE_DETACH); CPTCPServer::AttachDetach(HID_DEVICE_DETACH);
} }
@ -40,8 +40,8 @@ void CPTCPServer::AttachDetach(HIDAttachEvent attach) {
} }
} }
for(s32 i= 0; i< gHIDMaxDevices; i++) { for(int32_t i= 0; i< gHIDMaxDevices; i++) {
for(s32 j= 0; j< HID_MAX_PADS_COUNT; j++) { for(int32_t j= 0; j< HID_MAX_PADS_COUNT; j++) {
if(gNetworkController[i][j][NETWORK_CONTROLLER_ACTIVE] > 0) { if(gNetworkController[i][j][NETWORK_CONTROLLER_ACTIVE] > 0) {
DEBUG_FUNCTION_LINE("Found a registered pad in deviceslot %d and padslot %d! Lets detach it.\n",i,j); DEBUG_FUNCTION_LINE("Found a registered pad in deviceslot %d and padslot %d! Lets detach it.\n",i,j);
HIDDevice device; HIDDevice device;
@ -72,9 +72,9 @@ void CPTCPServer::DetachAndDelete() {
memset(&gNetworkController,0,sizeof(gNetworkController)); memset(&gNetworkController,0,sizeof(gNetworkController));
} }
bool CPTCPServer::whileLoop() { BOOL CPTCPServer::whileLoop() {
s32 ret; int32_t ret;
s32 clientfd = getClientFD(); int32_t clientfd = getClientFD();
while (1) { while (1) {
if(shouldExit()) { if(shouldExit()) {
break; break;
@ -91,7 +91,7 @@ bool CPTCPServer::whileLoop() {
switch (ret) { switch (ret) {
case WIIU_CP_TCP_ATTACH: { /*attach */ case WIIU_CP_TCP_ATTACH: { /*attach */
if(gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) { if(gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) {
s32 handle; int32_t handle;
ret = recvwait(clientfd, &handle, 4); ret = recvwait(clientfd, &handle, 4);
if(ret < 0) { if(ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: recvwait handle\n",WIIU_CP_TCP_ATTACH); DEBUG_FUNCTION_LINE("Error in %02X: recvwait handle\n",WIIU_CP_TCP_ATTACH);
@ -100,8 +100,8 @@ bool CPTCPServer::whileLoop() {
if(HID_DEBUG) { if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("got handle %d\n",handle); DEBUG_FUNCTION_LINE("got handle %d\n",handle);
} }
u16 vid = 0; uint16_t vid = 0;
u16 pid = 0; uint16_t pid = 0;
ret = recvwait(clientfd, &vid, 2); ret = recvwait(clientfd, &vid, 2);
if(ret < 0) { if(ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: recvwait vid\n",WIIU_CP_TCP_ATTACH); DEBUG_FUNCTION_LINE("Error in %02X: recvwait vid\n",WIIU_CP_TCP_ATTACH);
@ -185,7 +185,7 @@ bool CPTCPServer::whileLoop() {
} }
case WIIU_CP_TCP_DETACH: { /*detach */ case WIIU_CP_TCP_DETACH: { /*detach */
if(gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) { if(gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) {
s32 handle; int32_t handle;
ret = recvwait(clientfd, &handle, 4); ret = recvwait(clientfd, &handle, 4);
if(ret < 0) { if(ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: recvwait handle\n",WIIU_CP_TCP_DETACH); DEBUG_FUNCTION_LINE("Error in %02X: recvwait handle\n",WIIU_CP_TCP_DETACH);
@ -207,13 +207,13 @@ bool CPTCPServer::whileLoop() {
return false; return false;
break; break;
} }
s32 deviceslot = user->slotdata.deviceslot; int32_t deviceslot = user->slotdata.deviceslot;
if(HID_DEBUG) { if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("device slot is: %d , pad slot is: %d\n",deviceslot,user->pad_slot); DEBUG_FUNCTION_LINE("device slot is: %d , pad slot is: %d\n",deviceslot,user->pad_slot);
} }
DeviceVIDPIDInfo vidpid; DeviceVIDPIDInfo vidpid;
s32 result; int32_t result;
if((result = ControllerPatcherUtils::getVIDPIDbyDeviceSlot(deviceslot,&vidpid)) < 0) { if((result = ControllerPatcherUtils::getVIDPIDbyDeviceSlot(deviceslot,&vidpid)) < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: Couldn't find a valid VID/PID for device slot %d. Error: %d\n",WIIU_CP_TCP_DETACH,deviceslot,ret); DEBUG_FUNCTION_LINE("Error in %02X: Couldn't find a valid VID/PID for device slot %d. Error: %d\n",WIIU_CP_TCP_DETACH,deviceslot,ret);
return false; return false;
@ -242,7 +242,7 @@ bool CPTCPServer::whileLoop() {
if(HID_DEBUG) { if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("Got Ping, sending now a Pong\n"); DEBUG_FUNCTION_LINE("Got Ping, sending now a Pong\n");
} }
s32 ret = sendbyte(clientfd, WIIU_CP_TCP_PONG); int32_t ret = sendbyte(clientfd, WIIU_CP_TCP_PONG);
if(ret < 0) { if(ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: sendbyte PONG\n"); DEBUG_FUNCTION_LINE("Error in %02X: sendbyte PONG\n");
return false; return false;
@ -260,21 +260,21 @@ bool CPTCPServer::whileLoop() {
return true; return true;
} }
bool CPTCPServer::acceptConnection() { BOOL CPTCPServer::acceptConnection() {
s32 clientfd = getClientFD(); int32_t clientfd = getClientFD();
DEBUG_FUNCTION_LINE("TCP Connection accepted! Sending my protocol version: %d (0x%02X)\n", (WIIU_CP_TCP_HANDSHAKE - WIIU_CP_TCP_HANDSHAKE_VERSION_1)+1,WIIU_CP_TCP_HANDSHAKE); DEBUG_FUNCTION_LINE("TCP Connection accepted! Sending my protocol version: %d (0x%02X)\n", (WIIU_CP_TCP_HANDSHAKE - WIIU_CP_TCP_HANDSHAKE_VERSION_1)+1,WIIU_CP_TCP_HANDSHAKE);
gUDPClientip = getSockAddr().sin_addr.s_addr; gUDPClientip = getSockAddr().sin_addr.s_addr;
UDPClient::createInstance(); UDPClient::createInstance();
s32 ret; int32_t ret;
ret = sendbyte(clientfd, WIIU_CP_TCP_HANDSHAKE); //Hey I'm a WiiU console! ret = sendbyte(clientfd, WIIU_CP_TCP_HANDSHAKE); //Hey I'm a WiiU console!
if(ret < 0) { if(ret < 0) {
DEBUG_FUNCTION_LINE("Error sendbyte: %02X\n",WIIU_CP_TCP_HANDSHAKE); DEBUG_FUNCTION_LINE("Error sendbyte: %02X\n",WIIU_CP_TCP_HANDSHAKE);
return false; return false;
} }
u8 clientProtocolVersion = recvbyte(clientfd); uint8_t clientProtocolVersion = recvbyte(clientfd);
if(ret < 0) { if(ret < 0) {
DEBUG_FUNCTION_LINE("Error recvbyte: %02X\n",WIIU_CP_TCP_HANDSHAKE); DEBUG_FUNCTION_LINE("Error recvbyte: %02X\n",WIIU_CP_TCP_HANDSHAKE);
return false; return false;

10
source/network/CPTCPServer.hpp
View File

@ -65,8 +65,8 @@ private:
} }
} }
static s32 getPriority() { static int32_t getPriority() {
s32 priority = 28; int32_t priority = 28;
if(OSGetTitleID() == 0x00050000101c9300 || //The Legend of Zelda Breath of the Wild JPN if(OSGetTitleID() == 0x00050000101c9300 || //The Legend of Zelda Breath of the Wild JPN
OSGetTitleID() == 0x00050000101c9400 || //The Legend of Zelda Breath of the Wild USA OSGetTitleID() == 0x00050000101c9400 || //The Legend of Zelda Breath of the Wild USA
OSGetTitleID() == 0x00050000101c9500 || //The Legend of Zelda Breath of the Wild EUR OSGetTitleID() == 0x00050000101c9500 || //The Legend of Zelda Breath of the Wild EUR
@ -78,7 +78,7 @@ private:
return priority; return priority;
} }
CPTCPServer(s32 port); CPTCPServer(int32_t port);
virtual ~CPTCPServer(); virtual ~CPTCPServer();
@ -88,9 +88,9 @@ private:
virtual void DetachAndDelete(); virtual void DetachAndDelete();
virtual bool whileLoop(); virtual BOOL whileLoop();
virtual bool acceptConnection(); virtual BOOL acceptConnection();
virtual void onConnectionClosed(); virtual void onConnectionClosed();

6
source/network/UDPClient.cpp
View File

@ -24,7 +24,7 @@
UDPClient * UDPClient::instance = NULL; UDPClient * UDPClient::instance = NULL;
UDPClient::UDPClient(u32 ip, s32 port) { UDPClient::UDPClient(uint32_t ip, int32_t port) {
sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (sockfd < 0) if (sockfd < 0)
return; return;
@ -50,12 +50,12 @@ UDPClient::~UDPClient() {
} }
} }
bool UDPClient::sendData(char * data,s32 length) { BOOL UDPClient::sendData(char * data,int32_t length) {
if(sockfd < 0 || data == 0 || length < 0 || gUsedProtocolVersion < WIIU_CP_TCP_HANDSHAKE_VERSION_3) { if(sockfd < 0 || data == 0 || length < 0 || gUsedProtocolVersion < WIIU_CP_TCP_HANDSHAKE_VERSION_3) {
return false; return false;
} }
if(length > 1400) length = 1400; if(length > 1400) length = 1400;
s32 ret = send(sockfd, data, length, 0); int32_t ret = send(sockfd, data, length, 0);
return (ret >= 0); return (ret >= 0);
} }

6
source/network/UDPClient.hpp
View File

@ -52,11 +52,11 @@ private:
} }
} }
UDPClient(u32 ip,s32 port); UDPClient(uint32_t ip,int32_t port);
~UDPClient(); ~UDPClient();
bool sendData(char * data, s32 length); BOOL sendData(char * data, int32_t length);
volatile s32 sockfd = -1; volatile int32_t sockfd = -1;
struct sockaddr_in addr; struct sockaddr_in addr;
static UDPClient *instance; static UDPClient *instance;
}; };

40
source/network/UDPServer.cpp
View File

@ -26,8 +26,8 @@
CThread * UDPServer::pThread = NULL; CThread * UDPServer::pThread = NULL;
UDPServer * UDPServer::instance = NULL; UDPServer * UDPServer::instance = NULL;
UDPServer::UDPServer(s32 port) { UDPServer::UDPServer(int32_t port) {
s32 ret; int32_t ret;
struct sockaddr_in addr; struct sockaddr_in addr;
addr.sin_family = AF_INET; addr.sin_family = AF_INET;
@ -36,7 +36,7 @@ UDPServer::UDPServer(s32 port) {
this->sockfd = ret = socket(AF_INET, SOCK_DGRAM, 0); this->sockfd = ret = socket(AF_INET, SOCK_DGRAM, 0);
if(ret == -1) return; if(ret == -1) return;
s32 enable = 1; int32_t enable = 1;
setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable)); setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable));
ret = bind(sockfd, (sockaddr *)&addr, 16); ret = bind(sockfd, (sockaddr *)&addr, 16);
if(ret < 0) return; if(ret < 0) return;
@ -65,7 +65,7 @@ UDPServer::~UDPServer() {
} }
void UDPServer::StartUDPThread(UDPServer * server) { void UDPServer::StartUDPThread(UDPServer * server) {
s32 priority = 28; int32_t priority = 28;
if(OSGetTitleID() == 0x00050000101c9300 || //The Legend of Zelda Breath of the Wild JPN if(OSGetTitleID() == 0x00050000101c9300 || //The Legend of Zelda Breath of the Wild JPN
OSGetTitleID() == 0x00050000101c9400 || //The Legend of Zelda Breath of the Wild USA OSGetTitleID() == 0x00050000101c9400 || //The Legend of Zelda Breath of the Wild USA
OSGetTitleID() == 0x00050000101c9500 || //The Legend of Zelda Breath of the Wild EUR OSGetTitleID() == 0x00050000101c9500 || //The Legend of Zelda Breath of the Wild EUR
@ -78,12 +78,12 @@ void UDPServer::StartUDPThread(UDPServer * server) {
UDPServer::pThread->resumeThread(); UDPServer::pThread->resumeThread();
} }
bool UDPServer::cpyIncrementBufferOffset(void * target, void * source, s32 * offset, s32 typesize, s32 maximum) { BOOL UDPServer::cpyIncrementBufferOffset(void * target, void * source, int32_t * offset, int32_t typesize, int32_t maximum) {
if(((int)*offset + typesize) > maximum) { if(((int)*offset + typesize) > maximum) {
DEBUG_FUNCTION_LINE("Transfer error. Excepted %04X bytes, but only got %04X\n",(*offset + typesize),maximum); DEBUG_FUNCTION_LINE("Transfer error. Excepted %04X bytes, but only got %04X\n",(*offset + typesize),maximum);
return false; return false;
} }
memcpy(target,(void*)((u32)source+(*offset)),typesize); memcpy(target,(void*)((uint32_t)source+(*offset)),typesize);
*offset += typesize; *offset += typesize;
return true; return true;
} }
@ -94,46 +94,46 @@ void UDPServer::DoUDPThread(CThread *thread, void *arg) {
} }
void UDPServer::DoUDPThreadInternal() { void UDPServer::DoUDPThreadInternal() {
u8 buffer[MAX_UDP_SIZE]; uint8_t buffer[MAX_UDP_SIZE];
s32 n; int32_t n;
my_cb_user user; my_cb_user user;
while(1) { while(1) {
//s32 usingVar = exitThread; //int32_t usingVar = exitThread;
if(exitThread)break; if(exitThread)break;
memset(buffer,0,MAX_UDP_SIZE); memset(buffer,0,MAX_UDP_SIZE);
n = recv(sockfd,buffer,MAX_UDP_SIZE,0); n = recv(sockfd,buffer,MAX_UDP_SIZE,0);
if (n < 0) { if (n < 0) {
s32 errno_ = socketlasterr(); int32_t errno_ = socketlasterr();
OSSleepTicks(OSMicrosecondsToTicks(2000)); OSSleepTicks(OSMicrosecondsToTicks(2000));
if(errno_ != 11 && errno_ != 9) { if(errno_ != 11 && errno_ != 9) {
break; break;
} }
continue; continue;
} }
s32 bufferoffset = 0; int32_t bufferoffset = 0;
u8 type; uint8_t type;
memcpy((void *)&type,buffer,sizeof(type)); memcpy((void *)&type,buffer,sizeof(type));
bufferoffset += sizeof(type); bufferoffset += sizeof(type);
switch (buffer[0]) { switch (buffer[0]) {
case WIIU_CP_UDP_CONTROLLER_READ_DATA: { case WIIU_CP_UDP_CONTROLLER_READ_DATA: {
if(gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) { if(gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) {
u8 count_commands; uint8_t count_commands;
memcpy((void *)&count_commands,buffer+bufferoffset,sizeof(count_commands)); memcpy((void *)&count_commands,buffer+bufferoffset,sizeof(count_commands));
bufferoffset += sizeof(count_commands); bufferoffset += sizeof(count_commands);
for(s32 i = 0; i<count_commands; i++) { for(int32_t i = 0; i<count_commands; i++) {
s32 handle; int32_t handle;
u16 deviceSlot; uint16_t deviceSlot;
u32 hid; uint32_t hid;
u8 padslot; uint8_t padslot;
u8 datasize; uint8_t datasize;
if(!cpyIncrementBufferOffset((void *)&handle, (void *)buffer,&bufferoffset,sizeof(handle), n))continue; if(!cpyIncrementBufferOffset((void *)&handle, (void *)buffer,&bufferoffset,sizeof(handle), n))continue;
if(!cpyIncrementBufferOffset((void *)&deviceSlot, (void *)buffer,&bufferoffset,sizeof(deviceSlot),n))continue; if(!cpyIncrementBufferOffset((void *)&deviceSlot, (void *)buffer,&bufferoffset,sizeof(deviceSlot),n))continue;
hid = (1 << deviceSlot); hid = (1 << deviceSlot);
if(!cpyIncrementBufferOffset((void *)&padslot, (void *)buffer,&bufferoffset,sizeof(padslot), n))continue; if(!cpyIncrementBufferOffset((void *)&padslot, (void *)buffer,&bufferoffset,sizeof(padslot), n))continue;
if(!cpyIncrementBufferOffset((void *)&datasize, (void *)buffer,&bufferoffset,sizeof(datasize), n))continue; if(!cpyIncrementBufferOffset((void *)&datasize, (void *)buffer,&bufferoffset,sizeof(datasize), n))continue;
u8 * databuffer = (u8*) malloc(datasize * sizeof(u8)); uint8_t * databuffer = (uint8_t*) malloc(datasize * sizeof(uint8_t));
if(!databuffer) { if(!databuffer) {
DEBUG_FUNCTION_LINE("Allocating memory failed\n"); DEBUG_FUNCTION_LINE("Allocating memory failed\n");
continue; continue;

8
source/network/UDPServer.hpp
View File

@ -40,15 +40,15 @@ private:
} }
} }
UDPServer(s32 port); UDPServer(int32_t port);
~UDPServer(); ~UDPServer();
void StartUDPThread(UDPServer * server); void StartUDPThread(UDPServer * server);
static void DoUDPThread(CThread *thread, void *arg); static void DoUDPThread(CThread *thread, void *arg);
void DoUDPThreadInternal(); void DoUDPThreadInternal();
bool cpyIncrementBufferOffset(void * target, void * source, s32 * offset, s32 typesize, s32 maximum); BOOL cpyIncrementBufferOffset(void * target, void * source, int32_t * offset, int32_t typesize, int32_t maximum);
volatile s32 sockfd = -1; volatile int32_t sockfd = -1;
volatile s32 exitThread = 0; volatile int32_t exitThread = 0;
static UDPServer *instance; static UDPServer *instance;
static CThread *pThread; static CThread *pThread;

116
source/patcher/ControllerPatcherHID.cpp
View File

@ -26,13 +26,13 @@
* public implementation for the network controller * public implementation for the network controller
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/ *---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
s32 ControllerPatcherHID::externAttachDetachCallback(HIDDevice *p_device, HIDAttachEvent attach) { int32_t ControllerPatcherHID::externAttachDetachCallback(HIDDevice *p_device, HIDAttachEvent attach) {
HIDClient client; HIDClient client;
memset(&client,0,sizeof(client)); memset(&client,0,sizeof(client));
return AttachDetachCallback(&client,p_device,attach); return AttachDetachCallback(&client,p_device,attach);
} }
void ControllerPatcherHID::externHIDReadCallback(u32 handle, unsigned char *buf, u32 bytes_transfered, my_cb_user * usr) { void ControllerPatcherHID::externHIDReadCallback(uint32_t handle, unsigned char *buf, uint32_t bytes_transfered, my_cb_user * usr) {
HIDReadCallback(handle,buf,bytes_transfered,usr); HIDReadCallback(handle,buf,bytes_transfered,usr);
} }
@ -40,15 +40,15 @@ void ControllerPatcherHID::externHIDReadCallback(u32 handle, unsigned char *buf,
* private implementation for the HID Api. * private implementation for the HID Api.
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/ *---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
s32 ControllerPatcherHID::myAttachDetachCallback(HIDClient *p_client, HIDDevice *p_device, HIDAttachEvent attach) { int32_t ControllerPatcherHID::myAttachDetachCallback(HIDClient *p_client, HIDDevice *p_device, HIDAttachEvent attach) {
return AttachDetachCallback(p_client,p_device,attach); return AttachDetachCallback(p_client,p_device,attach);
} }
void ControllerPatcherHID::myHIDMouseReadCallback(u32 handle, s32 error, unsigned char *buf, u32 bytes_transfered, void *p_user) { void ControllerPatcherHID::myHIDMouseReadCallback(uint32_t handle, int32_t error, unsigned char *buf, uint32_t bytes_transfered, void *p_user) {
if(error == 0) { if(error == 0) {
my_cb_user *usr = (my_cb_user*)p_user; my_cb_user *usr = (my_cb_user*)p_user;
u32 slot = 0; uint32_t slot = 0;
if(usr->pad_slot < HID_MAX_PADS_COUNT) { if(usr->pad_slot < HID_MAX_PADS_COUNT) {
slot = usr->pad_slot; slot = usr->pad_slot;
} }
@ -63,8 +63,8 @@ void ControllerPatcherHID::myHIDMouseReadCallback(u32 handle, s32 error, unsigne
buf +=1; buf +=1;
} }
s8 x_value = 0; int8_t x_value = 0;
s8 y_value = 0; int8_t y_value = 0;
x_value = buf[1]; x_value = buf[1];
y_value = buf[2]; y_value = buf[2];
@ -92,7 +92,7 @@ void ControllerPatcherHID::myHIDMouseReadCallback(u32 handle, s32 error, unsigne
} }
} }
void ControllerPatcherHID::myHIDReadCallback(u32 handle, s32 error, unsigned char *buf, u32 bytes_transfered, void *p_user) { void ControllerPatcherHID::myHIDReadCallback(uint32_t handle, int32_t error, unsigned char *buf, uint32_t bytes_transfered, void *p_user) {
if(error == 0 && p_user != NULL && gHIDAttached) { if(error == 0 && p_user != NULL && gHIDAttached) {
my_cb_user *usr = (my_cb_user*)p_user; my_cb_user *usr = (my_cb_user*)p_user;
@ -109,7 +109,7 @@ void ControllerPatcherHID::myHIDReadCallback(u32 handle, s32 error, unsigned cha
* Intern Callback actions * Intern Callback actions
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/ *---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
s32 ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevice *p_device, HIDAttachEvent attach) { int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevice *p_device, HIDAttachEvent attach) {
if(attach) { if(attach) {
DEBUG_FUNCTION_LINE("vid %04x pid %04x connected\n", SWAP16(p_device->vid),SWAP16(p_device->pid)); DEBUG_FUNCTION_LINE("vid %04x pid %04x connected\n", SWAP16(p_device->vid),SWAP16(p_device->pid));
if(HID_DEBUG) { if(HID_DEBUG) {
@ -140,7 +140,7 @@ s32 ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevice *p
slotdata->deviceslot = gMouseSlot; slotdata->deviceslot = gMouseSlot;
//DEBUG_FUNCTION_LINE("Found Mouse: device: %s slot: %d\n",byte_to_binary(device_info.hid),device_info.slot); //DEBUG_FUNCTION_LINE("Found Mouse: device: %s slot: %d\n",byte_to_binary(device_info.hid),device_info.slot);
} else { } else {
s32 ret; int32_t ret;
if((ret = ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info)) < 0) { if((ret = ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info)) < 0) {
DEBUG_FUNCTION_LINE("ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info) failed %d \n",ret); DEBUG_FUNCTION_LINE("ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info) failed %d \n",ret);
return HID_DEVICE_DETACH; return HID_DEVICE_DETACH;
@ -151,7 +151,7 @@ s32 ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevice *p
if(slotdata->hidmask) { if(slotdata->hidmask) {
if(attach) { if(attach) {
s32 bufSize = 64; int32_t bufSize = 64;
if(slotdata->hidmask != gHID_LIST_MOUSE && config_controller[slotdata->deviceslot][CONTRPS_BUF_SIZE][0] == CONTROLLER_PATCHER_VALUE_SET) { if(slotdata->hidmask != gHID_LIST_MOUSE && config_controller[slotdata->deviceslot][CONTRPS_BUF_SIZE][0] == CONTROLLER_PATCHER_VALUE_SET) {
bufSize = config_controller[slotdata->deviceslot][CONTRPS_BUF_SIZE][1]; bufSize = config_controller[slotdata->deviceslot][CONTRPS_BUF_SIZE][1];
} }
@ -164,7 +164,7 @@ s32 ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevice *p
usr->handle = p_device->handle; usr->handle = p_device->handle;
gHIDAttached |= slotdata->hidmask; gHIDAttached |= slotdata->hidmask;
gHIDCurrentDevice |= slotdata->hidmask; gHIDCurrentDevice |= slotdata->hidmask;
s32 pads_per_device = 1; int32_t pads_per_device = 1;
if(config_controller[slotdata->deviceslot][CONTRPS_PAD_COUNT][0] != CONTROLLER_PATCHER_INVALIDVALUE) { if(config_controller[slotdata->deviceslot][CONTRPS_PAD_COUNT][0] != CONTROLLER_PATCHER_INVALIDVALUE) {
pads_per_device = config_controller[slotdata->deviceslot][CONTRPS_PAD_COUNT][1]; pads_per_device = config_controller[slotdata->deviceslot][CONTRPS_PAD_COUNT][1];
if(pads_per_device > HID_MAX_PADS_COUNT) { //maximum of HID_MAX_PADS_COUNT if(pads_per_device > HID_MAX_PADS_COUNT) { //maximum of HID_MAX_PADS_COUNT
@ -172,14 +172,14 @@ s32 ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevice *p
} }
} }
s32 pad_count = config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1]; int32_t pad_count = config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1];
if(pad_count > 0x0F) pad_count = 0; //??? if(pad_count > 0x0F) pad_count = 0; //???
s32 pad_slot = 0; int32_t pad_slot = 0;
s32 failed = 1; int32_t failed = 1;
for(s32 i = 0; i<HID_MAX_PADS_COUNT; i += pads_per_device) { for(int32_t i = 0; i<HID_MAX_PADS_COUNT; i += pads_per_device) {
if(!(pad_count & (1 << i))) { if(!(pad_count & (1 << i))) {
failed = 0; failed = 0;
pad_count |= (1 << i); pad_count |= (1 << i);
@ -209,7 +209,7 @@ s32 ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevice *p
usr->pads_per_device = pads_per_device; usr->pads_per_device = pads_per_device;
usr->pad_slot = pad_slot; usr->pad_slot = pad_slot;
for(s32 i = 0; i<pads_per_device; i++) { for(int32_t i = 0; i<pads_per_device; i++) {
memset(&gHID_Devices[slotdata->deviceslot].pad_data[pad_slot+i],0,sizeof(HID_Data)); memset(&gHID_Devices[slotdata->deviceslot].pad_data[pad_slot+i],0,sizeof(HID_Data));
gHID_Devices[slotdata->deviceslot].pad_data[pad_slot+i].handle = p_device->handle; gHID_Devices[slotdata->deviceslot].pad_data[pad_slot+i].handle = p_device->handle;
@ -243,7 +243,7 @@ s32 ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevice *p
gHID_Mouse_Mode = HID_MOUSE_MODE_AIM; gHID_Mouse_Mode = HID_MOUSE_MODE_AIM;
HIDRead(p_device->handle, buf, p_device->maxPacketSizeRx, myHIDMouseReadCallback, usr); HIDRead(p_device->handle, buf, p_device->maxPacketSizeRx, myHIDMouseReadCallback, usr);
} else if (slotdata->hidmask == gHID_LIST_SWITCH_PRO) { } else if (slotdata->hidmask == gHID_LIST_SWITCH_PRO) {
s32 read_result = HIDRead(p_device->handle, usr->buf, usr->transfersize, NULL, NULL); int32_t read_result = HIDRead(p_device->handle, usr->buf, usr->transfersize, NULL, NULL);
if(read_result == 64) { if(read_result == 64) {
if(usr->buf[01] == 0x01) { //We need to do the handshake if(usr->buf[01] == 0x01) { //We need to do the handshake
DEBUG_FUNCTION_LINE("Switch Pro Controller handshake needed\n"); DEBUG_FUNCTION_LINE("Switch Pro Controller handshake needed\n");
@ -290,8 +290,8 @@ s32 ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevice *p
} else { } else {
my_cb_user * user_data = NULL; my_cb_user * user_data = NULL;
s32 founddata = 0; int32_t founddata = 0;
for(s32 i = 0; i<HID_MAX_PADS_COUNT; i++) { for(int32_t i = 0; i<HID_MAX_PADS_COUNT; i++) {
if(gHID_Devices[slotdata->deviceslot].pad_data[i].handle == p_device->handle) { if(gHID_Devices[slotdata->deviceslot].pad_data[i].handle == p_device->handle) {
gHID_Devices[slotdata->deviceslot].pad_data[i].handle = 0; gHID_Devices[slotdata->deviceslot].pad_data[i].handle = 0;
@ -348,7 +348,7 @@ s32 ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevice *p
return HID_DEVICE_DETACH; return HID_DEVICE_DETACH;
} }
void ControllerPatcherHID::HIDReadCallback(u32 handle, unsigned char *buf, u32 bytes_transfered, my_cb_user * usr) { void ControllerPatcherHID::HIDReadCallback(uint32_t handle, unsigned char *buf, uint32_t bytes_transfered, my_cb_user * usr) {
ControllerPatcherUtils::doSampling(usr->slotdata.deviceslot,usr->pad_slot,false); ControllerPatcherUtils::doSampling(usr->slotdata.deviceslot,usr->pad_slot,false);
//DEBUG_FUNCTION_LINE("my_read_cbInternal: %d %08X %d\n",bytes_transfered,usr->slotdata.hidmask,usr->slotdata.deviceslot); //DEBUG_FUNCTION_LINE("my_read_cbInternal: %d %08X %d\n",bytes_transfered,usr->slotdata.hidmask,usr->slotdata.deviceslot);
@ -356,7 +356,7 @@ void ControllerPatcherHID::HIDReadCallback(u32 handle, unsigned char *buf, u32 b
HID_Data * data_ptr = NULL; HID_Data * data_ptr = NULL;
//Copy the data for all 4 pads //Copy the data for all 4 pads
for(s32 i = 0; i<4; i++) { for(int32_t i = 0; i<4; i++) {
data_ptr = &(gHID_Devices[gHID_SLOT_GC].pad_data[i]); data_ptr = &(gHID_Devices[gHID_SLOT_GC].pad_data[i]);
memcpy(&(data_ptr->data_union.controller.last_hid_data[0]),&(data_ptr->data_union.controller.cur_hid_data[0]),10); //save last data. memcpy(&(data_ptr->data_union.controller.last_hid_data[0]),&(data_ptr->data_union.controller.cur_hid_data[0]),10); //save last data.
memcpy(&(data_ptr->data_union.controller.cur_hid_data[0]),&buf[(i*9)+1],9); //save new data. memcpy(&(data_ptr->data_union.controller.cur_hid_data[0]),&buf[(i*9)+1],9); //save new data.
@ -364,7 +364,7 @@ void ControllerPatcherHID::HIDReadCallback(u32 handle, unsigned char *buf, u32 b
} }
/* /*
s32 i = 0; int32_t i = 0;
DEBUG_FUNCTION_LINE("GC1 %08X: %02X %02X %02X %02X %02X %02X %02X %02X %02X ", buf[i*9+0],buf[i*9+1],buf[i*9+2],buf[i*9+3],buf[i*9+4],buf[i*9+5],buf[i*9+6],buf[i*9+7],buf[i*9+8]);i++; DEBUG_FUNCTION_LINE("GC1 %08X: %02X %02X %02X %02X %02X %02X %02X %02X %02X ", buf[i*9+0],buf[i*9+1],buf[i*9+2],buf[i*9+3],buf[i*9+4],buf[i*9+5],buf[i*9+6],buf[i*9+7],buf[i*9+8]);i++;
DEBUG_FUNCTION_LINE("GC2 %08X: %02X %02X %02X %02X %02X %02X %02X %02X %02X ", buf[i*9+0],buf[i*9+1],buf[i*9+2],buf[i*9+3],buf[i*9+4],buf[i*9+5],buf[i*9+6],buf[i*9+7],buf[i*9+8]);i++; DEBUG_FUNCTION_LINE("GC2 %08X: %02X %02X %02X %02X %02X %02X %02X %02X %02X ", buf[i*9+0],buf[i*9+1],buf[i*9+2],buf[i*9+3],buf[i*9+4],buf[i*9+5],buf[i*9+6],buf[i*9+7],buf[i*9+8]);i++;
DEBUG_FUNCTION_LINE("GC3 %08X: %02X %02X %02X %02X %02X %02X %02X %02X %02X ", buf[i*9+0],buf[i*9+1],buf[i*9+2],buf[i*9+3],buf[i*9+4],buf[i*9+5],buf[i*9+6],buf[i*9+7],buf[i*9+8]);i++; DEBUG_FUNCTION_LINE("GC3 %08X: %02X %02X %02X %02X %02X %02X %02X %02X %02X ", buf[i*9+0],buf[i*9+1],buf[i*9+2],buf[i*9+3],buf[i*9+4],buf[i*9+5],buf[i*9+6],buf[i*9+7],buf[i*9+8]);i++;
@ -374,7 +374,7 @@ void ControllerPatcherHID::HIDReadCallback(u32 handle, unsigned char *buf, u32 b
//Depending on how the switch pro controller is connected, it has a different data format. At first we had the Bluetooth version, so we need to convert //Depending on how the switch pro controller is connected, it has a different data format. At first we had the Bluetooth version, so we need to convert
//the USB one into it now. (When it's connected via USB). The network client always sends the BT version, even if connected via USB to the PC. //the USB one into it now. (When it's connected via USB). The network client always sends the BT version, even if connected via USB to the PC.
if(usr->slotdata.hidmask == gHID_LIST_SWITCH_PRO && buf != NULL && bytes_transfered >= 0x20) { if(usr->slotdata.hidmask == gHID_LIST_SWITCH_PRO && buf != NULL && bytes_transfered >= 0x20) {
u8 buffer[0x13]; uint8_t buffer[0x13];
memcpy(buffer,buf+0x0D,0x013); memcpy(buffer,buf+0x0D,0x013);
/** /**
@ -390,13 +390,13 @@ void ControllerPatcherHID::HIDReadCallback(u32 handle, unsigned char *buf, u32 b
buf[7] = 0x00; buf[7] = 0x00;
buf[8] = 0x1F; buf[8] = 0x1F;
//We want to get the next input! //We want to get the next input!
s32 res = HIDWrite(handle, buf, 9, NULL,NULL); int32_t res = HIDWrite(handle, buf, 9, NULL,NULL);
if(res == 9) { //Check if it's the USB data format. if(res == 9) { //Check if it's the USB data format.
if(buffer[1] == 0) return; if(buffer[1] == 0) return;
//Converting the buttons //Converting the buttons
u32 buttons = (((u32*)(buffer))[0]) & 0xFFFFFF00; uint32_t buttons = (((uint32_t*)(buffer))[0]) & 0xFFFFFF00;
u32 newButtons = 0; uint32_t newButtons = 0;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_A_VALUE) == HID_SWITCH_PRO_USB_BUTTON_A_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_A_VALUE; if((buttons & HID_SWITCH_PRO_USB_BUTTON_A_VALUE) == HID_SWITCH_PRO_USB_BUTTON_A_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_A_VALUE;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_B_VALUE) == HID_SWITCH_PRO_USB_BUTTON_B_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_B_VALUE; if((buttons & HID_SWITCH_PRO_USB_BUTTON_B_VALUE) == HID_SWITCH_PRO_USB_BUTTON_B_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_B_VALUE;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_X_VALUE) == HID_SWITCH_PRO_USB_BUTTON_X_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_X_VALUE; if((buttons & HID_SWITCH_PRO_USB_BUTTON_X_VALUE) == HID_SWITCH_PRO_USB_BUTTON_X_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_X_VALUE;
@ -415,8 +415,8 @@ void ControllerPatcherHID::HIDReadCallback(u32 handle, unsigned char *buf, u32 b
if((buttons & HID_SWITCH_PRO_USB_BUTTON_ZL_VALUE) == HID_SWITCH_PRO_USB_BUTTON_ZL_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_ZL_VALUE; if((buttons & HID_SWITCH_PRO_USB_BUTTON_ZL_VALUE) == HID_SWITCH_PRO_USB_BUTTON_ZL_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_ZL_VALUE;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_STICK_L_VALUE) == HID_SWITCH_PRO_USB_BUTTON_STICK_L_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_STICK_L_VALUE; if((buttons & HID_SWITCH_PRO_USB_BUTTON_STICK_L_VALUE) == HID_SWITCH_PRO_USB_BUTTON_STICK_L_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_STICK_L_VALUE;
u8 dpad = buffer[2]; uint8_t dpad = buffer[2];
u8 dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_NEUTRAL_VALUE; uint8_t dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_NEUTRAL_VALUE;
//Converting the DPAD //Converting the DPAD
if(((dpad & HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) == HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) && if(((dpad & HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) == HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) &&
@ -442,10 +442,10 @@ void ControllerPatcherHID::HIDReadCallback(u32 handle, unsigned char *buf, u32 b
} }
//Converting the stick data //Converting the stick data
u8 LX = (u8) ((u16) ((buffer[0x04] << 8 &0xFF00) | (((u16)buffer[0x03])&0xFF)) >> 0x04); uint8_t LX = (uint8_t) ((uint16_t) ((buffer[0x04] << 8 &0xFF00) | (((uint16_t)buffer[0x03])&0xFF)) >> 0x04);
u8 LY = (u8)((buffer[0x05] *-1)); uint8_t LY = (uint8_t)((buffer[0x05] *-1));
u8 RX = (u8) ((u16) ((buffer[0x07] << 8 &0xFF00) | (((u16)buffer[0x06])&0xFF)) >> 0x04); uint8_t RX = (uint8_t) ((uint16_t) ((buffer[0x07] << 8 &0xFF00) | (((uint16_t)buffer[0x06])&0xFF)) >> 0x04);
u8 RY = (u8)((buffer[0x08] *-1)); uint8_t RY = (uint8_t)((buffer[0x08] *-1));
buf[0] = (newButtons >> 24) & 0xFF; buf[0] = (newButtons >> 24) & 0xFF;
buf[1] = (newButtons >> 16) & 0xFF; buf[1] = (newButtons >> 16) & 0xFF;
@ -457,8 +457,8 @@ void ControllerPatcherHID::HIDReadCallback(u32 handle, unsigned char *buf, u32 b
} }
} }
s32 dsize = (HID_MAX_DATA_LENGTH_PER_PAD > bytes_transfered)? bytes_transfered : HID_MAX_DATA_LENGTH_PER_PAD; int32_t dsize = (HID_MAX_DATA_LENGTH_PER_PAD > bytes_transfered)? bytes_transfered : HID_MAX_DATA_LENGTH_PER_PAD;
s32 skip = 0; int32_t skip = 0;
//Input filter //Input filter
if( config_controller[usr->slotdata.deviceslot][CONTRPS_INPUT_FILTER][0] != CONTROLLER_PATCHER_INVALIDVALUE) { if( config_controller[usr->slotdata.deviceslot][CONTRPS_INPUT_FILTER][0] != CONTROLLER_PATCHER_INVALIDVALUE) {
@ -468,7 +468,7 @@ void ControllerPatcherHID::HIDReadCallback(u32 handle, unsigned char *buf, u32 b
} }
if(!skip) { if(!skip) {
u32 slot = 0; uint32_t slot = 0;
if(usr->pad_slot < HID_MAX_PADS_COUNT) { if(usr->pad_slot < HID_MAX_PADS_COUNT) {
slot = usr->pad_slot; slot = usr->pad_slot;
} }
@ -496,8 +496,8 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherHID::setVPADControllerData(V
if(buffer == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(buffer == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
HID_Data * data_cur; HID_Data * data_cur;
s32 buttons_hold; int32_t buttons_hold;
for(u32 i = 0; i<data.size(); i++) { for(uint32_t i = 0; i<data.size(); i++) {
data_cur = data[i]; data_cur = data[i];
if(data_cur->slotdata.hidmask & gHID_LIST_MOUSE) { //Reset the input when we have no new inputs if(data_cur->slotdata.hidmask & gHID_LIST_MOUSE) { //Reset the input when we have no new inputs
@ -533,8 +533,8 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherHID::setVPADControllerData(V
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_STICK_L); ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_STICK_L);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_STICK_R); ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_STICK_R);
u32 last_emulate_stick = (data_cur->last_buttons) & VPAD_MASK_EMULATED_STICKS; // We should only need the emulated stick data. uint32_t last_emulate_stick = (data_cur->last_buttons) & VPAD_MASK_EMULATED_STICKS; // We should only need the emulated stick data.
s32 last_realbuttons = (data_cur->last_buttons) & VPAD_MASK_BUTTONS; int32_t last_realbuttons = (data_cur->last_buttons) & VPAD_MASK_BUTTONS;
buffer->hold |= buttons_hold; buffer->hold |= buttons_hold;
buffer->trigger |= (buttons_hold & (~last_realbuttons)); buffer->trigger |= (buttons_hold & (~last_realbuttons));
@ -562,14 +562,14 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherHID::setVPADControllerData(V
} }
std::vector<HID_Data *> ControllerPatcherHID::getHIDDataAll() { std::vector<HID_Data *> ControllerPatcherHID::getHIDDataAll() {
u32 hid = gHIDCurrentDevice; uint32_t hid = gHIDCurrentDevice;
std::vector<HID_Data *> data_list; std::vector<HID_Data *> data_list;
for(s32 i = 0; i < gHIDMaxDevices; i++) { for(int32_t i = 0; i < gHIDMaxDevices; i++) {
if((hid & (1 << i)) != 0) { if((hid & (1 << i)) != 0) {
u32 cur_hidmask = config_controller_hidmask[i]; uint32_t cur_hidmask = config_controller_hidmask[i];
for(s32 pad = 0; pad < HID_MAX_PADS_COUNT; pad++) { for(int32_t pad = 0; pad < HID_MAX_PADS_COUNT; pad++) {
s32 res; int32_t res;
HID_Data * new_data = NULL; HID_Data * new_data = NULL;
if((res = ControllerPatcherHID::getHIDData(cur_hidmask,pad,&new_data)) < 0) { // Checks if the pad is invalid. if((res = ControllerPatcherHID::getHIDData(cur_hidmask,pad,&new_data)) < 0) { // Checks if the pad is invalid.
//DEBUG_FUNCTION_LINE("error: Error getting the HID data from HID(%s) CHAN(). Error %d\n",StringTools::byte_to_binary(cur_hidmask),pad,res); //DEBUG_FUNCTION_LINE("error: Error getting the HID data from HID(%s) CHAN(). Error %d\n",StringTools::byte_to_binary(cur_hidmask),pad,res);
@ -585,24 +585,24 @@ std::vector<HID_Data *> ControllerPatcherHID::getHIDDataAll() {
/* /*
The slotdata in the HID_Data pointer is empty. We need to provide the hidmask via the parameter The slotdata in the HID_Data pointer is empty. We need to provide the hidmask via the parameter
*/ */
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherHID::getHIDData(u32 hidmask, s32 pad, HID_Data ** data) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherHID::getHIDData(uint32_t hidmask, int32_t pad, HID_Data ** data) {
if(data == NULL) return CONTROLLER_PATCHER_ERROR_INVALID_BUFFER; if(data == NULL) return CONTROLLER_PATCHER_ERROR_INVALID_BUFFER;
if(!(hidmask & gHIDCurrentDevice)) return CONTROLLER_PATCHER_ERROR_HID_NOT_CONNECTED; if(!(hidmask & gHIDCurrentDevice)) return CONTROLLER_PATCHER_ERROR_HID_NOT_CONNECTED;
if(pad < 0 && pad > 3) return CONTROLLER_PATCHER_ERROR_INVALID_CHAN; if(pad < 0 && pad > 3) return CONTROLLER_PATCHER_ERROR_INVALID_CHAN;
s32 device_slot = ControllerPatcherUtils::getDeviceSlot(hidmask); int32_t device_slot = ControllerPatcherUtils::getDeviceSlot(hidmask);
if(device_slot < 0) { if(device_slot < 0) {
return CONTROLLER_PATCHER_ERROR_DEVICE_SLOT_NOT_FOUND; return CONTROLLER_PATCHER_ERROR_DEVICE_SLOT_NOT_FOUND;
} }
s32 real_pad = pad; int32_t real_pad = pad;
if((device_slot != gHID_SLOT_GC) && config_controller[device_slot][CONTRPS_PAD_COUNT][0] != CONTROLLER_PATCHER_INVALIDVALUE) { if((device_slot != gHID_SLOT_GC) && config_controller[device_slot][CONTRPS_PAD_COUNT][0] != CONTROLLER_PATCHER_INVALIDVALUE) {
s32 pad_count = config_controller[device_slot][CONTRPS_PAD_COUNT][1]; int32_t pad_count = config_controller[device_slot][CONTRPS_PAD_COUNT][1];
if(pad_count > HID_MAX_PADS_COUNT) pad_count = HID_MAX_PADS_COUNT; if(pad_count > HID_MAX_PADS_COUNT) pad_count = HID_MAX_PADS_COUNT;
pad = (pad/(pad_count))*pad_count; pad = (pad/(pad_count))*pad_count;
} }
s32 result = ControllerPatcherUtils::checkActivePad(hidmask,pad); int32_t result = ControllerPatcherUtils::checkActivePad(hidmask,pad);
if(result < 0) { //Not pad connected to adapter if(result < 0) { //Not pad connected to adapter
return CONTROLLER_PATCHER_ERROR_NO_PAD_CONNECTED; return CONTROLLER_PATCHER_ERROR_NO_PAD_CONNECTED;
@ -614,13 +614,13 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherHID::getHIDData(u32 hidmask,
} }
void ControllerPatcherHID::HIDGCRumble(u32 handle,my_cb_user *usr) { void ControllerPatcherHID::HIDGCRumble(uint32_t handle,my_cb_user *usr) {
if(usr == NULL) return; if(usr == NULL) return;
if(!ControllerPatcher::isRumbleActivated()) return; if(!ControllerPatcher::isRumbleActivated()) return;
s32 rumblechanged = 0; int32_t rumblechanged = 0;
for(s32 i = 0; i<HID_GC_PAD_COUNT; i++) { for(int32_t i = 0; i<HID_GC_PAD_COUNT; i++) {
HID_Data * data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[i]); HID_Data * data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[i]);
if(data_ptr->rumbleActive != usr->rumblestatus[i]) { if(data_ptr->rumbleActive != usr->rumblestatus[i]) {
rumblechanged = 1; rumblechanged = 1;
@ -636,11 +636,11 @@ void ControllerPatcherHID::HIDGCRumble(u32 handle,my_cb_user *usr) {
} }
} }
void ControllerPatcherHID::HIDRumble(u32 handle,my_cb_user *usr,u32 pad) { void ControllerPatcherHID::HIDRumble(uint32_t handle,my_cb_user *usr,uint32_t pad) {
if(usr == NULL || pad > HID_MAX_PADS_COUNT) return; if(usr == NULL || pad > HID_MAX_PADS_COUNT) return;
if(!ControllerPatcher::isRumbleActivated()) return; if(!ControllerPatcher::isRumbleActivated()) return;
s32 rumblechanged = 0; int32_t rumblechanged = 0;
HID_Data * data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[pad]); HID_Data * data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[pad]);
if(data_ptr->rumbleActive != usr->rumblestatus[pad]) { if(data_ptr->rumbleActive != usr->rumblestatus[pad]) {
usr->rumblestatus[pad] = data_ptr->rumbleActive; usr->rumblestatus[pad] = data_ptr->rumbleActive;
@ -652,7 +652,7 @@ void ControllerPatcherHID::HIDRumble(u32 handle,my_cb_user *usr,u32 pad) {
//Seding to the network client! //Seding to the network client!
char bytes[6]; char bytes[6];
s32 i = 0; int32_t i = 0;
bytes[i++] = 0x01; bytes[i++] = 0x01;
bytes[i++] = (handle >> 24) & 0xFF; bytes[i++] = (handle >> 24) & 0xFF;
bytes[i++] = (handle >> 16) & 0xFF; bytes[i++] = (handle >> 16) & 0xFF;
@ -675,7 +675,7 @@ void ControllerPatcherHID::HIDRumble(u32 handle,my_cb_user *usr,u32 pad) {
} }
} }
static u8 ds3_rumble_Report[48] = { static uint8_t ds3_rumble_Report[48] = {
0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0x27, 0x10, 0x00, 0x32, 0xFF, 0x27, 0x10, 0x00, 0x32,
@ -688,7 +688,7 @@ static u8 ds3_rumble_Report[48] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}; };
void ControllerPatcherHID::HIDDS3Rumble(u32 handle,my_cb_user *usr,s32 rumble) { void ControllerPatcherHID::HIDDS3Rumble(uint32_t handle,my_cb_user *usr,int32_t rumble) {
memcpy(usr->buf, ds3_rumble_Report, 48); memcpy(usr->buf, ds3_rumble_Report, 48);
if (rumble) { if (rumble) {

22
source/patcher/ControllerPatcherHID.hpp
View File

@ -44,34 +44,34 @@ class ControllerPatcherHID {
friend class ControllerPatcher; friend class ControllerPatcher;
friend class ControllerPatcherUtils; friend class ControllerPatcherUtils;
public: public:
static s32 externAttachDetachCallback(HIDDevice *p_device, HIDAttachEvent attach); static int32_t externAttachDetachCallback(HIDDevice *p_device, HIDAttachEvent attach);
static void externHIDReadCallback(u32 handle, unsigned char *buf, u32 bytes_transfered, my_cb_user * usr); static void externHIDReadCallback(uint32_t handle, unsigned char *buf, uint32_t bytes_transfered, my_cb_user * usr);
private: private:
static CONTROLLER_PATCHER_RESULT_OR_ERROR setVPADControllerData(VPADStatus * buffer,std::vector<HID_Data *>& data); static CONTROLLER_PATCHER_RESULT_OR_ERROR setVPADControllerData(VPADStatus * buffer,std::vector<HID_Data *>& data);
static std::vector<HID_Data *> getHIDDataAll(); static std::vector<HID_Data *> getHIDDataAll();
static CONTROLLER_PATCHER_RESULT_OR_ERROR getHIDData(u32 hidmask, s32 pad, HID_Data ** data); static CONTROLLER_PATCHER_RESULT_OR_ERROR getHIDData(uint32_t hidmask, int32_t pad, HID_Data ** data);
/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- /*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Rumble * Rumble
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/ *---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
static void HIDRumble(u32 handle,my_cb_user *usr,u32 pad); static void HIDRumble(uint32_t handle,my_cb_user *usr,uint32_t pad);
static void HIDGCRumble(u32 handle,my_cb_user *usr); static void HIDGCRumble(uint32_t handle,my_cb_user *usr);
static void HIDDS3Rumble(u32 handle,my_cb_user *usr,s32 rumble); static void HIDDS3Rumble(uint32_t handle,my_cb_user *usr,int32_t rumble);
/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- /*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* HID Callbacks * HID Callbacks
*--------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/ *--------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
static s32 myAttachDetachCallback(HIDClient *p_client, HIDDevice *p_device, HIDAttachEvent attach); static int32_t myAttachDetachCallback(HIDClient *p_client, HIDDevice *p_device, HIDAttachEvent attach);
static void myHIDMouseReadCallback(u32 handle, s32 error, unsigned char *buf, u32 bytes_transfered, void *p_user); static void myHIDMouseReadCallback(uint32_t handle, int32_t error, unsigned char *buf, uint32_t bytes_transfered, void *p_user);
static void myHIDReadCallback(u32 handle, s32 error, unsigned char *buf, u32 bytes_transfered, void *p_user); static void myHIDReadCallback(uint32_t handle, int32_t error, unsigned char *buf, uint32_t bytes_transfered, void *p_user);
static s32 AttachDetachCallback(HIDClient *p_client, HIDDevice *p_device, HIDAttachEvent attach); static int32_t AttachDetachCallback(HIDClient *p_client, HIDDevice *p_device, HIDAttachEvent attach);
static void HIDReadCallback(u32 handle, unsigned char *buf, u32 bytes_transfered, my_cb_user * usr); static void HIDReadCallback(uint32_t handle, unsigned char *buf, uint32_t bytes_transfered, my_cb_user * usr);
}; };
#endif /* _CONTROLLER_PATCHER_HID_H_ */ #endif /* _CONTROLLER_PATCHER_HID_H_ */

172
source/patcher/ControllerPatcherUtils.cpp
View File

@ -20,11 +20,11 @@
#include <utils/logger.h> #include <utils/logger.h>
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getDataByHandle(s32 handle, my_cb_user ** data) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getDataByHandle(int32_t handle, my_cb_user ** data) {
for(s32 i = 0; i< gHIDMaxDevices; i++) { for(int32_t i = 0; i< gHIDMaxDevices; i++) {
for(s32 j = 0; j<4; j++) { for(int32_t j = 0; j<4; j++) {
//log_printf("%d %d %d %d\n",i,j,gHID_Devices[i].pad_data[j].handle,(u32)handle); //log_printf("%d %d %d %d\n",i,j,gHID_Devices[i].pad_data[j].handle,(uint32_t)handle);
if(gHID_Devices[i].pad_data[j].handle == (u32)handle) { if(gHID_Devices[i].pad_data[j].handle == (uint32_t)handle) {
*data = gHID_Devices[i].pad_data[j].user_data; *data = gHID_Devices[i].pad_data[j].user_data;
return CONTROLLER_PATCHER_ERROR_NONE; return CONTROLLER_PATCHER_ERROR_NONE;
} }
@ -36,12 +36,12 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getDataByHandle(s32 h
* Analyse inputs * Analyse inputs
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/ *---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getButtonPressed(HID_Data * data, s32 * buttons_hold, s32 VPADButton) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getButtonPressed(HID_Data * data, int32_t * buttons_hold, int32_t VPADButton) {
if(data == NULL || buttons_hold == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(data == NULL || buttons_hold == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
s32 deviceslot = data->slotdata.deviceslot; int32_t deviceslot = data->slotdata.deviceslot;
s32 result = -1; int32_t result = -1;
do { do {
if(data->type == DEVICE_TYPE_MOUSE) { if(data->type == DEVICE_TYPE_MOUSE) {
@ -75,10 +75,10 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getButtonPressed(HID_
result = 0; result = 0;
break; break;
} }
u8 * cur_data = &data->data_union.controller.cur_hid_data[0]; uint8_t * cur_data = &data->data_union.controller.cur_hid_data[0];
if(cur_data == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(cur_data == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
s32 cur_config = 0; int32_t cur_config = 0;
if(VPADButton == VPAD_BUTTON_A) { if(VPADButton == VPAD_BUTTON_A) {
cur_config = CONTRPS_VPAD_BUTTON_A; cur_config = CONTRPS_VPAD_BUTTON_A;
@ -111,15 +111,15 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getButtonPressed(HID_
//! Special DPAD treatment. //! Special DPAD treatment.
if(config_controller[deviceslot][CONTRPS_DPAD_MODE][0] == CONTROLLER_PATCHER_VALUE_SET) { if(config_controller[deviceslot][CONTRPS_DPAD_MODE][0] == CONTROLLER_PATCHER_VALUE_SET) {
if(config_controller[deviceslot][CONTRPS_DPAD_MODE][1] == CONTRPDM_Hat) { if(config_controller[deviceslot][CONTRPS_DPAD_MODE][1] == CONTRPDM_Hat) {
u8 mask = 0x0F; uint8_t mask = 0x0F;
if(config_controller[deviceslot][CONTRPS_DPAD_MASK][0] == CONTROLLER_PATCHER_VALUE_SET) { if(config_controller[deviceslot][CONTRPS_DPAD_MASK][0] == CONTROLLER_PATCHER_VALUE_SET) {
mask = config_controller[deviceslot][CONTRPS_DPAD_MASK][1]; mask = config_controller[deviceslot][CONTRPS_DPAD_MASK][1];
} }
if(cur_data[config_controller[deviceslot][CONTRPS_VPAD_BUTTON_DPAD_NEUTRAL][0]] != config_controller[deviceslot][CONTRPS_VPAD_BUTTON_DPAD_NEUTRAL][1]) { // Not neutral if(cur_data[config_controller[deviceslot][CONTRPS_VPAD_BUTTON_DPAD_NEUTRAL][0]] != config_controller[deviceslot][CONTRPS_VPAD_BUTTON_DPAD_NEUTRAL][1]) { // Not neutral
u8 dir1_0 = 0,dir1_1 = 0; uint8_t dir1_0 = 0,dir1_1 = 0;
u8 dir2_0 = 0,dir2_1 = 0; uint8_t dir2_0 = 0,dir2_1 = 0;
u8 dir3_0 = 0,dir3_1 = 0; uint8_t dir3_0 = 0,dir3_1 = 0;
u8 direction = 0; uint8_t direction = 0;
if(VPADButton == VPAD_BUTTON_LEFT) { if(VPADButton == VPAD_BUTTON_LEFT) {
dir1_0 = config_controller[deviceslot][CONTRPS_VPAD_BUTTON_DPAD_W][0]; dir1_0 = config_controller[deviceslot][CONTRPS_VPAD_BUTTON_DPAD_W][0];
dir2_0 = config_controller[deviceslot][CONTRPS_VPAD_BUTTON_DPAD_NW][0]; dir2_0 = config_controller[deviceslot][CONTRPS_VPAD_BUTTON_DPAD_NW][0];
@ -162,7 +162,7 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getButtonPressed(HID_
} }
} else if(config_controller[deviceslot][CONTRPS_DPAD_MODE][1] == CONTRPDM_Absolute_2Values) { } else if(config_controller[deviceslot][CONTRPS_DPAD_MODE][1] == CONTRPDM_Absolute_2Values) {
s32 contrps_value = 0; int32_t contrps_value = 0;
if(VPADButton == VPAD_BUTTON_LEFT) { if(VPADButton == VPAD_BUTTON_LEFT) {
contrps_value = CONTRPS_VPAD_BUTTON_DPAD_ABS_LEFT; contrps_value = CONTRPS_VPAD_BUTTON_DPAD_ABS_LEFT;
} else if(VPADButton == VPAD_BUTTON_RIGHT) { } else if(VPADButton == VPAD_BUTTON_RIGHT) {
@ -174,7 +174,7 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getButtonPressed(HID_
} }
if(contrps_value != 0) { if(contrps_value != 0) {
s32 value_byte = CONTROLLER_PATCHER_INVALIDVALUE; int32_t value_byte = CONTROLLER_PATCHER_INVALIDVALUE;
if((value_byte = config_controller[deviceslot][contrps_value][0]) != CONTROLLER_PATCHER_INVALIDVALUE) { if((value_byte = config_controller[deviceslot][contrps_value][0]) != CONTROLLER_PATCHER_INVALIDVALUE) {
if(cur_data[config_controller[deviceslot][contrps_value][0]] == config_controller[deviceslot][contrps_value][1]) { if(cur_data[config_controller[deviceslot][contrps_value][0]] == config_controller[deviceslot][contrps_value][1]) {
result = 1; result = 1;
@ -259,16 +259,16 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getButtonPressed(HID_
return CONTROLLER_PATCHER_ERROR_NONE; return CONTROLLER_PATCHER_ERROR_NONE;
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::isValueSet(HID_Data * data,s32 cur_config) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::isValueSet(HID_Data * data,int32_t cur_config) {
if(data == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(data == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
u8 * cur_data = &data->data_union.controller.cur_hid_data[0]; uint8_t * cur_data = &data->data_union.controller.cur_hid_data[0];
if(cur_data == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(cur_data == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
u32 hidmask = data->slotdata.hidmask; uint32_t hidmask = data->slotdata.hidmask;
s32 deviceslot = data->slotdata.deviceslot; int32_t deviceslot = data->slotdata.deviceslot;
s32 result = CONTROLLER_PATCHER_ERROR_NONE; int32_t result = CONTROLLER_PATCHER_ERROR_NONE;
if(config_controller[deviceslot][cur_config][0] != CONTROLLER_PATCHER_INVALIDVALUE) { //Invalid data if(config_controller[deviceslot][cur_config][0] != CONTROLLER_PATCHER_INVALIDVALUE) { //Invalid data
if(hidmask & gHID_LIST_KEYBOARD) { if(hidmask & gHID_LIST_KEYBOARD) {
if(isInKeyboardData(cur_data,config_controller[deviceslot][cur_config][1]) > 0) { if(isInKeyboardData(cur_data,config_controller[deviceslot][cur_config][1]) > 0) {
@ -282,9 +282,9 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::isValueSet(HID_Data *
} }
return result; return result;
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::isInKeyboardData(unsigned char * keyboardData,s32 key) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::isInKeyboardData(unsigned char * keyboardData,int32_t key) {
if(keyboardData == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(keyboardData == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
for(s32 i = 0; i<HID_KEYBOARD_DATA_LENGTH; i++) { for(int32_t i = 0; i<HID_KEYBOARD_DATA_LENGTH; i++) {
if(keyboardData[i] == 0 && i > 1) { if(keyboardData[i] == 0 && i > 1) {
break; break;
} else if (keyboardData[i] == key) { } else if (keyboardData[i] == key) {
@ -298,9 +298,9 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::isInKeyboardData(unsi
* Utils for setting the Button data * Utils for setting the Button data
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/ *---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::setButtonRemappingData(VPADStatus * old_buffer, VPADStatus * new_buffer,u32 VPADButton, s32 CONTRPS_SLOT) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::setButtonRemappingData(VPADStatus * old_buffer, VPADStatus * new_buffer,uint32_t VPADButton, int32_t CONTRPS_SLOT) {
if(old_buffer == NULL || new_buffer == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(old_buffer == NULL || new_buffer == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
u32 new_value = VPADButton; uint32_t new_value = VPADButton;
if(config_controller[gGamePadSlot][CONTRPS_SLOT][0] != CONTROLLER_PATCHER_INVALIDVALUE) { //using new value! if(config_controller[gGamePadSlot][CONTRPS_SLOT][0] != CONTROLLER_PATCHER_INVALIDVALUE) { //using new value!
new_value = gGamePadValues[config_controller[gGamePadSlot][CONTRPS_SLOT][1]]; new_value = gGamePadValues[config_controller[gGamePadSlot][CONTRPS_SLOT][1]];
@ -310,7 +310,7 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::setButtonRemappingDat
return CONTROLLER_PATCHER_ERROR_NONE; return CONTROLLER_PATCHER_ERROR_NONE;
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::setButtonData(VPADStatus * old_buffer, VPADStatus * new_buffer,u32 oldVPADButton,u32 newVPADButton) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::setButtonData(VPADStatus * old_buffer, VPADStatus * new_buffer,uint32_t oldVPADButton,uint32_t newVPADButton) {
if(old_buffer == NULL || new_buffer == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(old_buffer == NULL || new_buffer == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
if((old_buffer->hold & oldVPADButton) == oldVPADButton) { if((old_buffer->hold & oldVPADButton) == oldVPADButton) {
new_buffer->hold |= newVPADButton; new_buffer->hold |= newVPADButton;
@ -329,14 +329,14 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::setButtonData(VPADSta
* Pad Status functions * Pad Status functions
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/ *---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::checkActivePad(u32 hidmask,s32 pad) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::checkActivePad(uint32_t hidmask,int32_t pad) {
if(hidmask & gHID_LIST_GC && pad >= 0 && pad <= 3) { if(hidmask & gHID_LIST_GC && pad >= 0 && pad <= 3) {
if (!(((gHID_Devices[gHID_SLOT_GC].pad_data[pad].data_union.controller.cur_hid_data[0] & 0x10) == 0) && ((gHID_Devices[gHID_SLOT_GC].pad_data[pad].data_union.controller.cur_hid_data[0] & 0x22) != 0x22))) return 1; if (!(((gHID_Devices[gHID_SLOT_GC].pad_data[pad].data_union.controller.cur_hid_data[0] & 0x10) == 0) && ((gHID_Devices[gHID_SLOT_GC].pad_data[pad].data_union.controller.cur_hid_data[0] & 0x22) != 0x22))) return 1;
return CONTROLLER_PATCHER_ERROR_NO_PAD_CONNECTED; return CONTROLLER_PATCHER_ERROR_NO_PAD_CONNECTED;
} else { } else {
s32 deviceslot = getDeviceSlot(hidmask); int32_t deviceslot = getDeviceSlot(hidmask);
if(deviceslot < 0 ) return CONTROLLER_PATCHER_ERROR_DEVICE_SLOT_NOT_FOUND; if(deviceslot < 0 ) return CONTROLLER_PATCHER_ERROR_DEVICE_SLOT_NOT_FOUND;
s32 connected_pads = config_controller[deviceslot][CONTRPS_CONNECTED_PADS][1]; int32_t connected_pads = config_controller[deviceslot][CONTRPS_CONNECTED_PADS][1];
if((connected_pads & (1 << pad)) > 0) { if((connected_pads & (1 << pad)) > 0) {
return 1; return 1;
@ -346,7 +346,7 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::checkActivePad(u32 hi
} }
/* /*
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getActivePad(u32 hidmask){ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getActivePad(uint32_t hidmask){
if(hidmask & gHID_LIST_GC){ if(hidmask & gHID_LIST_GC){
if (!(((gHID_Devices[gHID_SLOT_GC].pad_data[0].data_union.controller.cur_hid_data[0] & 0x10) == 0) && ((gHID_Devices[gHID_SLOT_GC].pad_data[0].data_union.controller.cur_hid_data[0] & 0x22) != 0x22))) return 0; if (!(((gHID_Devices[gHID_SLOT_GC].pad_data[0].data_union.controller.cur_hid_data[0] & 0x10) == 0) && ((gHID_Devices[gHID_SLOT_GC].pad_data[0].data_union.controller.cur_hid_data[0] & 0x22) != 0x22))) return 0;
if (!(((gHID_Devices[gHID_SLOT_GC].pad_data[1].data_union.controller.cur_hid_data[0] & 0x10) == 0) && ((gHID_Devices[gHID_SLOT_GC].pad_data[1].data_union.controller.cur_hid_data[0] & 0x22) != 0x22))) return 1; if (!(((gHID_Devices[gHID_SLOT_GC].pad_data[1].data_union.controller.cur_hid_data[0] & 0x10) == 0) && ((gHID_Devices[gHID_SLOT_GC].pad_data[1].data_union.controller.cur_hid_data[0] & 0x22) != 0x22))) return 1;
@ -365,8 +365,8 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getActivePad(u32 hidm
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::normalizeStickValues(VPADVec2D * stick) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::normalizeStickValues(VPADVec2D * stick) {
if(stick == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(stick == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
f32 max_val = 0.0f; float max_val = 0.0f;
f32 mul_val = 0.0f; float mul_val = 0.0f;
if((max_val = (fabs(stick->x)) + fabs(stick->y)) > 1.414f) { if((max_val = (fabs(stick->x)) + fabs(stick->y)) > 1.414f) {
mul_val = 1.414f / max_val; mul_val = 1.414f / max_val;
@ -390,9 +390,9 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::normalizeStickValues(
return CONTROLLER_PATCHER_ERROR_NONE; return CONTROLLER_PATCHER_ERROR_NONE;
} }
f32 ControllerPatcherUtils::convertAnalogValue(u8 value, u8 default_val, u8 min, u8 max, u8 invert,u8 deadzone) { float ControllerPatcherUtils::convertAnalogValue(uint8_t value, uint8_t default_val, uint8_t min, uint8_t max, uint8_t invert,uint8_t deadzone) {
s8 new_value = (s8)(value - default_val); int8_t new_value = (int8_t)(value - default_val);
u8 range = 0; uint8_t range = 0;
if(value >= max) { if(value >= max) {
if(invert == 0x01) return -1.0f; if(invert == 0x01) return -1.0f;
return 1.0f; return 1.0f;
@ -416,15 +416,15 @@ f32 ControllerPatcherUtils::convertAnalogValue(u8 value, u8 default_val, u8 min,
} }
} }
VPADVec2D ControllerPatcherUtils::getAnalogValueByButtons(u8 stick_values) { VPADVec2D ControllerPatcherUtils::getAnalogValueByButtons(uint8_t stick_values) {
VPADVec2D stick; VPADVec2D stick;
stick.x = 0.0f; stick.x = 0.0f;
stick.y = 0.0f; stick.y = 0.0f;
u8 up = ((stick_values & STICK_VALUE_UP) == STICK_VALUE_UP); uint8_t up = ((stick_values & STICK_VALUE_UP) == STICK_VALUE_UP);
u8 down = ((stick_values & STICK_VALUE_DOWN) == STICK_VALUE_DOWN); uint8_t down = ((stick_values & STICK_VALUE_DOWN) == STICK_VALUE_DOWN);
u8 left = ((stick_values & STICK_VALUE_LEFT) == STICK_VALUE_LEFT); uint8_t left = ((stick_values & STICK_VALUE_LEFT) == STICK_VALUE_LEFT);
u8 right = ((stick_values & STICK_VALUE_RIGHT) == STICK_VALUE_RIGHT); uint8_t right = ((stick_values & STICK_VALUE_RIGHT) == STICK_VALUE_RIGHT);
if(up) { if(up) {
if(!down) { if(!down) {
@ -462,14 +462,14 @@ VPADVec2D ControllerPatcherUtils::getAnalogValueByButtons(u8 stick_values) {
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::convertAnalogSticks(HID_Data * data, VPADStatus * buffer) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::convertAnalogSticks(HID_Data * data, VPADStatus * buffer) {
if(buffer == NULL || data == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(buffer == NULL || data == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
s32 deviceslot = data->slotdata.deviceslot; int32_t deviceslot = data->slotdata.deviceslot;
if (data->type == DEVICE_TYPE_MOUSE) { if (data->type == DEVICE_TYPE_MOUSE) {
if(gHID_Mouse_Mode == HID_MOUSE_MODE_AIM) { // TODO: tweak values if(gHID_Mouse_Mode == HID_MOUSE_MODE_AIM) { // TODO: tweak values
HID_Mouse_Data * ms_data = &data->data_union.mouse.cur_mouse_data; HID_Mouse_Data * ms_data = &data->data_union.mouse.cur_mouse_data;
if(ms_data == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(ms_data == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
f32 x_value = ms_data->deltaX/10.0f; float x_value = ms_data->deltaX/10.0f;
f32 y_value = -1.0f*(ms_data->deltaY/10.0f); float y_value = -1.0f*(ms_data->deltaY/10.0f);
if(config_controller[deviceslot][CONTRPS_MOUSE_STICK][0] != CONTROLLER_PATCHER_INVALIDVALUE) { if(config_controller[deviceslot][CONTRPS_MOUSE_STICK][0] != CONTROLLER_PATCHER_INVALIDVALUE) {
if(config_controller[deviceslot][CONTRPS_MOUSE_STICK][1] == DEF_L_STICK) { if(config_controller[deviceslot][CONTRPS_MOUSE_STICK][1] == DEF_L_STICK) {
@ -483,10 +483,10 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::convertAnalogSticks(H
buffer->rightStick.y += y_value; buffer->rightStick.y += y_value;
} }
} else { } else {
u8 * cur_data = &data->data_union.controller.cur_hid_data[0]; uint8_t * cur_data = &data->data_union.controller.cur_hid_data[0];
if(cur_data == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(cur_data == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
s32 deadzone = 0; int32_t deadzone = 0;
if( config_controller[deviceslot][CONTRPS_VPAD_BUTTON_L_STICK_X][0] != CONTROLLER_PATCHER_INVALIDVALUE) { if( config_controller[deviceslot][CONTRPS_VPAD_BUTTON_L_STICK_X][0] != CONTROLLER_PATCHER_INVALIDVALUE) {
if(config_controller[deviceslot][CONTRPS_VPAD_BUTTON_L_STICK_X_DEADZONE][0] == CONTROLLER_PATCHER_VALUE_SET) { if(config_controller[deviceslot][CONTRPS_VPAD_BUTTON_L_STICK_X_DEADZONE][0] == CONTROLLER_PATCHER_VALUE_SET) {
@ -542,7 +542,7 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::convertAnalogSticks(H
deadzone); deadzone);
} }
u8 stick_values = 0; uint8_t stick_values = 0;
if(isValueSet(data,CONTRPS_VPAD_BUTTON_L_STICK_UP)) { if(isValueSet(data,CONTRPS_VPAD_BUTTON_L_STICK_UP)) {
stick_values |= STICK_VALUE_UP; stick_values |= STICK_VALUE_UP;
@ -585,7 +585,7 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::convertAnalogSticks(H
if(config_controller[deviceslot][CONTRPS_VPAD_STICK_L_COPY_DPAD][0] != CONTROLLER_PATCHER_INVALIDVALUE) { if(config_controller[deviceslot][CONTRPS_VPAD_STICK_L_COPY_DPAD][0] != CONTROLLER_PATCHER_INVALIDVALUE) {
if(config_controller[deviceslot][CONTRPS_VPAD_STICK_L_COPY_DPAD][0] == 1) { if(config_controller[deviceslot][CONTRPS_VPAD_STICK_L_COPY_DPAD][0] == 1) {
u8 stick_values = 0; uint8_t stick_values = 0;
if(buffer->hold & VPAD_BUTTON_UP) { if(buffer->hold & VPAD_BUTTON_UP) {
stick_values |= STICK_VALUE_UP; stick_values |= STICK_VALUE_UP;
@ -609,7 +609,7 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::convertAnalogSticks(H
} }
if(config_controller[deviceslot][CONTRPS_VPAD_STICK_R_COPY_DPAD][0] != CONTROLLER_PATCHER_INVALIDVALUE) { if(config_controller[deviceslot][CONTRPS_VPAD_STICK_R_COPY_DPAD][0] != CONTROLLER_PATCHER_INVALIDVALUE) {
if(config_controller[deviceslot][CONTRPS_VPAD_STICK_R_COPY_DPAD][0] == 1) { if(config_controller[deviceslot][CONTRPS_VPAD_STICK_R_COPY_DPAD][0] == 1) {
u8 stick_values = 0; uint8_t stick_values = 0;
if(buffer->hold & VPAD_BUTTON_UP) { if(buffer->hold & VPAD_BUTTON_UP) {
stick_values |= STICK_VALUE_UP; stick_values |= STICK_VALUE_UP;
@ -641,15 +641,15 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::convertAnalogSticks(H
return CONTROLLER_PATCHER_ERROR_NONE; return CONTROLLER_PATCHER_ERROR_NONE;
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::setEmulatedSticks(VPADStatus * buffer, u32 * last_emulatedSticks) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::setEmulatedSticks(VPADStatus * buffer, uint32_t * last_emulatedSticks) {
if(buffer == NULL || last_emulatedSticks == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(buffer == NULL || last_emulatedSticks == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
u32 emulatedSticks = 0; uint32_t emulatedSticks = 0;
s32 l_x_full = (buffer->leftStick.x > 0.5f || buffer->leftStick.x < -0.5f)? 1:0; int32_t l_x_full = (buffer->leftStick.x > 0.5f || buffer->leftStick.x < -0.5f)? 1:0;
s32 l_y_full = (buffer->leftStick.y > 0.5f || buffer->leftStick.y < -0.5f)? 1:0; int32_t l_y_full = (buffer->leftStick.y > 0.5f || buffer->leftStick.y < -0.5f)? 1:0;
s32 r_x_full = (buffer->rightStick.x > 0.5f || buffer->rightStick.x < -0.5f)? 1:0; int32_t r_x_full = (buffer->rightStick.x > 0.5f || buffer->rightStick.x < -0.5f)? 1:0;
s32 r_y_full = (buffer->rightStick.y > 0.5f || buffer->rightStick.y < -0.5f)? 1:0; int32_t r_y_full = (buffer->rightStick.y > 0.5f || buffer->rightStick.y < -0.5f)? 1:0;
if((buffer->leftStick.x > 0.5f) || (buffer->leftStick.x > 0.1f && !l_y_full)) { if((buffer->leftStick.x > 0.5f) || (buffer->leftStick.x > 0.1f && !l_y_full)) {
emulatedSticks |= VPAD_STICK_L_EMULATION_RIGHT; emulatedSticks |= VPAD_STICK_L_EMULATION_RIGHT;
@ -694,12 +694,12 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::setEmulatedSticks(VPA
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::setTouch(HID_Data * data,VPADStatus * buffer) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::setTouch(HID_Data * data,VPADStatus * buffer) {
if(buffer == NULL || data == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(buffer == NULL || data == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
if(data->type == DEVICE_TYPE_MOUSE && gHID_Mouse_Mode == HID_MOUSE_MODE_TOUCH) { if(data->type == DEVICE_TYPE_MOUSE && gHID_Mouse_Mode == HID_MOUSE_MODE_TOUCH) {
s32 buttons_hold; int32_t buttons_hold;
if(getButtonPressed(data,&buttons_hold,VPAD_BUTTON_TOUCH)) { if(getButtonPressed(data,&buttons_hold,VPAD_BUTTON_TOUCH)) {
HID_Mouse_Data * ms_data = &data->data_union.mouse.cur_mouse_data; HID_Mouse_Data * ms_data = &data->data_union.mouse.cur_mouse_data;
if(ms_data == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(ms_data == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
s32 x_mouse = 80 + ((int)(((ms_data->X)*1.0f/1280.0)*3890.0f)); int32_t x_mouse = 80 + ((int)(((ms_data->X)*1.0f/1280.0)*3890.0f));
s32 y_mouse = 3910 - ((int)(((ms_data->Y)*1.0f/720.0)*3760.0f)); int32_t y_mouse = 3910 - ((int)(((ms_data->Y)*1.0f/720.0)*3760.0f));
buffer->tpNormal.x = x_mouse; buffer->tpNormal.x = x_mouse;
buffer->tpNormal.y = y_mouse; buffer->tpNormal.y = y_mouse;
buffer->tpNormal.touched = 1; buffer->tpNormal.touched = 1;
@ -718,11 +718,11 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::setTouch(HID_Data * d
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::checkAndSetMouseMode(HID_Data * data) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::checkAndSetMouseMode(HID_Data * data) {
u32 hidmask = data->slotdata.hidmask; uint32_t hidmask = data->slotdata.hidmask;
if(hidmask & gHID_LIST_KEYBOARD) { if(hidmask & gHID_LIST_KEYBOARD) {
u8 * cur_data = &data->data_union.controller.cur_hid_data[0]; uint8_t * cur_data = &data->data_union.controller.cur_hid_data[0];
u8 * last_data = &data->data_union.controller.last_hid_data[0]; uint8_t * last_data = &data->data_union.controller.last_hid_data[0];
if((isInKeyboardData(cur_data,HID_KEYBOARD_BUTTON_F1) > 0) && ((isInKeyboardData(cur_data,HID_KEYBOARD_BUTTON_F1) > 0) != (isInKeyboardData(last_data,HID_KEYBOARD_BUTTON_F1) > 0)) && gMouseModeCoolDown == 0) { if((isInKeyboardData(cur_data,HID_KEYBOARD_BUTTON_F1) > 0) && ((isInKeyboardData(cur_data,HID_KEYBOARD_BUTTON_F1) > 0) != (isInKeyboardData(last_data,HID_KEYBOARD_BUTTON_F1) > 0)) && gMouseModeCoolDown == 0) {
gMouseModeCoolDown = 60; gMouseModeCoolDown = 60;
if(gHID_Mouse_Mode == HID_MOUSE_MODE_AIM) { if(gHID_Mouse_Mode == HID_MOUSE_MODE_AIM) {
@ -744,10 +744,10 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::checkAndSetMouseMode(
* Other functions * Other functions
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/ *---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::translateToPro(VPADStatus * vpad_buffer,KPADStatus * pro_buffer,u32 * lastButtonsPressesPRO) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::translateToPro(VPADStatus * vpad_buffer,KPADStatus * pro_buffer,uint32_t * lastButtonsPressesPRO) {
if(vpad_buffer == NULL || pro_buffer == NULL || lastButtonsPressesPRO == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(vpad_buffer == NULL || pro_buffer == NULL || lastButtonsPressesPRO == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
s32 buttons_hold = 0; int32_t buttons_hold = 0;
if(vpad_buffer->hold & VPAD_BUTTON_A) buttons_hold |= WPAD_PRO_BUTTON_A; if(vpad_buffer->hold & VPAD_BUTTON_A) buttons_hold |= WPAD_PRO_BUTTON_A;
if(vpad_buffer->hold & VPAD_BUTTON_B) buttons_hold |= WPAD_PRO_BUTTON_B; if(vpad_buffer->hold & VPAD_BUTTON_B) buttons_hold |= WPAD_PRO_BUTTON_B;
@ -815,7 +815,7 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::translateToPro(VPADSt
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::translateToProWPADRead(VPADStatus * vpad_buffer,WPADStatusProController * pro_buffer) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::translateToProWPADRead(VPADStatus * vpad_buffer,WPADStatusProController * pro_buffer) {
if(vpad_buffer == NULL || pro_buffer == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(vpad_buffer == NULL || pro_buffer == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
s32 buttons_hold = 0; int32_t buttons_hold = 0;
if(vpad_buffer->hold & VPAD_BUTTON_A) buttons_hold |= WPAD_PRO_BUTTON_A; if(vpad_buffer->hold & VPAD_BUTTON_A) buttons_hold |= WPAD_PRO_BUTTON_A;
if(vpad_buffer->hold & VPAD_BUTTON_B) buttons_hold |= WPAD_PRO_BUTTON_B; if(vpad_buffer->hold & VPAD_BUTTON_B) buttons_hold |= WPAD_PRO_BUTTON_B;
@ -850,10 +850,10 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::translateToProWPADRea
if(vpad_buffer->hold & VPAD_STICK_R_EMULATION_UP) buttons_hold |= WPAD_PRO_STICK_R_EMULATION_UP; if(vpad_buffer->hold & VPAD_STICK_R_EMULATION_UP) buttons_hold |= WPAD_PRO_STICK_R_EMULATION_UP;
if(vpad_buffer->hold & VPAD_STICK_R_EMULATION_DOWN) buttons_hold |= WPAD_PRO_STICK_R_EMULATION_DOWN; if(vpad_buffer->hold & VPAD_STICK_R_EMULATION_DOWN) buttons_hold |= WPAD_PRO_STICK_R_EMULATION_DOWN;
pro_buffer->leftStick.x = (s16) (vpad_buffer->leftStick.x * 950.0f); pro_buffer->leftStick.x = (int16_t) (vpad_buffer->leftStick.x * 950.0f);
pro_buffer->leftStick.y = (s16) (vpad_buffer->leftStick.y * 950.0f); pro_buffer->leftStick.y = (int16_t) (vpad_buffer->leftStick.y * 950.0f);
pro_buffer->rightStick.x = (s16) (vpad_buffer->rightStick.x * 950.0f); pro_buffer->rightStick.x = (int16_t) (vpad_buffer->rightStick.x * 950.0f);
pro_buffer->rightStick.y = (s16) (vpad_buffer->rightStick.y * 950.0f); pro_buffer->rightStick.y = (int16_t) (vpad_buffer->rightStick.y * 950.0f);
pro_buffer->buttons = buttons_hold; pro_buffer->buttons = buttons_hold;
@ -864,10 +864,10 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::translateToProWPADRea
return CONTROLLER_PATCHER_ERROR_NONE; return CONTROLLER_PATCHER_ERROR_NONE;
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::translateToVPAD(VPADStatus * vpad_buffer,KPADStatus * pro_buffer,u32 * lastButtonsPressesVPAD) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::translateToVPAD(VPADStatus * vpad_buffer,KPADStatus * pro_buffer,uint32_t * lastButtonsPressesVPAD) {
if(vpad_buffer == NULL || pro_buffer == NULL || lastButtonsPressesVPAD == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(vpad_buffer == NULL || pro_buffer == NULL || lastButtonsPressesVPAD == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
s32 buttons_hold = 0; int32_t buttons_hold = 0;
if(pro_buffer->pro.hold & WPAD_PRO_BUTTON_A) buttons_hold |= VPAD_BUTTON_A; if(pro_buffer->pro.hold & WPAD_PRO_BUTTON_A) buttons_hold |= VPAD_BUTTON_A;
@ -918,20 +918,20 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::translateToVPAD(VPADS
return CONTROLLER_PATCHER_ERROR_NONE; return CONTROLLER_PATCHER_ERROR_NONE;
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::checkValueinConfigController(s32 deviceslot,s32 CONTRPS_slot,s32 expectedValue) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::checkValueinConfigController(int32_t deviceslot,int32_t CONTRPS_slot,int32_t expectedValue) {
if(config_controller[deviceslot][CONTRPS_slot][0] != CONTROLLER_PATCHER_INVALIDVALUE) { if(config_controller[deviceslot][CONTRPS_slot][0] != CONTROLLER_PATCHER_INVALIDVALUE) {
if(expectedValue == config_controller[deviceslot][CONTRPS_slot][1]) return 1; if(expectedValue == config_controller[deviceslot][CONTRPS_slot][1]) return 1;
} }
return 0; return 0;
} }
void ControllerPatcherUtils::setConfigValue(u8 * dest, u8 first, u8 second) { void ControllerPatcherUtils::setConfigValue(uint8_t * dest, uint8_t first, uint8_t second) {
dest[0] = first; dest[0] = first;
dest[1] = second; dest[1] = second;
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getDeviceSlot(u32 hidmask) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getDeviceSlot(uint32_t hidmask) {
for(s32 i = 0; i < gHIDMaxDevices; i++) { for(int32_t i = 0; i < gHIDMaxDevices; i++) {
if(hidmask & config_controller_hidmask[i]) { if(hidmask & config_controller_hidmask[i]) {
return i; return i;
} }
@ -941,9 +941,9 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getDeviceSlot(u32 hid
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getDeviceInfoFromVidPid(DeviceInfo * info) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getDeviceInfoFromVidPid(DeviceInfo * info) {
if(info != NULL) { if(info != NULL) {
for(s32 i = 0; i< gHIDMaxDevices; i++) { for(int32_t i = 0; i< gHIDMaxDevices; i++) {
u16 my_vid = config_controller[i][CONTRPS_VID][0] * 0x100 + config_controller[i][CONTRPS_VID][1]; uint16_t my_vid = config_controller[i][CONTRPS_VID][0] * 0x100 + config_controller[i][CONTRPS_VID][1];
u16 my_pid = config_controller[i][CONTRPS_PID][0] * 0x100 + config_controller[i][CONTRPS_PID][1]; uint16_t my_pid = config_controller[i][CONTRPS_PID][0] * 0x100 + config_controller[i][CONTRPS_PID][1];
//log_printf("info->vidpid.vid (%04X) == my_vid (%04X) && info->vidpid.pid (%04X) == my_pid (%04X)\n",info->vidpid.vid,my_vid,info->vidpid.pid,my_pid); //log_printf("info->vidpid.vid (%04X) == my_vid (%04X) && info->vidpid.pid (%04X) == my_pid (%04X)\n",info->vidpid.vid,my_vid,info->vidpid.pid,my_pid);
if(info->vidpid.vid == my_vid && info->vidpid.pid == my_pid) { if(info->vidpid.vid == my_vid && info->vidpid.pid == my_pid) {
info->slotdata.hidmask = config_controller_hidmask[i]; info->slotdata.hidmask = config_controller_hidmask[i];
@ -976,7 +976,7 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getNextSlotData(HIDSl
return CONTROLLER_PATCHER_ERROR_NONE; return CONTROLLER_PATCHER_ERROR_NONE;
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getVIDPIDbyDeviceSlot(s32 deviceslot, DeviceVIDPIDInfo * vidpid) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getVIDPIDbyDeviceSlot(int32_t deviceslot, DeviceVIDPIDInfo * vidpid) {
if(vidpid == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if(vidpid == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
if(deviceslot >= gHIDMaxDevices || deviceslot < 0) return CONTROLLER_PATCHER_ERROR_DEVICE_SLOT_NOT_FOUND; if(deviceslot >= gHIDMaxDevices || deviceslot < 0) return CONTROLLER_PATCHER_ERROR_DEVICE_SLOT_NOT_FOUND;
vidpid->vid = config_controller[deviceslot][CONTRPS_VID][0] * 0x100 + config_controller[deviceslot][CONTRPS_VID][1]; vidpid->vid = config_controller[deviceslot][CONTRPS_VID][0] * 0x100 + config_controller[deviceslot][CONTRPS_VID][1];
@ -985,14 +985,14 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::getVIDPIDbyDeviceSlot
return CONTROLLER_PATCHER_ERROR_NONE; return CONTROLLER_PATCHER_ERROR_NONE;
} }
s32 ControllerPatcherUtils::getPadSlotInAdapter(s32 deviceslot, u8 * input_data) { int32_t ControllerPatcherUtils::getPadSlotInAdapter(int32_t deviceslot, uint8_t * input_data) {
s32 slot_incr = 0; int32_t slot_incr = 0;
if(config_controller[deviceslot][CONTRPS_PAD_COUNT][0] != CONTROLLER_PATCHER_INVALIDVALUE) { if(config_controller[deviceslot][CONTRPS_PAD_COUNT][0] != CONTROLLER_PATCHER_INVALIDVALUE) {
s32 pad_count = config_controller[deviceslot][CONTRPS_PAD_COUNT][1]; int32_t pad_count = config_controller[deviceslot][CONTRPS_PAD_COUNT][1];
if(pad_count > HID_MAX_PADS_COUNT) { if(pad_count > HID_MAX_PADS_COUNT) {
pad_count = HID_MAX_PADS_COUNT; pad_count = HID_MAX_PADS_COUNT;
} }
for(s32 i= 0; i<pad_count; i++) { for(int32_t i= 0; i<pad_count; i++) {
if( config_controller[deviceslot][CONTRPS_PAD1_FILTER + i][0] != CONTROLLER_PATCHER_INVALIDVALUE) { if( config_controller[deviceslot][CONTRPS_PAD1_FILTER + i][0] != CONTROLLER_PATCHER_INVALIDVALUE) {
if(input_data[config_controller[deviceslot][CONTRPS_PAD1_FILTER + i][0]] == config_controller[deviceslot][CONTRPS_PAD1_FILTER + i][1]) { if(input_data[config_controller[deviceslot][CONTRPS_PAD1_FILTER + i][0]] == config_controller[deviceslot][CONTRPS_PAD1_FILTER + i][1]) {
slot_incr = i; slot_incr = i;
@ -1021,7 +1021,7 @@ ControllerMappingPAD * ControllerPatcherUtils::getControllerMappingByType(UContr
return cm_map_pad; return cm_map_pad;
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::doSampling(u16 deviceslot,u8 padslot = 0,bool ignorePadSlot = false) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::doSampling(uint16_t deviceslot,uint8_t padslot = 0,BOOL ignorePadSlot = false) {
if(gSamplingCallback != NULL) { if(gSamplingCallback != NULL) {
doSamplingSingle(WPAD_CHAN_0, deviceslot, padslot, ignorePadSlot); doSamplingSingle(WPAD_CHAN_0, deviceslot, padslot, ignorePadSlot);
doSamplingSingle(WPAD_CHAN_1, deviceslot, padslot, ignorePadSlot); doSamplingSingle(WPAD_CHAN_1, deviceslot, padslot, ignorePadSlot);
@ -1031,7 +1031,7 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::doSampling(u16 device
return CONTROLLER_PATCHER_ERROR_NONE; return CONTROLLER_PATCHER_ERROR_NONE;
} }
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::doSamplingSingle(WPADChan chan, u16 deviceslot,u8 padslot = 0,bool ignorePadSlot = false) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::doSamplingSingle(WPADChan chan, uint16_t deviceslot,uint8_t padslot = 0,BOOL ignorePadSlot = false) {
ControllerMappingPADInfo * padinfo = gProPadInfo[chan]; ControllerMappingPADInfo * padinfo = gProPadInfo[chan];
if(padinfo->active) { if(padinfo->active) {
DeviceInfo device_info; DeviceInfo device_info;
@ -1039,10 +1039,10 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherUtils::doSamplingSingle(WPAD
memset(&device_info,0,sizeof(device_info)); memset(&device_info,0,sizeof(device_info));
device_info.vidpid = padinfo->vidpid; device_info.vidpid = padinfo->vidpid;
s32 res = -1; int32_t res = -1;
if((res = ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info)) >= 0) { if((res = ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info)) >= 0) {
if(!ignorePadSlot) { if(!ignorePadSlot) {
s32 real_pad = (padinfo->pad/(device_info.pad_count))*device_info.pad_count; int32_t real_pad = (padinfo->pad/(device_info.pad_count))*device_info.pad_count;
if(real_pad == padslot && device_info.slotdata.deviceslot == deviceslot) { if(real_pad == padslot && device_info.slotdata.deviceslot == deviceslot) {
if(ControllerPatcherUtils::checkActivePad(device_info.slotdata.hidmask,padinfo->pad)) { if(ControllerPatcherUtils::checkActivePad(device_info.slotdata.hidmask,padinfo->pad)) {
gSamplingCallback(chan); gSamplingCallback(chan);

48
source/patcher/ControllerPatcherUtils.hpp
View File

@ -46,7 +46,7 @@ public:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. The returned value is the deviceslot of the given HID-Mask \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. The returned value is the deviceslot of the given HID-Mask
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR getDeviceSlot(u32 hidmask); static CONTROLLER_PATCHER_RESULT_OR_ERROR getDeviceSlot(uint32_t hidmask);
/** /**
\brief Returns the device slot for a given HID-Mask. \brief Returns the device slot for a given HID-Mask.
@ -56,7 +56,7 @@ public:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. The actual result will be store in the given my_cb_user **. \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. The actual result will be store in the given my_cb_user **.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR getDataByHandle(s32 handle, my_cb_user ** data); static CONTROLLER_PATCHER_RESULT_OR_ERROR getDataByHandle(int32_t handle, my_cb_user ** data);
/** /**
\brief Returns the VID/PID for the given device slot. \brief Returns the VID/PID for the given device slot.
@ -66,17 +66,17 @@ public:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. The actual result will be store in the given DeviceVIDPIDInfo *. \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. The actual result will be store in the given DeviceVIDPIDInfo *.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR getVIDPIDbyDeviceSlot(s32 deviceslot, DeviceVIDPIDInfo * vidpid); static CONTROLLER_PATCHER_RESULT_OR_ERROR getVIDPIDbyDeviceSlot(int32_t deviceslot, DeviceVIDPIDInfo * vidpid);
/** \brief Set the VPAD data for a given KPAD data. /** \brief Set the VPAD data for a given KPAD data.
* *
* \param vpad_buffer VPADStatus* A pointer to the VPAD Data where the result will be stored. * \param vpad_buffer VPADStatus* A pointer to the VPAD Data where the result will be stored.
* \param pro_buffer KPADData* A pointer to the given KPADData data. * \param pro_buffer KPADData* A pointer to the given KPADData data.
* \param lastButtonsPressesPRO u32* A pointer to the button presses of the previous call. Will be updated while calling. * \param lastButtonsPressesPRO uint32_t* A pointer to the button presses of the previous call. Will be updated while calling.
* \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. * \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
* *
*/ */
static CONTROLLER_PATCHER_RESULT_OR_ERROR translateToVPAD(VPADStatus * vpad_buffer,KPADStatus * pro_buffer,u32 * lastButtonsPressesVPAD); static CONTROLLER_PATCHER_RESULT_OR_ERROR translateToVPAD(VPADStatus * vpad_buffer,KPADStatus * pro_buffer,uint32_t * lastButtonsPressesVPAD);
private: private:
/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- /*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Analyse inputs * Analyse inputs
@ -85,12 +85,12 @@ private:
/** \brief Checks if a the given @p VPADButton was pressed in the given HID @data. When it was pressed, the result will be set the in given @p buttons_hold /** \brief Checks if a the given @p VPADButton was pressed in the given HID @data. When it was pressed, the result will be set the in given @p buttons_hold
* *
* \param data Pointer to the HID_Data from where the input is read. * \param data Pointer to the HID_Data from where the input is read.
* \param buttons_hold Pointer to the u32 where the result will be written to. * \param buttons_hold Pointer to the uint32_t where the result will be written to.
* \param VPADButton The button that will be checked * \param VPADButton The button that will be checked
* \return When the functions failed result < 0 is returned.If the result is >= 0 the function was successful. * \return When the functions failed result < 0 is returned.If the result is >= 0 the function was successful.
* *
*/ */
static CONTROLLER_PATCHER_RESULT_OR_ERROR getButtonPressed(HID_Data * data, s32 * buttons_hold, s32 VPADButton); static CONTROLLER_PATCHER_RESULT_OR_ERROR getButtonPressed(HID_Data * data, int32_t * buttons_hold, int32_t VPADButton);
/** \brief Checks if a given value is set in the HID_DATA given the data in the slot number provided by cur_config. /** \brief Checks if a given value is set in the HID_DATA given the data in the slot number provided by cur_config.
@ -100,7 +100,7 @@ private:
* \return When the functions failed result < 0 is returned. If the value is set, 1 will be returned. Otherwise 0. * \return When the functions failed result < 0 is returned. If the value is set, 1 will be returned. Otherwise 0.
* *
*/ */
static CONTROLLER_PATCHER_RESULT_OR_ERROR isValueSet(HID_Data * data,s32 cur_config); static CONTROLLER_PATCHER_RESULT_OR_ERROR isValueSet(HID_Data * data,int32_t cur_config);
/** \brief Checks if a given key in the keyboard data is pressed. /** \brief Checks if a given key in the keyboard data is pressed.
@ -110,7 +110,7 @@ private:
* \return When the functions failed result < 0 is returned. If the key is active pressed, 1 is returned. * \return When the functions failed result < 0 is returned. If the key is active pressed, 1 is returned.
* *
*/ */
static CONTROLLER_PATCHER_RESULT_OR_ERROR isInKeyboardData(unsigned char * keyboardData,s32 key); static CONTROLLER_PATCHER_RESULT_OR_ERROR isInKeyboardData(unsigned char * keyboardData,int32_t key);
/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- /*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Utils for setting the Button data * Utils for setting the Button data
@ -126,7 +126,7 @@ private:
* \return When the functions failed result < 0 is returned. If the pad is active/connected, 1 is returned. * \return When the functions failed result < 0 is returned. If the pad is active/connected, 1 is returned.
* *
*/ */
static CONTROLLER_PATCHER_RESULT_OR_ERROR setButtonRemappingData(VPADStatus * old_buffer, VPADStatus * new_buffer,u32 VPADButton, s32 CONTRPS_SLOT); static CONTROLLER_PATCHER_RESULT_OR_ERROR setButtonRemappingData(VPADStatus * old_buffer, VPADStatus * new_buffer,uint32_t VPADButton, int32_t CONTRPS_SLOT);
/** /**
\brief Checks if a given button (oldVPADButton) is set in a given VPADStatus struct (old_buffer). If its set, it will set an other \brief Checks if a given button (oldVPADButton) is set in a given VPADStatus struct (old_buffer). If its set, it will set an other
@ -139,7 +139,7 @@ private:
\return When the functions failed result < 0 is returned. If the pad is active/connected, 1 is returned. \return When the functions failed result < 0 is returned. If the pad is active/connected, 1 is returned.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR setButtonData(VPADStatus * old_buffer, VPADStatus * new_buffer,u32 oldVPADButton,u32 newVPADButton); static CONTROLLER_PATCHER_RESULT_OR_ERROR setButtonData(VPADStatus * old_buffer, VPADStatus * new_buffer,uint32_t oldVPADButton,uint32_t newVPADButton);
/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- /*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Pad Status functions * Pad Status functions
@ -152,7 +152,7 @@ private:
\return When the functions failed result < 0 is returned. If the pad is active/connected, 1 is returned. \return When the functions failed result < 0 is returned. If the pad is active/connected, 1 is returned.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR checkActivePad(u32 hidmask,s32 pad); static CONTROLLER_PATCHER_RESULT_OR_ERROR checkActivePad(uint32_t hidmask,int32_t pad);
/** /**
\brief Returns the first active pad of devices with the given HID-Mask. Currently only implemented for the GC-Adapter. Every other pad will always return 0. \brief Returns the first active pad of devices with the given HID-Mask. Currently only implemented for the GC-Adapter. Every other pad will always return 0.
@ -161,7 +161,7 @@ private:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. The returned value is fist active pad. \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. The returned value is fist active pad.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR getActivePad(u32 hidmask); static CONTROLLER_PATCHER_RESULT_OR_ERROR getActivePad(uint32_t hidmask);
/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- /*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Stick functions * Stick functions
@ -187,7 +187,7 @@ private:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
**/ **/
static f32 convertAnalogValue(u8 value, u8 default_val, u8 min, u8 max, u8 invert,u8 deadzone); static float convertAnalogValue(uint8_t value, uint8_t default_val, uint8_t min, uint8_t max, uint8_t invert,uint8_t deadzone);
/** /**
\brief Calculates a the stick data (VPADVec2D) from given digital direction. \brief Calculates a the stick data (VPADVec2D) from given digital direction.
@ -196,7 +196,7 @@ private:
\return The VPADVec2D with the set values. \return The VPADVec2D with the set values.
**/ **/
static VPADVec2D getAnalogValueByButtons(u8 stick_values); static VPADVec2D getAnalogValueByButtons(uint8_t stick_values);
/** /**
\brief Handles the analog-stick data of HID devices. The result will written in the VPADStatus buffer. \brief Handles the analog-stick data of HID devices. The result will written in the VPADStatus buffer.
@ -239,7 +239,7 @@ private:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR setEmulatedSticks(VPADStatus * buffer, u32 * last_emulatedSticks); static CONTROLLER_PATCHER_RESULT_OR_ERROR setEmulatedSticks(VPADStatus * buffer, uint32_t * last_emulatedSticks);
/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- /*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Other functions * Other functions
@ -248,11 +248,11 @@ private:
* *
* \param vpad_buffer VPADStatus* A pointer to the given VPAD Data. * \param vpad_buffer VPADStatus* A pointer to the given VPAD Data.
* \param pro_buffer KPADData* A pointer to the KPADData where the result will be stored. * \param pro_buffer KPADData* A pointer to the KPADData where the result will be stored.
* \param lastButtonsPressesPRO u32* A pointer to the button presses of the previous call. Will be updated while calling. * \param lastButtonsPressesPRO uint32_t* A pointer to the button presses of the previous call. Will be updated while calling.
* \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. * \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
* *
*/ */
static CONTROLLER_PATCHER_RESULT_OR_ERROR translateToPro(VPADStatus * vpad_buffer, KPADStatus * pro_buffer, u32 * lastButtonsPressesPRO); static CONTROLLER_PATCHER_RESULT_OR_ERROR translateToPro(VPADStatus * vpad_buffer, KPADStatus * pro_buffer, uint32_t * lastButtonsPressesPRO);
static CONTROLLER_PATCHER_RESULT_OR_ERROR translateToProWPADRead(VPADStatus * vpad_buffer,WPADStatusProController * pro_buffer); static CONTROLLER_PATCHER_RESULT_OR_ERROR translateToProWPADRead(VPADStatus * vpad_buffer,WPADStatusProController * pro_buffer);
/** /**
@ -264,16 +264,16 @@ private:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR checkValueinConfigController(s32 device_slot,s32 CONTRPS_slot,s32 expectedValue); static CONTROLLER_PATCHER_RESULT_OR_ERROR checkValueinConfigController(int32_t device_slot,int32_t CONTRPS_slot,int32_t expectedValue);
/** /**
\brief Sets two u8 values to the given pointer. \brief Sets two uint8_t values to the given pointer.
\param dest: pointer to the destination array. \param dest: pointer to the destination array.
\param first: Value that will be written in @p dest[0] \param first: Value that will be written in @p dest[0]
\param second: Value that will be written in @p dest[1] \param second: Value that will be written in @p dest[1]
**/ **/
static void setConfigValue(u8 * dest , u8 first, u8 second); static void setConfigValue(uint8_t * dest , uint8_t first, uint8_t second);
/** /**
\brief Saves a new free device slot and the corresponding HID-Mask in the given @p HIDSlotData pointer \brief Saves a new free device slot and the corresponding HID-Mask in the given @p HIDSlotData pointer
@ -302,7 +302,7 @@ private:
\param current input data \param current input data
\return The relative slot in the device \return The relative slot in the device
**/ **/
static s32 getPadSlotInAdapter(s32 deviceslot, u8 * input_data); static int32_t getPadSlotInAdapter(int32_t deviceslot, uint8_t * input_data);
/** /**
\brief returns a pointer to the ControllerMapping to the given controller type \brief returns a pointer to the ControllerMapping to the given controller type
@ -313,9 +313,9 @@ private:
**/ **/
static ControllerMappingPAD * getControllerMappingByType(UController_Type type); static ControllerMappingPAD * getControllerMappingByType(UController_Type type);
static CONTROLLER_PATCHER_RESULT_OR_ERROR doSampling(u16 deviceslot,u8 padslot,bool ignorePadSlot); static CONTROLLER_PATCHER_RESULT_OR_ERROR doSampling(uint16_t deviceslot,uint8_t padslot,BOOL ignorePadSlot);
static CONTROLLER_PATCHER_RESULT_OR_ERROR doSamplingSingle(WPADChan chan, u16 deviceslot, u8 padslot, bool ignorePadSlot); static CONTROLLER_PATCHER_RESULT_OR_ERROR doSamplingSingle(WPADChan chan, uint16_t deviceslot, uint8_t padslot, BOOL ignorePadSlot);
}; };
#endif /* _CONTROLLER_PATCHER_UTIL_H_ */ #endif /* _CONTROLLER_PATCHER_UTIL_H_ */

58
source/utils/CPRetainVars.cpp
View File

@ -19,56 +19,56 @@
ControllerMapping gControllerMapping __attribute__((section(".data"))); ControllerMapping gControllerMapping __attribute__((section(".data")));
u8 gConfig_done __attribute__((section(".data"))) = 0; uint8_t gConfig_done __attribute__((section(".data"))) = 0;
u8 gButtonRemappingConfigDone __attribute__((section(".data"))) = 0; uint8_t gButtonRemappingConfigDone __attribute__((section(".data"))) = 0;
u32 gHIDAttached __attribute__((section(".data"))) = 0; uint32_t gHIDAttached __attribute__((section(".data"))) = 0;
u32 gHIDCurrentDevice __attribute__((section(".data"))) = 0; uint32_t gHIDCurrentDevice __attribute__((section(".data"))) = 0;
u16 gHIDRegisteredDevices __attribute__((section(".data"))) = 0; uint16_t gHIDRegisteredDevices __attribute__((section(".data"))) = 0;
HIDClient gHIDClient __attribute__((section(".data"))); HIDClient gHIDClient __attribute__((section(".data")));
HID_DEVICE_DATA gHID_Devices[gHIDMaxDevices] __attribute__((section(".data"))); HID_DEVICE_DATA gHID_Devices[gHIDMaxDevices] __attribute__((section(".data")));
u8 gHID_Mouse_Mode __attribute__((section(".data"))) = HID_MOUSE_MODE_TOUCH; uint8_t gHID_Mouse_Mode __attribute__((section(".data"))) = HID_MOUSE_MODE_TOUCH;
u8 gMouseModeCoolDown __attribute__((section(".data"))) = 0; uint8_t gMouseModeCoolDown __attribute__((section(".data"))) = 0;
u32 gGamePadValues[CONTRPS_MAX_VALUE] __attribute__((section(".data"))); uint32_t gGamePadValues[CONTRPS_MAX_VALUE] __attribute__((section(".data")));
u8 config_controller[gHIDMaxDevices][CONTRPS_MAX_VALUE][2] __attribute__((section(".data"))); uint8_t config_controller[gHIDMaxDevices][CONTRPS_MAX_VALUE][2] __attribute__((section(".data")));
u32 config_controller_hidmask[gHIDMaxDevices] __attribute__((section(".data"))); uint32_t config_controller_hidmask[gHIDMaxDevices] __attribute__((section(".data")));
u32 gHID_LIST_GC __attribute__((section(".data"))) = 0; uint32_t gHID_LIST_GC __attribute__((section(".data"))) = 0;
u32 gHID_LIST_DS3 __attribute__((section(".data"))) = 0; uint32_t gHID_LIST_DS3 __attribute__((section(".data"))) = 0;
u32 gHID_LIST_DS4 __attribute__((section(".data"))) = 0; uint32_t gHID_LIST_DS4 __attribute__((section(".data"))) = 0;
u32 gHID_LIST_KEYBOARD __attribute__((section(".data"))) = 0; uint32_t gHID_LIST_KEYBOARD __attribute__((section(".data"))) = 0;
u32 gHID_LIST_SWITCH_PRO __attribute__((section(".data"))) = 0; uint32_t gHID_LIST_SWITCH_PRO __attribute__((section(".data"))) = 0;
u32 gHID_LIST_MOUSE __attribute__((section(".data"))) = 0; uint32_t gHID_LIST_MOUSE __attribute__((section(".data"))) = 0;
u16 gGamePadSlot __attribute__((section(".data"))) = 0; uint16_t gGamePadSlot __attribute__((section(".data"))) = 0;
u16 gHID_SLOT_GC __attribute__((section(".data"))) = 0; uint16_t gHID_SLOT_GC __attribute__((section(".data"))) = 0;
u16 gHID_SLOT_KEYBOARD __attribute__((section(".data"))) = 0; uint16_t gHID_SLOT_KEYBOARD __attribute__((section(".data"))) = 0;
u16 gMouseSlot __attribute__((section(".data"))) = 0; uint16_t gMouseSlot __attribute__((section(".data"))) = 0;
u8 gOriginalDimState __attribute__((section(".data"))) = 0; uint8_t gOriginalDimState __attribute__((section(".data"))) = 0;
u8 gOriginalAPDState __attribute__((section(".data"))) = 0; uint8_t gOriginalAPDState __attribute__((section(".data"))) = 0;
u16 gNetworkController[gHIDMaxDevices][HID_MAX_PADS_COUNT][4] __attribute__((section(".data"))); uint16_t gNetworkController[gHIDMaxDevices][HID_MAX_PADS_COUNT][4] __attribute__((section(".data")));
s32 gHIDNetworkClientID __attribute__((section(".data"))) = 0; int32_t gHIDNetworkClientID __attribute__((section(".data"))) = 0;
u8 gUsedProtocolVersion __attribute__((section(".data"))) = WIIU_CP_TCP_HANDSHAKE; uint8_t gUsedProtocolVersion __attribute__((section(".data"))) = WIIU_CP_TCP_HANDSHAKE;
WPADConnectCallback gWPADConnectCallback[4] __attribute__((section(".data"))); WPADConnectCallback gWPADConnectCallback[4] __attribute__((section(".data")));
WPADConnectCallback gKPADConnectCallback[4] __attribute__((section(".data"))); WPADConnectCallback gKPADConnectCallback[4] __attribute__((section(".data")));
WPADExtensionCallback gExtensionCallback[4] __attribute__((section(".data"))); WPADExtensionCallback gExtensionCallback[4] __attribute__((section(".data")));
WPADSamplingCallback gSamplingCallback __attribute__((section(".data"))) = 0; WPADSamplingCallback gSamplingCallback __attribute__((section(".data"))) = 0;
u8 gCallbackCooldown __attribute__((section(".data"))) = 0; uint8_t gCallbackCooldown __attribute__((section(".data"))) = 0;
u8 gNetworkControllerActivated __attribute__((section(".data"))) = 1; uint8_t gNetworkControllerActivated __attribute__((section(".data"))) = 1;
u8 gGlobalRumbleActivated __attribute__((section(".data"))) = 0; uint8_t gGlobalRumbleActivated __attribute__((section(".data"))) = 0;
u32 gUDPClientip __attribute__((section(".data"))) = 0; uint32_t gUDPClientip __attribute__((section(".data"))) = 0;
ControllerMappingPADInfo* gProPadInfo[4] __attribute__((section(".data"))) = {&gControllerMapping.proController[0].pad_infos[0], ControllerMappingPADInfo* gProPadInfo[4] __attribute__((section(".data"))) = {&gControllerMapping.proController[0].pad_infos[0],
&gControllerMapping.proController[1].pad_infos[0], &gControllerMapping.proController[1].pad_infos[0],
&gControllerMapping.proController[2].pad_infos[0], &gControllerMapping.proController[2].pad_infos[0],

58
source/utils/CPRetainVars.hpp
View File

@ -22,55 +22,55 @@
extern ControllerMapping gControllerMapping; extern ControllerMapping gControllerMapping;
extern u8 gConfig_done; extern uint8_t gConfig_done;
extern u8 gButtonRemappingConfigDone; extern uint8_t gButtonRemappingConfigDone;
extern u32 gHIDAttached; extern uint32_t gHIDAttached;
extern u32 gHIDCurrentDevice; extern uint32_t gHIDCurrentDevice;
extern HIDClient gHIDClient; extern HIDClient gHIDClient;
extern u16 gHIDRegisteredDevices; extern uint16_t gHIDRegisteredDevices;
extern HID_DEVICE_DATA gHID_Devices[gHIDMaxDevices]; extern HID_DEVICE_DATA gHID_Devices[gHIDMaxDevices];
extern u8 gHID_Mouse_Mode; extern uint8_t gHID_Mouse_Mode;
extern u8 gMouseModeCoolDown; extern uint8_t gMouseModeCoolDown;
extern u32 gGamePadValues[CONTRPS_MAX_VALUE]; extern uint32_t gGamePadValues[CONTRPS_MAX_VALUE];
extern u8 config_controller[gHIDMaxDevices][CONTRPS_MAX_VALUE][2]; extern uint8_t config_controller[gHIDMaxDevices][CONTRPS_MAX_VALUE][2];
extern u32 config_controller_hidmask[gHIDMaxDevices]; extern uint32_t config_controller_hidmask[gHIDMaxDevices];
extern u32 gHID_LIST_GC; extern uint32_t gHID_LIST_GC;
extern u32 gHID_LIST_DS3; extern uint32_t gHID_LIST_DS3;
extern u32 gHID_LIST_DS4; extern uint32_t gHID_LIST_DS4;
extern u32 gHID_LIST_KEYBOARD; extern uint32_t gHID_LIST_KEYBOARD;
extern u32 gHID_LIST_SWITCH_PRO; extern uint32_t gHID_LIST_SWITCH_PRO;
extern u32 gHID_LIST_MOUSE; extern uint32_t gHID_LIST_MOUSE;
extern u16 gGamePadSlot; extern uint16_t gGamePadSlot;
extern u16 gHID_SLOT_GC; extern uint16_t gHID_SLOT_GC;
extern u16 gHID_SLOT_KEYBOARD; extern uint16_t gHID_SLOT_KEYBOARD;
extern u16 gMouseSlot; extern uint16_t gMouseSlot;
extern u8 gOriginalDimState; extern uint8_t gOriginalDimState;
extern u8 gOriginalAPDState; extern uint8_t gOriginalAPDState;
extern u16 gNetworkController[gHIDMaxDevices][HID_MAX_PADS_COUNT][4]; extern uint16_t gNetworkController[gHIDMaxDevices][HID_MAX_PADS_COUNT][4];
extern s32 gHIDNetworkClientID; extern int32_t gHIDNetworkClientID;
extern u8 gUsedProtocolVersion; extern uint8_t gUsedProtocolVersion;
extern WPADConnectCallback gWPADConnectCallback[4]; extern WPADConnectCallback gWPADConnectCallback[4];
extern WPADConnectCallback gKPADConnectCallback[4]; extern WPADConnectCallback gKPADConnectCallback[4];
extern WPADExtensionCallback gExtensionCallback[4]; extern WPADExtensionCallback gExtensionCallback[4];
extern WPADSamplingCallback gSamplingCallback; extern WPADSamplingCallback gSamplingCallback;
extern u8 gCallbackCooldown; extern uint8_t gCallbackCooldown;
extern u8 gGlobalRumbleActivated; extern uint8_t gGlobalRumbleActivated;
extern u8 gNetworkControllerActivated; extern uint8_t gNetworkControllerActivated;
extern u32 gUDPClientip; extern uint32_t gUDPClientip;
extern ControllerMappingPADInfo* gProPadInfo[4]; extern ControllerMappingPADInfo* gProPadInfo[4];
#endif // CP_RETAINS_VARS_H_ #endif // CP_RETAINS_VARS_H_