The-Homebrew-Cloud/controller_patcher
2
0
Fork 0
mirror of https://github.com/Maschell/controller_patcher.git synced 2024-11-24 21:16:52 +01:00
Code Issues Packages Projects Releases Wiki Activity

Add a .clang_format

Browse Source
This commit is contained in:
Maschell 2023-04-10 11:45:58 +02:00
parent c8a077574e
commit 7c4232e177
37 changed files with 3074 additions and 3005 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
.clang-format Normal file
View File

@ -0,0 +1,67 @@
# Generated from CLion C/C++ Code Style settings
BasedOnStyle: LLVM
AccessModifierOffset: -4
AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: Consecutive
AlignConsecutiveMacros: AcrossEmptyLinesAndComments
AlignOperands: Align
AllowAllArgumentsOnNextLine: false
AllowAllConstructorInitializersOnNextLine: false
AllowAllParametersOfDeclarationOnNextLine: false
AllowShortBlocksOnASingleLine: Always
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: All
AllowShortIfStatementsOnASingleLine: Always
AllowShortLambdasOnASingleLine: All
AllowShortLoopsOnASingleLine: true
AlwaysBreakAfterReturnType: None
AlwaysBreakTemplateDeclarations: Yes
BreakBeforeBraces: Custom
BraceWrapping:
AfterCaseLabel: false
AfterClass: false
AfterControlStatement: Never
AfterEnum: false
AfterFunction: false
AfterNamespace: false
AfterUnion: false
BeforeCatch: false
BeforeElse: false
IndentBraces: false
SplitEmptyFunction: false
SplitEmptyRecord: true
BreakBeforeBinaryOperators: None
BreakBeforeTernaryOperators: true
BreakConstructorInitializers: BeforeColon
BreakInheritanceList: BeforeColon
ColumnLimit: 0
CompactNamespaces: false
ContinuationIndentWidth: 8
IndentCaseLabels: true
IndentPPDirectives: None
IndentWidth: 4
KeepEmptyLinesAtTheStartOfBlocks: true
MaxEmptyLinesToKeep: 2
NamespaceIndentation: All
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PointerAlignment: Right
ReflowComments: false
SpaceAfterCStyleCast: true
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: false
SpaceBeforeAssignmentOperators: true
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: false
SpacesInCStyleCastParentheses: false
SpacesInContainerLiterals: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
TabWidth: 4
UseTab: Never

4
README.md
View File

@ -50,6 +50,10 @@ ControllerPatcher::DeInit();
ControllerPatcher::stopNetworkServer();
```
## Format the code via docker
`docker run --rm -v ${PWD}:/src ghcr.io/wiiu-env/clang-format:13.0.0-2 -r ./source ./include -i`
# Credits:
- Maschell
- FIX94 - huge thanks to him and his initally created gc-to-vpad. Was a motivation and base to start all this

26
include/controller_patcher/ControllerPatcher.hpp
View File

@ -29,9 +29,9 @@
#include <string>
#include "ControllerPatcherDefs.h"
#include <padscore/wpad.h>
#include <vpad/input.h>
#include "ControllerPatcherDefs.h"
class ControllerPatcher {
public:
@ -48,7 +48,7 @@ public:
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
@ -84,7 +84,7 @@ public:
@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,int32_t chan,int32_t mode = PRO_CONTROLLER_MODE_KPADDATA);
static CONTROLLER_PATCHER_RESULT_OR_ERROR setProControllerDataFromHID(void *data, int32_t chan, int32_t mode = PRO_CONTROLLER_MODE_KPADDATA);
/**
@ -96,7 +96,7 @@ public:
@return When the functions failed result < 0 is returned. If the result is == 0 the function was successful.
**/
static CONTROLLER_PATCHER_RESULT_OR_ERROR setControllerDataFromHID(VPADStatus * buffer);
static CONTROLLER_PATCHER_RESULT_OR_ERROR setControllerDataFromHID(VPADStatus *buffer);
/*-----------------------------------------------------------------------------------------------------------------------------------
* Useful functions
@ -144,7 +144,7 @@ public:
@return When the functions failed result < 0 is returned. If the result is == 0 the function was successful.
**/
static CONTROLLER_PATCHER_RESULT_OR_ERROR addControllerMapping(UController_Type type,ControllerMappingPADInfo config);
static CONTROLLER_PATCHER_RESULT_OR_ERROR addControllerMapping(UController_Type type, ControllerMappingPADInfo config);
/**
@ -158,7 +158,7 @@ public:
@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.
**/
static ControllerMappingPADInfo * getControllerMappingInfo(UController_Type type,int32_t 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.
@ -168,13 +168,13 @@ public:
@return
**/
static BOOL isControllerConnectedAndActive(UController_Type type,int32_t 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.
@return A pointer to the first connected mouse that is found. NULL if no mouse is connected.
**/
static HID_Mouse_Data * getMouseData();
static HID_Mouse_Data *getMouseData();
/**
Sets a rumble status for a controller.
@ -184,7 +184,7 @@ public:
@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,uint32_t 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.
@ -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.
**/
static CONTROLLER_PATCHER_RESULT_OR_ERROR gettingInputAllDevices(InputData * output,int32_t 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.
@ -204,7 +204,7 @@ public:
@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, int32_t 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..
@ -213,9 +213,9 @@ public:
@return When the functions failed result < 0 is returned. If the result is == 0 the function was successful.
**/
static CONTROLLER_PATCHER_RESULT_OR_ERROR printVPADButtons(VPADStatus * buffer);
static CONTROLLER_PATCHER_RESULT_OR_ERROR printVPADButtons(VPADStatus *buffer);
static std::string getIdentifierByVIDPID(uint16_t vid,uint16_t pid);
static std::string getIdentifierByVIDPID(uint16_t vid, uint16_t pid);
static void destroyConfigHelper();

588
include/controller_patcher/ControllerPatcherDefs.h
View File

@ -31,79 +31,79 @@
#define FIRST_INSTRUCTION_IN_SAMPLING_CALLBACK 0x9421FFB8
#define HID_INIT_NOT_DONE 0
#define HID_INIT_DONE 1
#define HID_SDCARD_READ 2
#define HID_INIT_NOT_DONE 0
#define HID_INIT_DONE 1
#define HID_SDCARD_READ 2
#define gHIDMaxDevices 32
#define HID_MAX_DATA_LENGTH_PER_PAD 16
#define HID_MAX_PADS_COUNT 5
#define HID_MAX_DEVICES_PER_SLOT 2
#define gHIDMaxDevices 32
#define HID_MAX_DATA_LENGTH_PER_PAD 16
#define HID_MAX_PADS_COUNT 5
#define HID_MAX_DEVICES_PER_SLOT 2
#define NETWORK_CONTROLLER_VID 0
#define NETWORK_CONTROLLER_PID 1
#define NETWORK_CONTROLLER_ACTIVE 2
#define NETWORK_CONTROLLER_HANDLE 3
#define NETWORK_CONTROLLER_VID 0
#define NETWORK_CONTROLLER_PID 1
#define NETWORK_CONTROLLER_ACTIVE 2
#define NETWORK_CONTROLLER_HANDLE 3
#define CONTROLLER_PATCHER_VALUE_SET 0x01
#define CONTROLLER_PATCHER_GC_DOUBLE_USE 0x01
#define CONTROLLER_PATCHER_INVALIDVALUE 0xFF
#define CONTROLLER_PATCHER_VALUE_SET 0x01
#define CONTROLLER_PATCHER_GC_DOUBLE_USE 0x01
#define CONTROLLER_PATCHER_INVALIDVALUE 0xFF
#define HID_INVALID_SLOT 0xFFFF
#define HID_INVALID_HIDMASK 0xFFFFFFFF
#define HID_INVALID_SLOT 0xFFFF
#define HID_INVALID_HIDMASK 0xFFFFFFFF
typedef int CONTROLLER_PATCHER_RESULT_OR_ERROR;
#define CONTROLLER_PATCHER_ERROR_NONE 0
#define CONTROLLER_PATCHER_ERROR_INVALID_CHAN -1
#define CONTROLLER_PATCHER_ERROR_UNKNOWN_VID_PID -2
#define CONTROLLER_PATCHER_ERROR_FAILED_TO_GET_HIDDATA -3
#define CONTROLLER_PATCHER_ERROR_MAPPING_DISABLED -4
#define CONTROLLER_PATCHER_ERROR_INVALID_BUFFER -5
#define CONTROLLER_PATCHER_ERROR_HID_NOT_CONNECTED -6
#define CONTROLLER_PATCHER_ERROR_NO_PAD_CONNECTED -7
#define CONTROLLER_PATCHER_ERROR_DEVICE_SLOT_NOT_FOUND -8
#define CONTROLLER_PATCHER_ERROR_NULL_POINTER -9
#define CONTROLLER_PATCHER_ERROR_CONFIG_NOT_DONE -10
#define CONTROLLER_PATCHER_ERROR_NO_FREE_SLOT -11
#define CONTROLLER_PATCHER_ERROR_UNKNOWN -50
#define CONTROLLER_PATCHER_ERROR_NONE 0
#define CONTROLLER_PATCHER_ERROR_INVALID_CHAN -1
#define CONTROLLER_PATCHER_ERROR_UNKNOWN_VID_PID -2
#define CONTROLLER_PATCHER_ERROR_FAILED_TO_GET_HIDDATA -3
#define CONTROLLER_PATCHER_ERROR_MAPPING_DISABLED -4
#define CONTROLLER_PATCHER_ERROR_INVALID_BUFFER -5
#define CONTROLLER_PATCHER_ERROR_HID_NOT_CONNECTED -6
#define CONTROLLER_PATCHER_ERROR_NO_PAD_CONNECTED -7
#define CONTROLLER_PATCHER_ERROR_DEVICE_SLOT_NOT_FOUND -8
#define CONTROLLER_PATCHER_ERROR_NULL_POINTER -9
#define CONTROLLER_PATCHER_ERROR_CONFIG_NOT_DONE -10
#define CONTROLLER_PATCHER_ERROR_NO_FREE_SLOT -11
#define CONTROLLER_PATCHER_ERROR_UNKNOWN -50
#define PRO_CONTROLLER_MODE_KPADDATA 0
#define PRO_CONTROLLER_MODE_WPADReadData 1
#define PRO_CONTROLLER_MODE_KPADDATA 0
#define PRO_CONTROLLER_MODE_WPADReadData 1
#define STICK_VALUE_UP 1 << 1
#define STICK_VALUE_DOWN 1 << 2
#define STICK_VALUE_LEFT 1 << 3
#define STICK_VALUE_RIGHT 1 << 4
#define STICK_VALUE_UP 1 << 1
#define STICK_VALUE_DOWN 1 << 2
#define STICK_VALUE_LEFT 1 << 3
#define STICK_VALUE_RIGHT 1 << 4
/**
* @brief The enumeration of Controller sticks defines
*/
enum Controller_Stick_Defines {
STICK_CONF_MAGIC_VERSION, /**< Version of the stick configuration. Changes with every format*/
STICK_CONF_BYTE, /**< Byte where the stick-axis data is stored*/
STICK_CONF_DEFAULT, /**< Default value*/
STICK_CONF_DEADZONE, /**< Size of the deadzone */
STICK_CONF_INVERT, /**< Is 1 when the axis is inverted */
STICK_CONF_MIN, /**< Value that represent the minimum value (-1.0f)*/
STICK_CONF_MAX, /**< Value that represent the maximum value (1.0f) */
STICK_CONF_ENUM_MAXVALUE /**< Maxmimum enum value for iteration*/
STICK_CONF_MAGIC_VERSION, /**< Version of the stick configuration. Changes with every format*/
STICK_CONF_BYTE, /**< Byte where the stick-axis data is stored*/
STICK_CONF_DEFAULT, /**< Default value*/
STICK_CONF_DEADZONE, /**< Size of the deadzone */
STICK_CONF_INVERT, /**< Is 1 when the axis is inverted */
STICK_CONF_MIN, /**< Value that represent the minimum value (-1.0f)*/
STICK_CONF_MAX, /**< Value that represent the maximum value (1.0f) */
STICK_CONF_ENUM_MAXVALUE /**< Maxmimum enum value for iteration*/
};
#define STICK_CONF_MAGIC_VALUE 0xF0 // When you change the enum above, Dont forget to change the magic version!!!!
//! most data has the format: byte,value (byte starting at 0)
enum Controller_Patcher_Settings {
CONTRPS_VID, //! pid: 0x451d would be 0x45,0x1d
CONTRPS_PID, //! vid: 0x488d would be 0x48,0x8d
CONTRPS_BUF_SIZE, //! To set: CONTROLLER_PATCHER_VALUE_SET, BUF_SIZE (default is 64)
CONTRPS_VID, //! pid: 0x451d would be 0x45,0x1d
CONTRPS_PID, //! vid: 0x488d would be 0x48,0x8d
CONTRPS_BUF_SIZE, //! To set: CONTROLLER_PATCHER_VALUE_SET, BUF_SIZE (default is 64)
CONTRPS_VPAD_BUTTON_A,
CONTRPS_VPAD_BUTTON_B,
CONTRPS_VPAD_BUTTON_X,
CONTRPS_VPAD_BUTTON_Y,
CONTRPS_DPAD_MODE, //! To set mode: CONTROLLER_PATCHER_VALUE_SET, Controller_Patcher_DPAD_MODE (default is normal mode)
CONTRPS_DPAD_MASK, //! Mask needed for hat mode: CONTROLLER_PATCHER_VALUE_SET, mask
CONTRPS_DPAD_MODE, //! To set mode: CONTROLLER_PATCHER_VALUE_SET, Controller_Patcher_DPAD_MODE (default is normal mode)
CONTRPS_DPAD_MASK, //! Mask needed for hat mode: CONTROLLER_PATCHER_VALUE_SET, mask
/* Normal DPAD */
CONTRPS_VPAD_BUTTON_LEFT,
CONTRPS_VPAD_BUTTON_RIGHT,
@ -175,7 +175,7 @@ enum Controller_Patcher_Settings {
CONTRPS_VPAD_STICK_R_COPY_DPAD,
CONTRPS_VPAD_BUTTON_TV,
CONTRPS_DOUBLE_USE, //!When used: e.g. CONTROLLER_PATCHER_VALUE_SET, CONTROLLER_PATCHER_GC_DOUBLE_USE
CONTRPS_DOUBLE_USE, //!When used: e.g. CONTROLLER_PATCHER_VALUE_SET, CONTROLLER_PATCHER_GC_DOUBLE_USE
CONTRPS_DOUBLE_USE_BUTTON_ACTIVATOR,
CONTRPS_DOUBLE_USE_BUTTON_1_PRESSED,
CONTRPS_DOUBLE_USE_BUTTON_2_PRESSED,
@ -187,14 +187,14 @@ enum Controller_Patcher_Settings {
CONTRPS_DOUBLE_USE_BUTTON_3_RELEASED,
CONTRPS_DOUBLE_USE_BUTTON_4_RELEASED,
CONTRPS_DOUBLE_USE_BUTTON_5_RELEASED,
CONTRPS_PAD_COUNT, //!
CONTRPS_CONNECTED_PADS, //!
CONTRPS_INPUT_FILTER, //!
CONTRPS_PAD1_FILTER, //!
CONTRPS_PAD2_FILTER, //!
CONTRPS_PAD3_FILTER, //!
CONTRPS_PAD4_FILTER, //!
CONTRPS_PAD5_FILTER, //!
CONTRPS_PAD_COUNT, //!
CONTRPS_CONNECTED_PADS, //!
CONTRPS_INPUT_FILTER, //!
CONTRPS_PAD1_FILTER, //!
CONTRPS_PAD2_FILTER, //!
CONTRPS_PAD3_FILTER, //!
CONTRPS_PAD4_FILTER, //!
CONTRPS_PAD5_FILTER, //!
CONTRPS_MOUSE_STICK,
CONTRPS_MAX_VALUE
};
@ -202,9 +202,9 @@ enum Controller_Patcher_Settings {
* @brief The enumeration of different DPAD-Modes
*/
enum Controller_Patcher_DPAD_MODE {
CONTRPDM_Normal, /**< Normal mode */
CONTRPDM_Hat, /**< Hat mode */
CONTRPDM_Absolute_2Values, /**< DPAD Value stored in 2 values (one for each axis), acting like a stick */
CONTRPDM_Normal, /**< Normal mode */
CONTRPDM_Hat, /**< Hat mode */
CONTRPDM_Absolute_2Values, /**< DPAD Value stored in 2 values (one for each axis), acting like a stick */
};
/**
* @brief The enumeration of DPAD Settings. Needed for saving both in the PADConst.
@ -218,20 +218,20 @@ enum Controller_Patcher_DPAD_Settings {
* @brief Stores data if the Slot the device is using in gHID_Devices
*/
typedef struct _HIDSlotData {
uint16_t deviceslot; /**< deviceslot number */
uint32_t hidmask; /**< Used HID-Mask */
uint16_t deviceslot; /**< deviceslot number */
uint32_t hidmask; /**< Used HID-Mask */
} HIDSlotData;
/**
* @brief Struct where the data for the callback funtion is stored
*/
typedef struct _my_cb_user {
uint8_t *buf; /**< pointer the buffer that is used */
uint32_t transfersize; /**< number of transfered data */
uint32_t handle; /**< HID handle */
HIDSlotData slotdata; /**< Information about the deviceslot and hidmask */
uint32_t pads_per_device; /**< Number of maximum pads of this device */
uint8_t pad_slot; /**< number of the pad that will be used */
uint8_t *buf; /**< pointer the buffer that is used */
uint32_t transfersize; /**< number of transfered data */
uint32_t handle; /**< HID handle */
HIDSlotData slotdata; /**< Information about the deviceslot and hidmask */
uint32_t pads_per_device; /**< Number of maximum pads of this device */
uint8_t pad_slot; /**< number of the pad that will be used */
uint8_t rumblestatus[HID_MAX_PADS_COUNT]; /**< Current status of the device rumble */
uint8_t forceRumbleInTicks[HID_MAX_PADS_COUNT];
} my_cb_user;
@ -240,12 +240,12 @@ typedef struct _my_cb_user {
* @brief Stores data for the mouse
*/
typedef struct _HID_Mouse_Data {
uint8_t left_click; /**< Is 1 when the left mouse button is pressed */
uint8_t right_click; /**< Is 1 when the right mouse button is pressed */
int16_t X; /**< X position of the cursor */
int16_t Y; /**< Y position of the cursor */
int16_t deltaX; /**< difference of the X value since the last call */
int16_t deltaY; /**< difference of the Y value since the last call */
uint8_t left_click; /**< Is 1 when the left mouse button is pressed */
uint8_t right_click; /**< Is 1 when the right mouse button is pressed */
int16_t X; /**< X position of the cursor */
int16_t Y; /**< Y position of the cursor */
int16_t deltaX; /**< difference of the X value since the last call */
int16_t deltaY; /**< difference of the Y value since the last call */
uint8_t valuedChanged; /**< Is 1 when the value has changed */
} HID_Mouse_Data;
@ -253,30 +253,30 @@ typedef struct _HID_Mouse_Data {
* @brief The enumeration of device types
*/
enum DEVICE_TYPE {
DEVICE_TYPE_CONTROLLER = 0, /**< Normal Controller */
DEVICE_TYPE_MOUSE = 1, /**< Mouse */
DEVICE_TYPE_CONTROLLER = 0, /**< Normal Controller */
DEVICE_TYPE_MOUSE = 1, /**< Mouse */
};
/**
* @brief Stores all data of the HID Device for accessing
*/
typedef struct _HID_Data {
uint32_t handle; /**< The HID-handle this device is using */
uint8_t rumbleActive; /**< 1 when rumble is active */
uint32_t last_buttons; /**< The last pressed buttons, based on VPAD_BUTTON_XXX data */
uint32_t handle; /**< The HID-handle this device is using */
uint8_t rumbleActive; /**< 1 when rumble is active */
uint32_t last_buttons; /**< The last pressed buttons, based on VPAD_BUTTON_XXX data */
union {
struct {
uint8_t cur_hid_data[HID_MAX_DATA_LENGTH_PER_PAD]; /**< Array where the current 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 uint8_t array where the raw data of the controller is placed. */
uint8_t cur_hid_data[HID_MAX_DATA_LENGTH_PER_PAD]; /**< Array where the current 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 uint8_t array where the raw data of the controller is placed. */
struct {
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 */
} mouse; /**< Used when the device in a mouse. Using a new struct to store the data. */
} data_union; /**< The data union where the current and last data is stored.*/
DEVICE_TYPE type; /**< The device type*/
HIDSlotData slotdata; /**< Information about the deviceslot and his mask*/
my_cb_user * user_data; /**< Pointer to the user data the read callback is using*/
} mouse; /**< Used when the device in a mouse. Using a new struct to store the data. */
} data_union; /**< The data union where the current and last data is stored.*/
DEVICE_TYPE type; /**< The device type*/
HIDSlotData slotdata; /**< Information about the deviceslot and his mask*/
my_cb_user *user_data; /**< Pointer to the user data the read callback is using*/
} HID_Data;
@ -300,29 +300,29 @@ typedef struct _DeviceVIDPIDInfo {
* @brief Infos of the device
*/
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 */
uint8_t pad_count; /**< Number of maximum pads this device can have*/
uint8_t pad_count; /**< Number of maximum pads this device can have*/
} DeviceInfo;
/**
* @brief The enumeration of Controller-Mapping types
*/
enum ControllerMapping_Type_Defines {
CM_Type_Controller = 0, /**< Device with single input */
CM_Type_Controller = 0, /**< Device with single input */
CM_Type_RealController = 1, /**< Real Pro Controller */
CM_Type_Mouse = 2, /**< Mouse */
CM_Type_Keyboard = 3, /**< Keyboard */
CM_Type_Mouse = 2, /**< Mouse */
CM_Type_Keyboard = 3, /**< Keyboard */
};
/**
* @brief Infos of a mapped controller
*/
typedef struct _ControllerMappingPADInfo {
uint8_t active; /**< Set to one if mapped */
uint8_t active; /**< Set to one if mapped */
ControllerMapping_Type_Defines type; /**< Type of the controller mapping */
DeviceVIDPIDInfo vidpid; /**< The VID/PID of the device */
uint8_t pad; /**< Stores which pad it mapped */
DeviceVIDPIDInfo vidpid; /**< The VID/PID of the device */
uint8_t pad; /**< Stores which pad it mapped */
} ControllerMappingPADInfo;
/**
@ -338,7 +338,7 @@ typedef struct _ControllerMappingPAD {
* @brief Stores informations about all mapped controller
*/
typedef struct _ControllerMapping {
ControllerMappingPAD gamepad; /**< Information about the gamepad mapping */
ControllerMappingPAD gamepad; /**< Information about the gamepad mapping */
ControllerMappingPAD proController[4]; /**< Information about the Pro Controller mapping */
} ControllerMapping;
@ -372,160 +372,160 @@ enum UController_Type {
};
#define CONTROLLER_PATCHER_PATH "sd:/wiiu/controller"
#define CONTROLLER_PATCHER_PATH "sd:/wiiu/controller"
#define UController_Type_Gamepad_Name gettext("GamePad")
#define UController_Type_Pro1_Name gettext("Pro Controller 1")
#define UController_Type_Pro2_Name gettext("Pro Controller 2")
#define UController_Type_Pro3_Name gettext("Pro Controller 3")
#define UController_Type_Pro4_Name gettext("Pro Controller 4")
#define UController_Type_Gamepad_Name gettext("GamePad")
#define UController_Type_Pro1_Name gettext("Pro Controller 1")
#define UController_Type_Pro2_Name gettext("Pro Controller 2")
#define UController_Type_Pro3_Name gettext("Pro Controller 3")
#define UController_Type_Pro4_Name gettext("Pro Controller 4")
/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* VID/PID values
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
#define HID_GC_VID 0x057e
#define HID_GC_PID 0x0337
#define HID_GC_VID 0x057e
#define HID_GC_PID 0x0337
#define HID_KEYBOARD_VID 0xAFFE
#define HID_KEYBOARD_PID 0XAAAC
#define HID_KEYBOARD_VID 0xAFFE
#define HID_KEYBOARD_PID 0XAAAC
#define HID_MOUSE_VID 0xAFFE
#define HID_MOUSE_PID 0XAAAB
#define HID_MOUSE_VID 0xAFFE
#define HID_MOUSE_PID 0XAAAB
#define HID_DS3_VID 0x054c
#define HID_DS3_PID 0x0268
#define HID_DS3_VID 0x054c
#define HID_DS3_PID 0x0268
#define HID_DS4_VID 0x054c
#define HID_DS4_PID 0x05c4
#define HID_DS4_VID 0x054c
#define HID_DS4_PID 0x05c4
#define HID_NEW_DS4_VID 0x054c
#define HID_NEW_DS4_PID 0x09CC
#define HID_NEW_DS4_VID 0x054c
#define HID_NEW_DS4_PID 0x09CC
#define HID_XINPUT_VID 0x7331
#define HID_XINPUT_PID 0x1337
#define HID_XINPUT_VID 0x7331
#define HID_XINPUT_PID 0x1337
#define HID_SWITCH_PRO_VID 0x057e
#define HID_SWITCH_PRO_PID 0x2009
#define HID_SWITCH_PRO_VID 0x057e
#define HID_SWITCH_PRO_PID 0x2009
/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* GC Adapter
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
#define HID_GC_BUTTON_A_VALUE 0x01
#define HID_GC_BUTTON_B_VALUE 0x02
#define HID_GC_BUTTON_X_VALUE 0x04
#define HID_GC_BUTTON_Y_VALUE 0x08
#define HID_GC_BUTTON_LEFT_VALUE 0x10
#define HID_GC_BUTTON_RIGHT_VALUE 0x20
#define HID_GC_BUTTON_DOWN_VALUE 0x40
#define HID_GC_BUTTON_UP_VALUE 0x80
#define HID_GC_BUTTON_A_VALUE 0x01
#define HID_GC_BUTTON_B_VALUE 0x02
#define HID_GC_BUTTON_X_VALUE 0x04
#define HID_GC_BUTTON_Y_VALUE 0x08
#define HID_GC_BUTTON_LEFT_VALUE 0x10
#define HID_GC_BUTTON_RIGHT_VALUE 0x20
#define HID_GC_BUTTON_DOWN_VALUE 0x40
#define HID_GC_BUTTON_UP_VALUE 0x80
#define HID_GC_BUTTON_START_VALUE 0x01
#define HID_GC_BUTTON_L_VALUE 0x80
#define HID_GC_BUTTON_R_VALUE 0x80
#define HID_GC_BUTTON_Z_VALUE 0x02
#define HID_GC_BUTTON_START_VALUE 0x01
#define HID_GC_BUTTON_L_VALUE 0x80
#define HID_GC_BUTTON_R_VALUE 0x80
#define HID_GC_BUTTON_Z_VALUE 0x02
#define HID_GC_PAD_COUNT 4
#define HID_GC_PAD_COUNT 4
/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* DS3
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
#define PS3_F4_REPORT_LEN 4
#define PS3_F5_REPORT_LEN 8
#define PS3_01_REPORT_LEN 48
#define HID_REPORT_FEATURE 3
#define HID_REPORT_OUTPUT 2
#define PS3_F4_REPORT_ID 0xF4
#define PS3_01_REPORT_ID 0x01
#define PS3_F5_REPORT_ID 0xF5
#define PS3_F4_REPORT_LEN 4
#define PS3_F5_REPORT_LEN 8
#define PS3_01_REPORT_LEN 48
#define HID_REPORT_FEATURE 3
#define HID_REPORT_OUTPUT 2
#define PS3_F4_REPORT_ID 0xF4
#define PS3_01_REPORT_ID 0x01
#define PS3_F5_REPORT_ID 0xF5
#define HID_DS3_BUTTON_CROSS_VALUE 0x40 // 3
#define HID_DS3_BUTTON_CIRCLE_VALUE 0x20 // 3
#define HID_DS3_BUTTON_SQUARE_VALUE 0x80 // 3
#define HID_DS3_BUTTON_TRIANGLE_VALUE 0x10 // 3
#define HID_DS3_BUTTON_L1_VALUE 0x04 // 3
#define HID_DS3_BUTTON_L2_VALUE 0x01 // 3
#define HID_DS3_BUTTON_R1_VALUE 0x08 // 3
#define HID_DS3_BUTTON_R2_VALUE 0x02 // 3
#define HID_DS3_BUTTON_CROSS_VALUE 0x40 // 3
#define HID_DS3_BUTTON_CIRCLE_VALUE 0x20 // 3
#define HID_DS3_BUTTON_SQUARE_VALUE 0x80 // 3
#define HID_DS3_BUTTON_TRIANGLE_VALUE 0x10 // 3
#define HID_DS3_BUTTON_L1_VALUE 0x04 // 3
#define HID_DS3_BUTTON_L2_VALUE 0x01 // 3
#define HID_DS3_BUTTON_R1_VALUE 0x08 // 3
#define HID_DS3_BUTTON_R2_VALUE 0x02 // 3
#define HID_DS3_BUTTON_L3_VALUE 0x02 // 2
#define HID_DS3_BUTTON_R3_VALUE 0x04 // 2
#define HID_DS3_BUTTON_SELECT_VALUE 0x01 // 2
#define HID_DS3_BUTTON_START_VALUE 0x08 // 2
#define HID_DS3_BUTTON_LEFT_VALUE 0x80 // 2
#define HID_DS3_BUTTON_RIGHT_VALUE 0x20 // 2
#define HID_DS3_BUTTON_UP_VALUE 0x10 // 2
#define HID_DS3_BUTTON_DOWN_VALUE 0x40 // 2
#define HID_DS3_BUTTON_GUIDE_VALUE 0x01 // 4
#define HID_DS3_BUTTON_L3_VALUE 0x02 // 2
#define HID_DS3_BUTTON_R3_VALUE 0x04 // 2
#define HID_DS3_BUTTON_SELECT_VALUE 0x01 // 2
#define HID_DS3_BUTTON_START_VALUE 0x08 // 2
#define HID_DS3_BUTTON_LEFT_VALUE 0x80 // 2
#define HID_DS3_BUTTON_RIGHT_VALUE 0x20 // 2
#define HID_DS3_BUTTON_UP_VALUE 0x10 // 2
#define HID_DS3_BUTTON_DOWN_VALUE 0x40 // 2
#define HID_DS3_BUTTON_GUIDE_VALUE 0x01 // 4
#define HID_DS3_PAD_COUNT 1
#define HID_DS3_PAD_COUNT 1
/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* DS4
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
#define HID_DS4_BUTTON_CROSS_VALUE 0x20 // 5
#define HID_DS4_BUTTON_SQUARE_VALUE 0x10 // 5
#define HID_DS4_BUTTON_CIRCLE_VALUE 0x40 // 5
#define HID_DS4_BUTTON_TRIANGLE_VALUE 0x80 // 5
#define HID_DS4_BUTTON_L1_VALUE 0x01 // 6
#define HID_DS4_BUTTON_L2_VALUE 0x04 // 6
#define HID_DS4_BUTTON_L3_VALUE 0x40 // 6
#define HID_DS4_BUTTON_R1_VALUE 0x02 // 6
#define HID_DS4_BUTTON_R2_VALUE 0x08 // 6
#define HID_DS4_BUTTON_R3_VALUE 0x80 // 6
#define HID_DS4_BUTTON_SHARE_VALUE 0x10 // 6
#define HID_DS4_BUTTON_OPTIONS_VALUE 0x20 // 6
#define HID_DS4_BUTTON_CROSS_VALUE 0x20 // 5
#define HID_DS4_BUTTON_SQUARE_VALUE 0x10 // 5
#define HID_DS4_BUTTON_CIRCLE_VALUE 0x40 // 5
#define HID_DS4_BUTTON_TRIANGLE_VALUE 0x80 // 5
#define HID_DS4_BUTTON_L1_VALUE 0x01 // 6
#define HID_DS4_BUTTON_L2_VALUE 0x04 // 6
#define HID_DS4_BUTTON_L3_VALUE 0x40 // 6
#define HID_DS4_BUTTON_R1_VALUE 0x02 // 6
#define HID_DS4_BUTTON_R2_VALUE 0x08 // 6
#define HID_DS4_BUTTON_R3_VALUE 0x80 // 6
#define HID_DS4_BUTTON_SHARE_VALUE 0x10 // 6
#define HID_DS4_BUTTON_OPTIONS_VALUE 0x20 // 6
#define HID_DS4_BUTTON_DPAD_MASK_VALUE 0x0F
#define HID_DS4_BUTTON_DPAD_MASK_VALUE 0x0F
#define HID_DS4_BUTTON_DPAD_N_VALUE 0x00 // 5
#define HID_DS4_BUTTON_DPAD_NE_VALUE 0x01 // 5
#define HID_DS4_BUTTON_DPAD_E_VALUE 0x02 // 5
#define HID_DS4_BUTTON_DPAD_SE_VALUE 0x03 // 5
#define HID_DS4_BUTTON_DPAD_S_VALUE 0x04 // 5
#define HID_DS4_BUTTON_DPAD_SW_VALUE 0x05 // 5
#define HID_DS4_BUTTON_DPAD_W_VALUE 0x06 // 5
#define HID_DS4_BUTTON_DPAD_NW_VALUE 0x07 // 5
#define HID_DS4_BUTTON_DPAD_NEUTRAL_VALUE 0x08 // 5
#define HID_DS4_BUTTON_DPAD_N_VALUE 0x00 // 5
#define HID_DS4_BUTTON_DPAD_NE_VALUE 0x01 // 5
#define HID_DS4_BUTTON_DPAD_E_VALUE 0x02 // 5
#define HID_DS4_BUTTON_DPAD_SE_VALUE 0x03 // 5
#define HID_DS4_BUTTON_DPAD_S_VALUE 0x04 // 5
#define HID_DS4_BUTTON_DPAD_SW_VALUE 0x05 // 5
#define HID_DS4_BUTTON_DPAD_W_VALUE 0x06 // 5
#define HID_DS4_BUTTON_DPAD_NW_VALUE 0x07 // 5
#define HID_DS4_BUTTON_DPAD_NEUTRAL_VALUE 0x08 // 5
#define HID_DS4_BUTTON_GUIDE_VALUE 0x01 // 7
#define HID_DS4_BUTTON_T_PAD_CLICK_VALUE 0x02 // 7
#define HID_DS4_BUTTON_GUIDE_VALUE 0x01 // 7
#define HID_DS4_BUTTON_T_PAD_CLICK_VALUE 0x02 // 7
#define HID_DS4_PAD_COUNT 1
#define HID_DS4_PAD_COUNT 1
/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* XInput
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
#define HID_XINPUT_BUTTON_A_VALUE 0x01 // 7
#define HID_XINPUT_BUTTON_B_VALUE 0x02 // 7
#define HID_XINPUT_BUTTON_X_VALUE 0x04 // 7
#define HID_XINPUT_BUTTON_Y_VALUE 0x08 // 7
#define HID_XINPUT_BUTTON_A_VALUE 0x01 // 7
#define HID_XINPUT_BUTTON_B_VALUE 0x02 // 7
#define HID_XINPUT_BUTTON_X_VALUE 0x04 // 7
#define HID_XINPUT_BUTTON_Y_VALUE 0x08 // 7
#define HID_XINPUT_BUTTON_START_VALUE 0x02 // 6
#define HID_XINPUT_BUTTON_BACK_VALUE 0x01 // 6
#define HID_XINPUT_BUTTON_GUIDE_VALUE 0x80 // 6
#define HID_XINPUT_BUTTON_START_VALUE 0x02 // 6
#define HID_XINPUT_BUTTON_BACK_VALUE 0x01 // 6
#define HID_XINPUT_BUTTON_GUIDE_VALUE 0x80 // 6
#define HID_XINPUT_BUTTON_LB_VALUE 0x04 // 6
#define HID_XINPUT_BUTTON_RB_VALUE 0x08 // 6
#define HID_XINPUT_BUTTON_LB_VALUE 0x04 // 6
#define HID_XINPUT_BUTTON_RB_VALUE 0x08 // 6
#define HID_XINPUT_BUTTON_L3_VALUE 0x10 // 6
#define HID_XINPUT_BUTTON_R3_VALUE 0x20 // 6
#define HID_XINPUT_BUTTON_L3_VALUE 0x10 // 6
#define HID_XINPUT_BUTTON_R3_VALUE 0x20 // 6
#define HID_XINPUT_BUTTON_LT_VALUE 0x80 // 4
#define HID_XINPUT_BUTTON_RT_VALUE 0x80 // 5
#define HID_XINPUT_BUTTON_LT_VALUE 0x80 // 4
#define HID_XINPUT_BUTTON_RT_VALUE 0x80 // 5
#define HID_XINPUT_BUTTON_DPAD_MASK_VALUE 0xF0
#define HID_XINPUT_BUTTON_LEFT_VALUE 0x10 // 7
#define HID_XINPUT_BUTTON_RIGHT_VALUE 0x40 // 7
#define HID_XINPUT_BUTTON_DOWN_VALUE 0x80 // 7
#define HID_XINPUT_BUTTON_UP_VALUE 0x20 // 7
#define HID_XINPUT_BUTTON_DPAD_MASK_VALUE 0xF0
#define HID_XINPUT_BUTTON_LEFT_VALUE 0x10 // 7
#define HID_XINPUT_BUTTON_RIGHT_VALUE 0x40 // 7
#define HID_XINPUT_BUTTON_DOWN_VALUE 0x80 // 7
#define HID_XINPUT_BUTTON_UP_VALUE 0x20 // 7
#define HID_XINPUT_PAD_COUNT 1
#define HID_XINPUT_PAD_COUNT 1
/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Switch Pro Controller
@ -587,110 +587,110 @@ enum UController_Type {
* Keyboard (Full list is on: http://www.freebsddiary.org/APC/usb_hid_usages.php)
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
#define HID_KEYBOARD_BUTTON_SHIFT 0x02
#define HID_KEYBOARD_BUTTON_SHIFT 0x02
#define HID_KEYBOARD_BUTTON_A 0x04
#define HID_KEYBOARD_BUTTON_B 0x05
#define HID_KEYBOARD_BUTTON_C 0x06
#define HID_KEYBOARD_BUTTON_D 0x07
#define HID_KEYBOARD_BUTTON_E 0x08
#define HID_KEYBOARD_BUTTON_F 0x09
#define HID_KEYBOARD_BUTTON_G 0x0A
#define HID_KEYBOARD_BUTTON_H 0x0B
#define HID_KEYBOARD_BUTTON_I 0x0C
#define HID_KEYBOARD_BUTTON_J 0x0D
#define HID_KEYBOARD_BUTTON_K 0x0E
#define HID_KEYBOARD_BUTTON_L 0x0F
#define HID_KEYBOARD_BUTTON_M 0x10
#define HID_KEYBOARD_BUTTON_N 0x11
#define HID_KEYBOARD_BUTTON_O 0x12
#define HID_KEYBOARD_BUTTON_P 0x13
#define HID_KEYBOARD_BUTTON_Q 0x14
#define HID_KEYBOARD_BUTTON_R 0x15
#define HID_KEYBOARD_BUTTON_S 0x16
#define HID_KEYBOARD_BUTTON_T 0x17
#define HID_KEYBOARD_BUTTON_U 0x18
#define HID_KEYBOARD_BUTTON_V 0x19
#define HID_KEYBOARD_BUTTON_W 0x1A
#define HID_KEYBOARD_BUTTON_X 0x1B
#define HID_KEYBOARD_BUTTON_Y 0x1C
#define HID_KEYBOARD_BUTTON_Z 0x1D
#define HID_KEYBOARD_BUTTON_F1 0x3A
#define HID_KEYBOARD_BUTTON_F2 0x3B
#define HID_KEYBOARD_BUTTON_F3 0x3C
#define HID_KEYBOARD_BUTTON_F4 0x3D
#define HID_KEYBOARD_BUTTON_F5 0x3E
#define HID_KEYBOARD_BUTTON_F6 0x3F
#define HID_KEYBOARD_BUTTON_F7 0x40
#define HID_KEYBOARD_BUTTON_F8 0x41
#define HID_KEYBOARD_BUTTON_F9 0x42
#define HID_KEYBOARD_BUTTON_F10 0x43
#define HID_KEYBOARD_BUTTON_F11 0x44
#define HID_KEYBOARD_BUTTON_F12 0x45
#define HID_KEYBOARD_BUTTON_1 0x1E
#define HID_KEYBOARD_BUTTON_2 0x1F
#define HID_KEYBOARD_BUTTON_3 0x20
#define HID_KEYBOARD_BUTTON_4 0x21
#define HID_KEYBOARD_BUTTON_5 0x22
#define HID_KEYBOARD_BUTTON_6 0x23
#define HID_KEYBOARD_BUTTON_7 0x24
#define HID_KEYBOARD_BUTTON_8 0x25
#define HID_KEYBOARD_BUTTON_9 0x26
#define HID_KEYBOARD_BUTTON_0 0x27
#define HID_KEYBOARD_BUTTON_A 0x04
#define HID_KEYBOARD_BUTTON_B 0x05
#define HID_KEYBOARD_BUTTON_C 0x06
#define HID_KEYBOARD_BUTTON_D 0x07
#define HID_KEYBOARD_BUTTON_E 0x08
#define HID_KEYBOARD_BUTTON_F 0x09
#define HID_KEYBOARD_BUTTON_G 0x0A
#define HID_KEYBOARD_BUTTON_H 0x0B
#define HID_KEYBOARD_BUTTON_I 0x0C
#define HID_KEYBOARD_BUTTON_J 0x0D
#define HID_KEYBOARD_BUTTON_K 0x0E
#define HID_KEYBOARD_BUTTON_L 0x0F
#define HID_KEYBOARD_BUTTON_M 0x10
#define HID_KEYBOARD_BUTTON_N 0x11
#define HID_KEYBOARD_BUTTON_O 0x12
#define HID_KEYBOARD_BUTTON_P 0x13
#define HID_KEYBOARD_BUTTON_Q 0x14
#define HID_KEYBOARD_BUTTON_R 0x15
#define HID_KEYBOARD_BUTTON_S 0x16
#define HID_KEYBOARD_BUTTON_T 0x17
#define HID_KEYBOARD_BUTTON_U 0x18
#define HID_KEYBOARD_BUTTON_V 0x19
#define HID_KEYBOARD_BUTTON_W 0x1A
#define HID_KEYBOARD_BUTTON_X 0x1B
#define HID_KEYBOARD_BUTTON_Y 0x1C
#define HID_KEYBOARD_BUTTON_Z 0x1D
#define HID_KEYBOARD_BUTTON_F1 0x3A
#define HID_KEYBOARD_BUTTON_F2 0x3B
#define HID_KEYBOARD_BUTTON_F3 0x3C
#define HID_KEYBOARD_BUTTON_F4 0x3D
#define HID_KEYBOARD_BUTTON_F5 0x3E
#define HID_KEYBOARD_BUTTON_F6 0x3F
#define HID_KEYBOARD_BUTTON_F7 0x40
#define HID_KEYBOARD_BUTTON_F8 0x41
#define HID_KEYBOARD_BUTTON_F9 0x42
#define HID_KEYBOARD_BUTTON_F10 0x43
#define HID_KEYBOARD_BUTTON_F11 0x44
#define HID_KEYBOARD_BUTTON_F12 0x45
#define HID_KEYBOARD_BUTTON_1 0x1E
#define HID_KEYBOARD_BUTTON_2 0x1F
#define HID_KEYBOARD_BUTTON_3 0x20
#define HID_KEYBOARD_BUTTON_4 0x21
#define HID_KEYBOARD_BUTTON_5 0x22
#define HID_KEYBOARD_BUTTON_6 0x23
#define HID_KEYBOARD_BUTTON_7 0x24
#define HID_KEYBOARD_BUTTON_8 0x25
#define HID_KEYBOARD_BUTTON_9 0x26
#define HID_KEYBOARD_BUTTON_0 0x27
#define HID_KEYBOARD_BUTTON_RETURN 0x28
#define HID_KEYBOARD_BUTTON_ESCAPE 0x29
#define HID_KEYBOARD_BUTTON_DELETE 0x2A
#define HID_KEYBOARD_BUTTON_TAB 0x2B
#define HID_KEYBOARD_BUTTON_SPACEBAR 0x2C
#define HID_KEYBOARD_BUTTON_CAPSLOCK 0x39
#define HID_KEYBOARD_BUTTON_PRINTSCREEN 0x46
#define HID_KEYBOARD_BUTTON_SCROLLLOCK 0x47
#define HID_KEYBOARD_BUTTON_PAUSE 0x48
#define HID_KEYBOARD_BUTTON_INSERT 0x49
#define HID_KEYBOARD_BUTTON_HOME 0x4A
#define HID_KEYBOARD_BUTTON_PAGEUP 0x4B
#define HID_KEYBOARD_BUTTON_PAGEDOWN 0x4E
#define HID_KEYBOARD_BUTTON_DELETEFORWARD 0x4C
#define HID_KEYBOARD_BUTTON_END 0x4D
#define HID_KEYBOARD_BUTTON_LEFT_CONTROL 0xE0
#define HID_KEYBOARD_BUTTON_LEFT_ALT 0xE2
#define HID_KEYBOARD_BUTTON_RIGHT_CONTROL 0xE4
#define HID_KEYBOARD_BUTTON_RIGHT_SHIFT 0xE5
#define HID_KEYBOARD_BUTTON_RIGHT_ALT 0xE6
#define HID_KEYBOARD_BUTTON_RETURN 0x28
#define HID_KEYBOARD_BUTTON_ESCAPE 0x29
#define HID_KEYBOARD_BUTTON_DELETE 0x2A
#define HID_KEYBOARD_BUTTON_TAB 0x2B
#define HID_KEYBOARD_BUTTON_SPACEBAR 0x2C
#define HID_KEYBOARD_BUTTON_CAPSLOCK 0x39
#define HID_KEYBOARD_BUTTON_PRINTSCREEN 0x46
#define HID_KEYBOARD_BUTTON_SCROLLLOCK 0x47
#define HID_KEYBOARD_BUTTON_PAUSE 0x48
#define HID_KEYBOARD_BUTTON_INSERT 0x49
#define HID_KEYBOARD_BUTTON_HOME 0x4A
#define HID_KEYBOARD_BUTTON_PAGEUP 0x4B
#define HID_KEYBOARD_BUTTON_PAGEDOWN 0x4E
#define HID_KEYBOARD_BUTTON_DELETEFORWARD 0x4C
#define HID_KEYBOARD_BUTTON_END 0x4D
#define HID_KEYBOARD_BUTTON_LEFT_CONTROL 0xE0
#define HID_KEYBOARD_BUTTON_LEFT_ALT 0xE2
#define HID_KEYBOARD_BUTTON_RIGHT_CONTROL 0xE4
#define HID_KEYBOARD_BUTTON_RIGHT_SHIFT 0xE5
#define HID_KEYBOARD_BUTTON_RIGHT_ALT 0xE6
#define HID_KEYBOARD_BUTTON_LEFT 0x50
#define HID_KEYBOARD_BUTTON_RIGHT 0x4f
#define HID_KEYBOARD_BUTTON_DOWN 0x51
#define HID_KEYBOARD_BUTTON_UP 0x52
#define HID_KEYBOARD_BUTTON_LEFT 0x50
#define HID_KEYBOARD_BUTTON_RIGHT 0x4f
#define HID_KEYBOARD_BUTTON_DOWN 0x51
#define HID_KEYBOARD_BUTTON_UP 0x52
#define HID_KEYBOARD_KEYPAD_BUTTON_1 0x59
#define HID_KEYBOARD_KEYPAD_BUTTON_2 0x5A
#define HID_KEYBOARD_KEYPAD_BUTTON_3 0x5B
#define HID_KEYBOARD_KEYPAD_BUTTON_4 0x5C
#define HID_KEYBOARD_KEYPAD_BUTTON_5 0x5D
#define HID_KEYBOARD_KEYPAD_BUTTON_6 0x5E
#define HID_KEYBOARD_KEYPAD_BUTTON_7 0x5F
#define HID_KEYBOARD_KEYPAD_BUTTON_8 0x60
#define HID_KEYBOARD_KEYPAD_BUTTON_9 0x61
#define HID_KEYBOARD_KEYPAD_BUTTON_0 0x62
#define HID_KEYBOARD_KEYPAD_BUTTON_NUMLOCK 0x53
#define HID_KEYBOARD_KEYPAD_BUTTON_MINUS 0x56
#define HID_KEYBOARD_KEYPAD_BUTTON_PLUS 0x57
#define HID_KEYBOARD_KEYPAD_BUTTON_1 0x59
#define HID_KEYBOARD_KEYPAD_BUTTON_2 0x5A
#define HID_KEYBOARD_KEYPAD_BUTTON_3 0x5B
#define HID_KEYBOARD_KEYPAD_BUTTON_4 0x5C
#define HID_KEYBOARD_KEYPAD_BUTTON_5 0x5D
#define HID_KEYBOARD_KEYPAD_BUTTON_6 0x5E
#define HID_KEYBOARD_KEYPAD_BUTTON_7 0x5F
#define HID_KEYBOARD_KEYPAD_BUTTON_8 0x60
#define HID_KEYBOARD_KEYPAD_BUTTON_9 0x61
#define HID_KEYBOARD_KEYPAD_BUTTON_0 0x62
#define HID_KEYBOARD_KEYPAD_BUTTON_NUMLOCK 0x53
#define HID_KEYBOARD_KEYPAD_BUTTON_MINUS 0x56
#define HID_KEYBOARD_KEYPAD_BUTTON_PLUS 0x57
#define HID_KEYBOARD_PAD_COUNT 1
#define HID_KEYBOARD_DATA_LENGTH 8
#define HID_KEYBOARD_PAD_COUNT 1
#define HID_KEYBOARD_DATA_LENGTH 8
/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Mouse
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
#define HID_MOUSE_BUTTON_LEFTCLICK 0x04
#define HID_MOUSE_BUTTON_RIGHTCLICK 0x05
#define HID_MOUSE_BUTTON_LEFTCLICK 0x04
#define HID_MOUSE_BUTTON_RIGHTCLICK 0x05
#define HID_MOUSE_PAD_COUNT 1
#define HID_MOUSE_PAD_COUNT 1
#define HID_MOUSE_MODE_AIM 0x01
#define HID_MOUSE_MODE_TOUCH 0x02
#define HID_MOUSE_MODE_AIM 0x01
#define HID_MOUSE_MODE_TOUCH 0x02
#endif /* _CONTROLLER_PATCHER_DEFS_H_ */

47
source/ConfigReader.cpp
View File

@ -17,13 +17,12 @@
#include "./ConfigReader.hpp"
#include <fs/FSUtils.h>
#include <fcntl.h>
#include <map>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <map>
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/types.h>
#include <unistd.h>
@ -32,20 +31,20 @@
#include <utils/logger.h>
int32_t ConfigReader::numberValidFiles = 0;
ConfigReader *ConfigReader::instance = NULL;
ConfigReader *ConfigReader::instance = NULL;
ConfigReader::ConfigReader() {
}
BOOL ConfigReader::ReadConfigs(std::string 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;
}
if(fileList.size() > 0) {
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("Found %d config files",fileList.size());
if (fileList.size() > 0) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Found %d config files", fileList.size());
}
processFileList(fileList);
}
@ -54,7 +53,7 @@ BOOL ConfigReader::ReadConfigs(std::string path) {
ConfigReader::~ConfigReader() {
if(HID_DEBUG) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("~ConfigReader");
}
}
@ -63,26 +62,26 @@ std::vector<std::string> ConfigReader::ScanFolder(std::string path) {
std::vector<std::string> config_files;
struct dirent *dirent = NULL;
DIR *dirHandle = opendir(path.c_str());
DIR *dirHandle = opendir(path.c_str());
if (dirHandle == NULL) {
DEBUG_FUNCTION_LINE("Failed to open dir %s",path.c_str());
DEBUG_FUNCTION_LINE("Failed to open dir %s", path.c_str());
config_files.push_back("ERROR"); //TODO: Find a proper solution
return config_files;
}
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;
if(strcmp(filename,".") == 0 || strcmp(filename,"..") == 0) {
if (strcmp(filename, ".") == 0 || strcmp(filename, "..") == 0) {
continue;
}
std::string newPath = path + "/" + std::string(filename);
if(!isDir && StringTools::EndsWith(std::string(filename),".ini")) {
if (!isDir && StringTools::EndsWith(std::string(filename), ".ini")) {
config_files.push_back(newPath);
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("Found ini: %s ",newPath.c_str());
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Found ini: %s ", newPath.c_str());
}
}
}
@ -91,8 +90,8 @@ std::vector<std::string> ConfigReader::ScanFolder(std::string path) {
}
void ConfigReader::processFileList(std::vector<std::string> path) {
for(std::vector<std::string>::iterator it = path.begin(); it != path.end(); ++it) {
DEBUG_FUNCTION_LINE("Reading %s",it->c_str());
for (std::vector<std::string>::iterator it = path.begin(); it != path.end(); ++it) {
DEBUG_FUNCTION_LINE("Reading %s", it->c_str());
std::string result = loadFileToString(*it);
ConfigParser parser(result);
@ -102,12 +101,12 @@ void ConfigReader::processFileList(std::vector<std::string> path) {
std::string ConfigReader::loadFileToString(std::string path) {
std::string strBuffer = "";
uint8_t * buffer = NULL;
if(FSUtils::LoadFileToMem(path.c_str(),&buffer,NULL) > 0) {
strBuffer = std::string((char *)buffer);
strBuffer = StringTools::removeCharFromString(strBuffer,'\r');
strBuffer = StringTools::removeCharFromString(strBuffer,' ');
strBuffer = StringTools::removeCharFromString(strBuffer,'\t');
uint8_t *buffer = NULL;
if (FSUtils::LoadFileToMem(path.c_str(), &buffer, NULL) > 0) {
strBuffer = std::string((char *) buffer);
strBuffer = StringTools::removeCharFromString(strBuffer, '\r');
strBuffer = StringTools::removeCharFromString(strBuffer, ' ');
strBuffer = StringTools::removeCharFromString(strBuffer, '\t');
}
return strBuffer;
}

59
source/ConfigReader.hpp
View File

@ -22,46 +22,47 @@
#include "ControllerPatcherIncludes.hpp"
class ConfigReader{
class ConfigReader {
friend class ControllerPatcher;
friend class ConfigParser;
private:
static ConfigReader *getInstance() {
if(!instance){
instance = new ConfigReader();
}
return instance;
private:
static ConfigReader *getInstance() {
if (!instance) {
instance = new ConfigReader();
}
return instance;
}
static void destroyInstance() {
if(instance){
delete instance;
instance = NULL;
}
static void destroyInstance() {
if (instance) {
delete instance;
instance = NULL;
}
}
static int32_t getNumberOfLoadedFiles(){
return ConfigReader::numberValidFiles;
}
static int32_t getNumberOfLoadedFiles() {
return ConfigReader::numberValidFiles;
}
static void increaseNumberOfLoadedFiles(){
ConfigReader::numberValidFiles++;
}
BOOL ReadConfigs(std::string path);
static int32_t numberValidFiles;
static void increaseNumberOfLoadedFiles() {
ConfigReader::numberValidFiles++;
}
BOOL ReadConfigs(std::string path);
static int32_t numberValidFiles;
//!Constructor
ConfigReader();
//!Destructor
~ConfigReader();
//!Constructor
ConfigReader();
//!Destructor
~ConfigReader();
int32_t InitSDCard();
int32_t InitSDCard();
static ConfigReader *instance;
static ConfigReader *instance;
std::string loadFileToString(std::string path);
void processFileList(std::vector<std::string> path);
std::string loadFileToString(std::string path);
void processFileList(std::vector<std::string> path);
std::vector<std::string> ScanFolder(std::string path);
std::vector<std::string> ScanFolder(std::string path);
};
#endif

1209
source/ControllerPatcher.cpp
View File

File diff suppressed because it is too large Load Diff

10
source/ControllerPatcherIncludes.hpp
View File

@ -22,29 +22,29 @@
#include <wut_types.h>
#include <coreinit/systeminfo.h>
#include <padscore/kpad.h>
#include <padscore/wpad.h>
#include <vpad/input.h>
#include <coreinit/systeminfo.h>
#include <sys/socket.h>
#include <vpad/input.h>
#include "./ConfigReader.hpp"
#include <controller_patcher/ControllerPatcher.hpp>
#include <system/CThread.h>
#include "./utils/CPRetainVars.hpp"
#include "./utils/PadConst.hpp"
#include <system/CThread.h>
#include <utils/StringTools.h>
#include "./patcher/ControllerPatcherHID.hpp"
#include "./patcher/ControllerPatcherUtils.hpp"
#include "./config/ConfigValues.hpp"
#include "./config/ConfigParser.hpp"
#include "./config/ConfigValues.hpp"
#include "./network/CPTCPServer.hpp"
#include "./network/UDPServer.hpp"
#include "./network/UDPClient.hpp"
#include "./network/UDPServer.hpp"
#endif /* _CONTROLLER_PATCHER_INCLUDES_H_ */

249
source/config/ConfigParser.cpp
View File

@ -15,34 +15,34 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include "./ConfigParser.hpp"
#include <utils/StringTools.h>
#include <algorithm>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <utils/StringTools.h>
ConfigParser::ConfigParser(std::string configData) {
this->content = configData;
this->content = configData;
this->contentLines = StringTools::stringSplit(content, "");
if(contentLines.empty()) {
if (contentLines.empty()) {
return;
}
//remove the comments and make everything uppercase
for(uint32_t i = 0; i < contentLines.size(); i++) {
for (uint32_t i = 0; i < contentLines.size(); i++) {
std::vector<std::string> comments = StringTools::stringSplit(contentLines[i], "//");
if(!comments.empty()) {
if (!comments.empty()) {
contentLines[i] = comments[0];
}
//we want everything uppercase
std::transform(contentLines[i].begin(), contentLines[i].end(),contentLines[i].begin(), ::toupper);
std::transform(contentLines[i].begin(), contentLines[i].end(), contentLines[i].begin(), ::toupper);
}
//remove empty lines
std::vector<std::string> contentline2;
for(uint32_t i = 0; i < contentLines.size(); i++) {
if(strlen(contentLines[i].c_str()) > 0) {
for (uint32_t i = 0; i < contentLines.size(); i++) {
if (strlen(contentLines[i].c_str()) > 0) {
contentline2.push_back(contentLines[i]);
}
}
@ -51,7 +51,6 @@ ConfigParser::ConfigParser(std::string configData) {
}
ConfigParser::~ConfigParser() {
}
PARSE_TYPE ConfigParser::getType() {
@ -71,36 +70,36 @@ void ConfigParser::setSlot(uint16_t newSlot) {
}
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");
return false;
}
const char * line = contentLines[0].c_str();
int32_t len = strlen(line);
if(len <= 4) {
const char *line = contentLines[0].c_str();
int32_t len = strlen(line);
if (len <= 4) {
DEBUG_FUNCTION_LINE("Header is too short.");
return false;
}
std::string identify;
if(line[0] == '[' && line[len-1] == ']') {
identify = contentLines[0].substr(1,len-2);
if (line[0] == '[' && line[len - 1] == ']') {
identify = contentLines[0].substr(1, len - 2);
} else {
DEBUG_FUNCTION_LINE("Not a proper config file!");
return false;
}
if(identify.compare("GAMEPAD") == 0) {
if (identify.compare("GAMEPAD") == 0) {
DEBUG_FUNCTION_LINE("Its a gamepad config file!");
setSlot(gGamePadSlot);
setType(PARSE_GAMEPAD);
} else if(identify.compare("MOUSE") == 0) {
} else if (identify.compare("MOUSE") == 0) {
DEBUG_FUNCTION_LINE("Its a mouse config file!");
setSlot(gMouseSlot);
setType(PARSE_MOUSE);
this->vid = HID_MOUSE_VID;
this->pid = HID_MOUSE_PID;
} else if(identify.compare("KEYBOARD") == 0) {
} else if (identify.compare("KEYBOARD") == 0) {
DEBUG_FUNCTION_LINE("Its a keyboard config file!");
setSlot(gHID_SLOT_KEYBOARD);
setType(PARSE_KEYBOARD);
@ -112,7 +111,7 @@ BOOL ConfigParser::Init() {
setType(PARSE_CONTROLLER);
}
if(getSlot() == HID_INVALID_SLOT) {
if (getSlot() == HID_INVALID_SLOT) {
return false;
}
@ -122,53 +121,53 @@ BOOL ConfigParser::Init() {
}
void ConfigParser::parseSingleLine(std::string line) {
if(line.empty()) {
if (line.empty()) {
DEBUG_FUNCTION_LINE("Can't parse line. it's empty");
return;
}
std::vector<std::string> cur_values = StringTools::stringSplit(line,"=");
if(cur_values.size() != 2) {
if(HID_DEBUG || cur_values.size() > 2) {
DEBUG_FUNCTION_LINE("Not a valid key=pair line %s",line.c_str());
std::vector<std::string> cur_values = StringTools::stringSplit(line, "=");
if (cur_values.size() != 2) {
if (HID_DEBUG || cur_values.size() > 2) {
DEBUG_FUNCTION_LINE("Not a valid key=pair line %s", line.c_str());
}
return;
} else {
uint16_t hid_slot = getSlot();
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("leftpart = \"%s\" ",cur_values[0].c_str());
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("leftpart = \"%s\" ", cur_values[0].c_str());
}
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("rightpart = \"%s\" ",cur_values[1].c_str());
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("rightpart = \"%s\" ", cur_values[1].c_str());
}
int32_t keyslot = -1;
int32_t keyslot = -1;
if(HID_DEBUG) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Checking single value");
}
if(getType() == PARSE_GAMEPAD || getType() == PARSE_KEYBOARD) {
if (getType() == PARSE_GAMEPAD || getType() == PARSE_KEYBOARD) {
keyslot = ConfigValues::getKeySlotGamePad(cur_values[0]);
} else if(getType() == PARSE_MOUSE) {
} else if (getType() == PARSE_MOUSE) {
keyslot = ConfigValues::getKeySlotMouse(cur_values[0]);
} else {
keyslot = ConfigValues::getKeySlotDefaultSingleValue(cur_values[0]);
}
if(keyslot != -1) {
if(HID_DEBUG) {
if (keyslot != -1) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Its a single value");
}
long rightValue = -1;
BOOL valueSet = false;
if(cur_values[0].compare("DPAD_MODE") == 0) {
const uint8_t * values_ = NULL;
if((values_ = ConfigValues::getValuesStickPreset(cur_values[1])) != NULL) {
if(values_[STICK_CONF_MAGIC_VERSION] != STICK_CONF_MAGIC_VALUE)
if(HID_DEBUG) {
BOOL valueSet = false;
if (cur_values[0].compare("DPAD_MODE") == 0) {
const uint8_t *values_ = NULL;
if ((values_ = ConfigValues::getValuesStickPreset(cur_values[1])) != NULL) {
if (values_[STICK_CONF_MAGIC_VERSION] != STICK_CONF_MAGIC_VALUE)
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Settings preset DPAD MODE and Mask");
}
config_controller[hid_slot][CONTRPS_DPAD_MODE][0] = CONTROLLER_PATCHER_VALUE_SET;
config_controller[hid_slot][CONTRPS_DPAD_MODE][1] = values_[CONTRDPAD_MODE];
if(values_[CONTRDPAD_MASK] != 0x00) {
if (values_[CONTRDPAD_MASK] != 0x00) {
config_controller[hid_slot][CONTRPS_DPAD_MASK][0] = CONTROLLER_PATCHER_VALUE_SET;
config_controller[hid_slot][CONTRPS_DPAD_MASK][1] = values_[CONTRDPAD_MASK];
}
@ -176,83 +175,83 @@ void ConfigParser::parseSingleLine(std::string line) {
}
}
if(!valueSet) {
if(getType() == PARSE_KEYBOARD) {
if((rightValue = ConfigValues::getPresetValuesKeyboard(cur_values[1]))!= -1) {
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("Used pre-defined Keyboard! \"%s\" is %d",cur_values[1].c_str(),rightValue);
if (!valueSet) {
if (getType() == PARSE_KEYBOARD) {
if ((rightValue = ConfigValues::getPresetValuesKeyboard(cur_values[1])) != -1) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Used pre-defined Keyboard! \"%s\" is %d", cur_values[1].c_str(), rightValue);
}
} else {
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("I need to parse %s",cur_values[1].c_str());
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("I need to parse %s", cur_values[1].c_str());
}
char * ptr;
rightValue = strtol(cur_values[1].c_str(),&ptr,16);
char *ptr;
rightValue = strtol(cur_values[1].c_str(), &ptr, 16);
}
} else {
rightValue = ConfigValues::getPresetValue(cur_values[1]);
if(getType() == PARSE_MOUSE) { //No parsing for the mouse
if(rightValue == -1) {
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("Invalid mouse value, lets skip it %s",cur_values[1].c_str());
if (getType() == PARSE_MOUSE) { //No parsing for the mouse
if (rightValue == -1) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Invalid mouse value, lets skip it %s", cur_values[1].c_str());
}
return;
}
} else {
if(rightValue == -1) {
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("I need to parse %s",cur_values[1].c_str());
if (rightValue == -1) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("I need to parse %s", cur_values[1].c_str());
}
char * ptr;
rightValue = strtol(cur_values[1].c_str(),&ptr,16);
char *ptr;
rightValue = strtol(cur_values[1].c_str(), &ptr, 16);
}
}
}
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("Setting value to %d",rightValue);
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Setting value to %d", rightValue);
}
config_controller[hid_slot][keyslot][0] = CONTROLLER_PATCHER_VALUE_SET;
config_controller[hid_slot][keyslot][1] = rightValue;
}
} else {
if(HID_DEBUG) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Check pair value");
}
keyslot = ConfigValues::getKeySlotDefaultPairedValue(cur_values[0]);
if(keyslot != -1) {
if(HID_DEBUG) {
if (keyslot != -1) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Its a pair value");
}
if(!ConfigValues::getInstance()->setIfValueIsAControllerPreset(cur_values[1],getSlot(),keyslot)) {
if(HID_DEBUG) {
if (!ConfigValues::getInstance()->setIfValueIsAControllerPreset(cur_values[1], getSlot(), keyslot)) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("And its no preset");
}
std::vector<std::string> rightvalues = StringTools::stringSplit(cur_values[1],",");
std::vector<std::string> rightvalues = StringTools::stringSplit(cur_values[1], ",");
if(rightvalues.size() != 2) {
DEBUG_FUNCTION_LINE("%d instead of 2 key=values pairs in line",rightvalues.size());
if (rightvalues.size() != 2) {
DEBUG_FUNCTION_LINE("%d instead of 2 key=values pairs in line", rightvalues.size());
return;
}
char * ptr;
long firstValue = strtol(rightvalues[0].c_str(),&ptr,16);
long secondValue = strtol(rightvalues[1].c_str(),&ptr,16);
char *ptr;
long firstValue = strtol(rightvalues[0].c_str(), &ptr, 16);
long secondValue = strtol(rightvalues[1].c_str(), &ptr, 16);
config_controller[hid_slot][keyslot][0] = firstValue;
config_controller[hid_slot][keyslot][1] = secondValue;
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("Set %02X,%02X",firstValue,secondValue);
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Set %02X,%02X", firstValue, secondValue);
}
} else {
if(HID_DEBUG) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Found preset value!!");
}
}
} else {
DEBUG_FUNCTION_LINE("The setting \"%s\" is unknown!",cur_values[0].c_str());
DEBUG_FUNCTION_LINE("The setting \"%s\" is unknown!", cur_values[0].c_str());
}
}
}
@ -260,47 +259,47 @@ void ConfigParser::parseSingleLine(std::string line) {
BOOL ConfigParser::resetConfig() {
int32_t slot = getSlot();
if((slot == HID_INVALID_SLOT) || (slot >= gHIDMaxDevices)) return false;
for(int32_t j = (CONTRPS_PID+1); j< CONTRPS_MAX_VALUE; j++) {
if ((slot == HID_INVALID_SLOT) || (slot >= gHIDMaxDevices)) return false;
for (int32_t j = (CONTRPS_PID + 1); j < CONTRPS_MAX_VALUE; j++) {
config_controller[slot][j][0] = CONTROLLER_PATCHER_INVALIDVALUE;
config_controller[slot][j][1] = CONTROLLER_PATCHER_INVALIDVALUE;
}
return true;
}
int32_t ConfigParser::getSlotController(std::string identify) {
if(HID_DEBUG) {
int32_t ConfigParser::getSlotController(std::string identify) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Getting Controller Slot");
}
std::vector<std::string> values = StringTools::stringSplit(identify,",");
std::vector<std::string> values = StringTools::stringSplit(identify, ",");
if(values.size() != 2) {
DEBUG_FUNCTION_LINE("You need to provide a VID and PID. e.g. \"[vid=0x451,pid=0x152]\". (%s)",identify.c_str());
if (values.size() != 2) {
DEBUG_FUNCTION_LINE("You need to provide a VID and PID. e.g. \"[vid=0x451,pid=0x152]\". (%s)", identify.c_str());
return HID_INVALID_SLOT;
}
int32_t vid = getValueFromKeyValue(values[0],"VID","=");
if(vid < 0) {
int32_t vid = getValueFromKeyValue(values[0], "VID", "=");
if (vid < 0) {
return HID_INVALID_SLOT;
}
int32_t pid = getValueFromKeyValue(values[1],"PID","=");
if(pid < 0) {
int32_t pid = getValueFromKeyValue(values[1], "PID", "=");
if (pid < 0) {
return HID_INVALID_SLOT;
}
DEBUG_FUNCTION_LINE("VID: %04x PID: %04x",vid,pid);
DEBUG_FUNCTION_LINE("VID: %04x PID: %04x", vid, pid);
this->vid = vid;
this->pid = pid;
DeviceInfo deviceinfo;
memset(&deviceinfo,0,sizeof(deviceinfo));
memset(&deviceinfo, 0, sizeof(deviceinfo));
deviceinfo.vidpid.vid = vid;
deviceinfo.vidpid.pid = pid;
int32_t result = ControllerPatcherUtils::getDeviceInfoFromVidPid(&deviceinfo);
int32_t slot = deviceinfo.slotdata.deviceslot;
int32_t hid = 0;
if(result < 0) {
if(HID_DEBUG) {
int32_t result = ControllerPatcherUtils::getDeviceInfoFromVidPid(&deviceinfo);
int32_t slot = deviceinfo.slotdata.deviceslot;
int32_t hid = 0;
if (result < 0) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Its a new controller, lets save it");
}
@ -308,97 +307,97 @@ int32_t ConfigParser::getSlotController(std::string identify) {
ControllerPatcherUtils::getNextSlotData(&slotdata);
slot = slotdata.deviceslot;
hid = slotdata.hidmask;
hid = slotdata.hidmask;
if(slot >= gHIDMaxDevices) {
if (slot >= gHIDMaxDevices) {
DEBUG_FUNCTION_LINE("We don't a space for a new controller, please delete .inis");
return HID_INVALID_SLOT;
}
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("Got new slot! slot: %d hid %s .. Lets registrate it!",slot,StringTools::byte_to_binary(hid));
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Got new slot! slot: %d hid %s .. Lets registrate it!", slot, StringTools::byte_to_binary(hid));
}
config_controller[slot][CONTRPS_VID][0] = (vid & 0xFF00) >> 8;
config_controller[slot][CONTRPS_VID][1] = (vid & 0x00FF);
config_controller[slot][CONTRPS_PID][0] = (pid & 0xFF00) >> 8;
config_controller[slot][CONTRPS_PID][1] = (pid & 0x00FF);
if(HID_DEBUG) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Saved vid: %04X pid: %04X",
config_controller[slot][CONTRPS_VID][0] * 0x100 + config_controller[slot][CONTRPS_VID][1],
config_controller[slot][CONTRPS_PID][0] * 0x100 + config_controller[slot][CONTRPS_PID][1]);
}
config_controller_hidmask[slot] = hid;
if(HID_DEBUG) {
config_controller_hidmask[slot] = hid;
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Saved the hid");
}
} else {
if(slot < gHIDMaxDevices) {
if (slot < gHIDMaxDevices) {
hid = config_controller_hidmask[slot];
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE(">>>>>> found slot %d (hid:%s). Modifing existing data <<<<<<<<",slot,StringTools::byte_to_binary(hid));
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE(">>>>>> found slot %d (hid:%s). Modifing existing data <<<<<<<<", slot, StringTools::byte_to_binary(hid));
}
DEBUG_FUNCTION_LINE("We already have data of this controller, lets modify it");
} else {
DEBUG_FUNCTION_LINE("Something really odd happend to the slots. %d is bigger then max (%d)",slot,gHIDMaxDevices);
DEBUG_FUNCTION_LINE("Something really odd happend to the slots. %d is bigger then max (%d)", slot, gHIDMaxDevices);
return HID_INVALID_SLOT;
}
}
DEBUG_FUNCTION_LINE("using slot: %d hid %08X",slot,hid);
DEBUG_FUNCTION_LINE("using slot: %d hid %08X", slot, hid);
return slot;
}
BOOL ConfigParser::parseIni() {
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",getType(),gHIDMaxDevices);
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", getType(), gHIDMaxDevices);
return false;
}
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("Parsing content, type %d",getType());
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Parsing content, type %d", getType());
}
int32_t start = 1;
if(contentLines.size() <= 1) {
if (contentLines.size() <= 1) {
DEBUG_FUNCTION_LINE("File only contains a header.");
return false;
}
if(contentLines[1].compare("[IGNOREDEFAULT]") == 0) {
if (contentLines[1].compare("[IGNOREDEFAULT]") == 0) {
resetConfig();
DEBUG_FUNCTION_LINE("Ignoring existing settings of this device");
start++;
}
for(uint32_t i = start; i < contentLines.size(); i++) {
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("line %d: \"%s\" ",(i+1),contentLines[i].c_str());
for (uint32_t i = start; i < contentLines.size(); i++) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("line %d: \"%s\" ", (i + 1), contentLines[i].c_str());
}
parseSingleLine(contentLines[i]);
}
if(HID_DEBUG) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Parsing of the file is done.");
}
return true;
}
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);
if(string_value.size() != 2) {
if(HID_DEBUG || string_value.size() > 2) {
DEBUG_FUNCTION_LINE("Not a valid key=pair line %s",value_pair.c_str());
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);
if (string_value.size() != 2) {
if (HID_DEBUG || string_value.size() > 2) {
DEBUG_FUNCTION_LINE("Not a valid key=pair line %s", value_pair.c_str());
}
return -1;
}
if(string_value[0].compare(expectedKey) != 0) {
DEBUG_FUNCTION_LINE("Key part not %s, its %s",expectedKey.c_str(),string_value[0].c_str());
if (string_value[0].compare(expectedKey) != 0) {
DEBUG_FUNCTION_LINE("Key part not %s, its %s", expectedKey.c_str(), string_value[0].c_str());
return -1;
}
char * ptr;
int32_t value = strtol(string_value[1].c_str(),&ptr,16);
char *ptr;
int32_t value = strtol(string_value[1].c_str(), &ptr, 16);
return value;
}

9
source/config/ConfigParser.hpp
View File

@ -17,9 +17,9 @@
#ifndef _ConfigParser_H_
#define _ConfigParser_H_
#include <map>
#include <string>
#include <vector>
#include <map>
#include <stdio.h>
@ -27,16 +27,17 @@
#include <utils/logger.h>
enum PARSE_TYPE{
enum PARSE_TYPE {
PARSE_CONTROLLER,
PARSE_GAMEPAD,
PARSE_MOUSE,
PARSE_KEYBOARD
};
class ConfigParser{
class ConfigParser {
friend class ConfigReader;
friend class ControllerPatcher;
private:
//!Constructor
ConfigParser(std::string configData);
@ -59,7 +60,7 @@ private:
int32_t checkExistingController(int32_t vid, int32_t pid);
int32_t 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();

86
source/config/ConfigValues.cpp
View File

@ -28,13 +28,13 @@ ConfigValues::ConfigValues() {
}
ConfigValues::~ConfigValues() {
if(HID_DEBUG) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("\n");
}
}
const uint8_t * ConfigValues::getValuesForPreset(std::map<std::string,const uint8_t*> values,std::string possibleValue) {
std::map<std::string,const uint8_t*>::iterator it;
const uint8_t *ConfigValues::getValuesForPreset(std::map<std::string, const uint8_t *> values, std::string possibleValue) {
std::map<std::string, const uint8_t *>::iterator it;
it = values.find(possibleValue);
if (it != values.end()) {
return it->second;
@ -42,46 +42,46 @@ const uint8_t * ConfigValues::getValuesForPreset(std::map<std::string,const uint
return NULL;
}
BOOL ConfigValues::setIfValueIsAControllerPresetEx(std::string value,int32_t slot,int32_t keyslot) {
if(setIfValueIsPreset(presetGCValues,value,slot,keyslot)) return true;
if(setIfValueIsPreset(presetDS3Values,value,slot,keyslot)) return true;
if(setIfValueIsPreset(presetDS4Values,value,slot,keyslot)) return true;
if(setIfValueIsPreset(presetXInputValues,value,slot,keyslot)) return true;
if(setIfValueIsPreset(presetSwitchProValues,value,slot,keyslot)) return true;
BOOL ConfigValues::setIfValueIsAControllerPresetEx(std::string value, int32_t slot, int32_t keyslot) {
if (setIfValueIsPreset(presetGCValues, value, slot, keyslot)) return true;
if (setIfValueIsPreset(presetDS3Values, value, slot, keyslot)) return true;
if (setIfValueIsPreset(presetDS4Values, value, slot, keyslot)) return true;
if (setIfValueIsPreset(presetXInputValues, value, slot, keyslot)) return true;
if (setIfValueIsPreset(presetSwitchProValues, value, slot, keyslot)) return true;
return false;
}
//We need this function here so we can use preset sticks.
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) {
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) {
return false;
}
const uint8_t * values_ = NULL;
if( keyslot == CONTRPS_VPAD_BUTTON_L_STICK_X ||
keyslot == CONTRPS_VPAD_BUTTON_L_STICK_Y ||
keyslot == CONTRPS_VPAD_BUTTON_R_STICK_X ||
keyslot == CONTRPS_VPAD_BUTTON_R_STICK_Y) {
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("This may be a predefined stick %s",possibleValue.c_str());
const uint8_t *values_ = NULL;
if (keyslot == CONTRPS_VPAD_BUTTON_L_STICK_X ||
keyslot == CONTRPS_VPAD_BUTTON_L_STICK_Y ||
keyslot == CONTRPS_VPAD_BUTTON_R_STICK_X ||
keyslot == CONTRPS_VPAD_BUTTON_R_STICK_Y) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("This may be a predefined stick %s", possibleValue.c_str());
}
if((values_ = ConfigValues::getValuesStickPreset(possibleValue)) != NULL) {
if(HID_DEBUG) {
if ((values_ = ConfigValues::getValuesStickPreset(possibleValue)) != NULL) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Found predefined stick!");
}
config_controller[slot][keyslot][0] = values_[STICK_CONF_BYTE]; //CONTRPS_VPAD_BUTTON_L_STICK_X
config_controller[slot][keyslot][1] = values_[STICK_CONF_DEFAULT];
config_controller[slot][keyslot+DEF_STICK_OFFSET_INVERT][0] = CONTROLLER_PATCHER_VALUE_SET; //CONTRPS_VPAD_BUTTON_L_STICK_X_INVERT
config_controller[slot][keyslot+DEF_STICK_OFFSET_INVERT][1] = values_[STICK_CONF_INVERT];
config_controller[slot][keyslot+DEF_STICK_OFFSET_DEADZONE][0] = CONTROLLER_PATCHER_VALUE_SET; //CONTRPS_VPAD_BUTTON_L_STICK_X_DEADZONE
config_controller[slot][keyslot+DEF_STICK_OFFSET_DEADZONE][1] = values_[STICK_CONF_DEADZONE];
config_controller[slot][keyslot+DEF_STICK_OFFSET_MINMAX][0] = values_[STICK_CONF_MIN]; //CONTRPS_VPAD_BUTTON_L_STICK_X_MINMAX
config_controller[slot][keyslot+DEF_STICK_OFFSET_MINMAX][1] = values_[STICK_CONF_MAX];
config_controller[slot][keyslot][0] = values_[STICK_CONF_BYTE]; //CONTRPS_VPAD_BUTTON_L_STICK_X
config_controller[slot][keyslot][1] = values_[STICK_CONF_DEFAULT];
config_controller[slot][keyslot + DEF_STICK_OFFSET_INVERT][0] = CONTROLLER_PATCHER_VALUE_SET; //CONTRPS_VPAD_BUTTON_L_STICK_X_INVERT
config_controller[slot][keyslot + DEF_STICK_OFFSET_INVERT][1] = values_[STICK_CONF_INVERT];
config_controller[slot][keyslot + DEF_STICK_OFFSET_DEADZONE][0] = CONTROLLER_PATCHER_VALUE_SET; //CONTRPS_VPAD_BUTTON_L_STICK_X_DEADZONE
config_controller[slot][keyslot + DEF_STICK_OFFSET_DEADZONE][1] = values_[STICK_CONF_DEADZONE];
config_controller[slot][keyslot + DEF_STICK_OFFSET_MINMAX][0] = values_[STICK_CONF_MIN]; //CONTRPS_VPAD_BUTTON_L_STICK_X_MINMAX
config_controller[slot][keyslot + DEF_STICK_OFFSET_MINMAX][1] = values_[STICK_CONF_MAX];
return true;
}
}
if((values_ = getValuesForPreset(values,possibleValue)) != NULL) {
if ((values_ = getValuesForPreset(values, possibleValue)) != NULL) {
config_controller[slot][keyslot][0] = values_[0];
config_controller[slot][keyslot][1] = values_[1];
return true;
@ -90,8 +90,8 @@ BOOL ConfigValues::setIfValueIsPreset(std::map<std::string,const uint8_t*> value
}
int32_t ConfigValues::getValueFromMap(std::map<std::string,int> values,std::string nameOfString) {
std::map<std::string,int>::iterator it;
int32_t ConfigValues::getValueFromMap(std::map<std::string, int> values, std::string nameOfString) {
std::map<std::string, int>::iterator it;
it = values.find(nameOfString);
if (it != values.end()) {
return it->second;
@ -103,31 +103,31 @@ int32_t ConfigValues::getValueFromMap(std::map<std::string,int> values,std::stri
int32_t ConfigValues::getPresetValueEx(std::string possibleString) {
int32_t rightValue = -1;
if((rightValue = getValueFromMap(gGamePadValuesToCONTRPSString,possibleString))!= -1) {
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("Used pre-defined VPAD_VALUE! \"%s\" is %d",possibleString.c_str(),rightValue);
if ((rightValue = getValueFromMap(gGamePadValuesToCONTRPSString, possibleString)) != -1) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Used pre-defined VPAD_VALUE! \"%s\" is %d", possibleString.c_str(), rightValue);
}
} else if((rightValue = getValueFromMap(presetValues,possibleString))!= -1) {
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("Used pre-defined value! \"%s\" is %d",possibleString.c_str(),rightValue);
} else if ((rightValue = getValueFromMap(presetValues, possibleString)) != -1) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Used pre-defined value! \"%s\" is %d", possibleString.c_str(), rightValue);
}
}
return rightValue;
}
void ConfigValues::addDeviceNameEx(uint16_t vid,uint16_t pid,std::string value) {
deviceNames[StringTools::strfmt("%04X%04X",vid,pid).c_str()] = value;
void ConfigValues::addDeviceNameEx(uint16_t vid, uint16_t pid, std::string value) {
deviceNames[StringTools::strfmt("%04X%04X", vid, pid).c_str()] = value;
}
std::string ConfigValues::getStringByVIDPIDEx(uint16_t vid,uint16_t pid) {
std::string ConfigValues::getStringByVIDPIDEx(uint16_t vid, uint16_t pid) {
std::string result = "";
std::map<std::string,std::string>::iterator it;
std::map<std::string, std::string>::iterator it;
it = deviceNames.find(StringTools::strfmt("%04X%04X",vid,pid));
it = deviceNames.find(StringTools::strfmt("%04X%04X", vid, pid));
if (it != deviceNames.end()) {
result = it->second;
} else {
result = StringTools::strfmt("VID: 0x%04X\nPID: 0x%04X",vid,pid);
result = StringTools::strfmt("VID: 0x%04X\nPID: 0x%04X", vid, pid);
}
return result;
}

820
source/config/ConfigValues.hpp
View File

@ -17,21 +17,21 @@
#ifndef _ConfigValues_H_
#define _ConfigValues_H_
#include <map>
#include <string>
#include <vector>
#include <map>
#include "../ControllerPatcherIncludes.hpp"
#include <utils/logger.h>
class ConfigValues
{
friend class ConfigParser;
friend class ControllerPatcher;
class ConfigValues {
friend class ConfigParser;
friend class ControllerPatcher;
private:
static ConfigValues *getInstance() {
if(instance == NULL){
if (instance == NULL) {
DEBUG_FUNCTION_LINE("We need a new instance!!!\n");
instance = new ConfigValues();
}
@ -39,7 +39,7 @@ private:
}
static void destroyInstance() {
if(instance){
if (instance) {
delete instance;
instance = NULL;
}
@ -48,96 +48,88 @@ private:
/**
Returns NULL if not a preset!
**/
static const uint8_t * getValuesStickPreset(std::string possibleValue)
{
ConfigValues * cur_instance = getInstance();
if(cur_instance == NULL) return NULL;
return cur_instance->getValuesForPreset(cur_instance->presetSticks,possibleValue);
static const uint8_t *getValuesStickPreset(std::string possibleValue) {
ConfigValues *cur_instance = getInstance();
if (cur_instance == NULL) return NULL;
return cur_instance->getValuesForPreset(cur_instance->presetSticks, possibleValue);
}
/**
Returns -1 if not found
**/
static int32_t getKeySlotGamePad(std::string possibleValue)
{
ConfigValues * cur_instance = getInstance();
if(cur_instance == NULL) return -1;
return cur_instance->getValueFromMap(cur_instance->CONTPRStringToValue,possibleValue);
static int32_t getKeySlotGamePad(std::string possibleValue) {
ConfigValues *cur_instance = getInstance();
if (cur_instance == NULL) return -1;
return cur_instance->getValueFromMap(cur_instance->CONTPRStringToValue, possibleValue);
}
/**
Returns -1 if not found
**/
static int32_t getKeySlotMouse(std::string possibleValue)
{
ConfigValues * cur_instance = getInstance();
if(cur_instance == NULL) return -1;
return cur_instance->getValueFromMap(cur_instance->mouseLeftValues,possibleValue);
static int32_t getKeySlotMouse(std::string possibleValue) {
ConfigValues *cur_instance = getInstance();
if (cur_instance == NULL) return -1;
return cur_instance->getValueFromMap(cur_instance->mouseLeftValues, possibleValue);
}
/**
Returns -1 if not found
**/
static int32_t getKeySlotDefaultSingleValue(std::string possibleValue)
{
ConfigValues * cur_instance = getInstance();
if(cur_instance == NULL) return -1;
return cur_instance->getValueFromMap(cur_instance->CONTPRStringToValueSingle,possibleValue);
static int32_t getKeySlotDefaultSingleValue(std::string possibleValue) {
ConfigValues *cur_instance = getInstance();
if (cur_instance == NULL) return -1;
return cur_instance->getValueFromMap(cur_instance->CONTPRStringToValueSingle, possibleValue);
}
/**
Returns -1 if not found
**/
static int32_t getKeySlotDefaultPairedValue(std::string possibleValue)
{
ConfigValues * cur_instance = getInstance();
if(cur_instance == NULL) return -1;
return cur_instance->getValueFromMap(cur_instance->CONTPRStringToValue,possibleValue);
static int32_t getKeySlotDefaultPairedValue(std::string possibleValue) {
ConfigValues *cur_instance = getInstance();
if (cur_instance == NULL) return -1;
return cur_instance->getValueFromMap(cur_instance->CONTPRStringToValue, possibleValue);
}
/**
Returns -1 if not found
**/
static int32_t getPresetValuesKeyboard(std::string possibleValue)
{
ConfigValues * cur_instance = getInstance();
if(cur_instance == NULL) return -1;
return cur_instance->getValueFromMap(cur_instance->presetKeyboardValues,possibleValue);
static int32_t getPresetValuesKeyboard(std::string possibleValue) {
ConfigValues *cur_instance = getInstance();
if (cur_instance == NULL) return -1;
return cur_instance->getValueFromMap(cur_instance->presetKeyboardValues, possibleValue);
}
/**
Returns -1 if not found
**/
static int32_t getPresetValue(std::string possibleValue)
{
ConfigValues * cur_instance = getInstance();
if(cur_instance == NULL) return -1;
static int32_t getPresetValue(std::string possibleValue) {
ConfigValues *cur_instance = getInstance();
if (cur_instance == NULL) return -1;
return cur_instance->getPresetValueEx(possibleValue);
}
/**
Returns -1 if not found
**/
static int32_t setIfValueIsAControllerPreset(std::string value,int32_t slot,int32_t keyslot)
{
ConfigValues * cur_instance = getInstance();
if(cur_instance == NULL) return -1;
return cur_instance->setIfValueIsAControllerPresetEx(value,slot,keyslot);
static int32_t setIfValueIsAControllerPreset(std::string value, int32_t slot, int32_t keyslot) {
ConfigValues *cur_instance = getInstance();
if (cur_instance == NULL) return -1;
return cur_instance->setIfValueIsAControllerPresetEx(value, slot, keyslot);
}
static void addDeviceName(uint16_t vid,uint16_t pid,std::string value){
ConfigValues * cur_instance = getInstance();
if(cur_instance != NULL){
cur_instance->addDeviceNameEx(vid,pid,value);
static void addDeviceName(uint16_t vid, uint16_t pid, std::string value) {
ConfigValues *cur_instance = getInstance();
if (cur_instance != NULL) {
cur_instance->addDeviceNameEx(vid, pid, value);
}
}
/**
Returns empty String if not found
**/
static std::string getStringByVIDPID(uint16_t vid,uint16_t pid){
ConfigValues * cur_instance = getInstance();
if(cur_instance == NULL) return "";
return cur_instance->getStringByVIDPIDEx(vid,pid);
static std::string getStringByVIDPID(uint16_t vid, uint16_t pid) {
ConfigValues *cur_instance = getInstance();
if (cur_instance == NULL) return "";
return cur_instance->getStringByVIDPIDEx(vid, pid);
}
//!Constructor
@ -147,428 +139,428 @@ private:
static ConfigValues *instance;
std::map<std::string,int> mouseLeftValues;
std::map<std::string,int> CONTPRStringToValue;
std::map<std::string,int> CONTPRStringToValueSingle;
std::map<std::string,int> presetValues;
std::map<std::string,int> gGamePadValuesToCONTRPSString;
std::map<std::string,int> presetKeyboardValues;
std::map<std::string, int> mouseLeftValues;
std::map<std::string, int> CONTPRStringToValue;
std::map<std::string, int> CONTPRStringToValueSingle;
std::map<std::string, int> presetValues;
std::map<std::string, int> gGamePadValuesToCONTRPSString;
std::map<std::string, int> presetKeyboardValues;
std::map<std::string,std::string> deviceNames;
std::map<std::string, std::string> deviceNames;
std::map<std::string,const uint8_t*> presetGCValues;
std::map<std::string,const uint8_t*> presetDS3Values;
std::map<std::string,const uint8_t*> presetDS4Values;
std::map<std::string,const uint8_t*> presetXInputValues;
std::map<std::string,const uint8_t*> presetSwitchProValues;
std::map<std::string,const uint8_t*> presetSticks;
std::map<std::string, const uint8_t *> presetGCValues;
std::map<std::string, const uint8_t *> presetDS3Values;
std::map<std::string, const uint8_t *> presetDS4Values;
std::map<std::string, const uint8_t *> presetXInputValues;
std::map<std::string, const uint8_t *> presetSwitchProValues;
std::map<std::string, const uint8_t *> presetSticks;
int32_t 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,int32_t slot,int32_t keyslot);
BOOL checkIfValueIsAControllerPreset(std::string value, int32_t slot, int32_t keyslot);
int32_t getPresetValueEx(std::string possibleString);
void InitValues(){
void InitValues() {
DEBUG_FUNCTION_LINE("Init values for the configuration");
CONTPRStringToValue["VPAD_BUTTON_A"] = CONTRPS_VPAD_BUTTON_A;
CONTPRStringToValue["VPAD_BUTTON_B"] = CONTRPS_VPAD_BUTTON_B;
CONTPRStringToValue["VPAD_BUTTON_X"] = CONTRPS_VPAD_BUTTON_X;
CONTPRStringToValue["VPAD_BUTTON_Y"] = CONTRPS_VPAD_BUTTON_Y;
CONTPRStringToValue["VPAD_BUTTON_A"] = CONTRPS_VPAD_BUTTON_A;
CONTPRStringToValue["VPAD_BUTTON_B"] = CONTRPS_VPAD_BUTTON_B;
CONTPRStringToValue["VPAD_BUTTON_X"] = CONTRPS_VPAD_BUTTON_X;
CONTPRStringToValue["VPAD_BUTTON_Y"] = CONTRPS_VPAD_BUTTON_Y;
/* Normal DPAD */
CONTPRStringToValue["VPAD_BUTTON_LEFT"] = CONTRPS_VPAD_BUTTON_LEFT;
CONTPRStringToValue["VPAD_BUTTON_RIGHT"] = CONTRPS_VPAD_BUTTON_RIGHT;
CONTPRStringToValue["VPAD_BUTTON_UP"] = CONTRPS_VPAD_BUTTON_UP;
CONTPRStringToValue["VPAD_BUTTON_DOWN"] = CONTRPS_VPAD_BUTTON_DOWN;
CONTPRStringToValue["VPAD_BUTTON_LEFT"] = CONTRPS_VPAD_BUTTON_LEFT;
CONTPRStringToValue["VPAD_BUTTON_RIGHT"] = CONTRPS_VPAD_BUTTON_RIGHT;
CONTPRStringToValue["VPAD_BUTTON_UP"] = CONTRPS_VPAD_BUTTON_UP;
CONTPRStringToValue["VPAD_BUTTON_DOWN"] = CONTRPS_VPAD_BUTTON_DOWN;
/* DPAD hat mode */
CONTPRStringToValue["VPAD_BUTTON_DPAD_N"] = CONTRPS_VPAD_BUTTON_DPAD_N;
CONTPRStringToValue["VPAD_BUTTON_DPAD_NE"] = CONTRPS_VPAD_BUTTON_DPAD_NE;
CONTPRStringToValue["VPAD_BUTTON_DPAD_E"] = CONTRPS_VPAD_BUTTON_DPAD_E;
CONTPRStringToValue["VPAD_BUTTON_DPAD_SE"] = CONTRPS_VPAD_BUTTON_DPAD_SE;
CONTPRStringToValue["VPAD_BUTTON_DPAD_S"] = CONTRPS_VPAD_BUTTON_DPAD_S;
CONTPRStringToValue["VPAD_BUTTON_DPAD_SW"] = CONTRPS_VPAD_BUTTON_DPAD_SW;
CONTPRStringToValue["VPAD_BUTTON_DPAD_W"] = CONTRPS_VPAD_BUTTON_DPAD_W;
CONTPRStringToValue["VPAD_BUTTON_DPAD_NW"] = CONTRPS_VPAD_BUTTON_DPAD_NW;
CONTPRStringToValue["VPAD_BUTTON_DPAD_NEUTRAL"] = CONTRPS_VPAD_BUTTON_DPAD_NEUTRAL;
CONTPRStringToValue["VPAD_BUTTON_DPAD_N"] = CONTRPS_VPAD_BUTTON_DPAD_N;
CONTPRStringToValue["VPAD_BUTTON_DPAD_NE"] = CONTRPS_VPAD_BUTTON_DPAD_NE;
CONTPRStringToValue["VPAD_BUTTON_DPAD_E"] = CONTRPS_VPAD_BUTTON_DPAD_E;
CONTPRStringToValue["VPAD_BUTTON_DPAD_SE"] = CONTRPS_VPAD_BUTTON_DPAD_SE;
CONTPRStringToValue["VPAD_BUTTON_DPAD_S"] = CONTRPS_VPAD_BUTTON_DPAD_S;
CONTPRStringToValue["VPAD_BUTTON_DPAD_SW"] = CONTRPS_VPAD_BUTTON_DPAD_SW;
CONTPRStringToValue["VPAD_BUTTON_DPAD_W"] = CONTRPS_VPAD_BUTTON_DPAD_W;
CONTPRStringToValue["VPAD_BUTTON_DPAD_NW"] = CONTRPS_VPAD_BUTTON_DPAD_NW;
CONTPRStringToValue["VPAD_BUTTON_DPAD_NEUTRAL"] = CONTRPS_VPAD_BUTTON_DPAD_NEUTRAL;
/* DPAD Absolute mode */
CONTPRStringToValue["VPAD_BUTTON_DPAD_ABS_UP"] = CONTRPS_VPAD_BUTTON_DPAD_ABS_UP;
CONTPRStringToValue["VPAD_BUTTON_DPAD_ABS_DOWN"] = CONTRPS_VPAD_BUTTON_DPAD_ABS_DOWN;
CONTPRStringToValue["VPAD_BUTTON_DPAD_ABS_LEFT"] = CONTRPS_VPAD_BUTTON_DPAD_ABS_LEFT;
CONTPRStringToValue["VPAD_BUTTON_DPAD_ABS_RIGHT"] = CONTRPS_VPAD_BUTTON_DPAD_ABS_RIGHT;
CONTPRStringToValue["VPAD_BUTTON_DPAD_ABS_UP"] = CONTRPS_VPAD_BUTTON_DPAD_ABS_UP;
CONTPRStringToValue["VPAD_BUTTON_DPAD_ABS_DOWN"] = CONTRPS_VPAD_BUTTON_DPAD_ABS_DOWN;
CONTPRStringToValue["VPAD_BUTTON_DPAD_ABS_LEFT"] = CONTRPS_VPAD_BUTTON_DPAD_ABS_LEFT;
CONTPRStringToValue["VPAD_BUTTON_DPAD_ABS_RIGHT"] = CONTRPS_VPAD_BUTTON_DPAD_ABS_RIGHT;
/* */
CONTPRStringToValue["VPAD_BUTTON_ZL"] = CONTRPS_VPAD_BUTTON_ZL;
CONTPRStringToValue["VPAD_BUTTON_ZR"] = CONTRPS_VPAD_BUTTON_ZR;
CONTPRStringToValue["VPAD_BUTTON_L"] = CONTRPS_VPAD_BUTTON_L;
CONTPRStringToValue["VPAD_BUTTON_R"] = CONTRPS_VPAD_BUTTON_R;
CONTPRStringToValue["VPAD_BUTTON_PLUS"] = CONTRPS_VPAD_BUTTON_PLUS;
CONTPRStringToValue["VPAD_BUTTON_MINUS"] = CONTRPS_VPAD_BUTTON_MINUS;
CONTPRStringToValue["VPAD_BUTTON_HOME"] = CONTRPS_VPAD_BUTTON_HOME;
CONTPRStringToValue["VPAD_BUTTON_SYNC"] = CONTRPS_VPAD_BUTTON_SYNC;
CONTPRStringToValue["VPAD_BUTTON_STICK_R"] = CONTRPS_VPAD_BUTTON_STICK_R;
CONTPRStringToValue["VPAD_BUTTON_STICK_L"] = CONTRPS_VPAD_BUTTON_STICK_L;
CONTPRStringToValue["VPAD_BUTTON_ZL"] = CONTRPS_VPAD_BUTTON_ZL;
CONTPRStringToValue["VPAD_BUTTON_ZR"] = CONTRPS_VPAD_BUTTON_ZR;
CONTPRStringToValue["VPAD_BUTTON_L"] = CONTRPS_VPAD_BUTTON_L;
CONTPRStringToValue["VPAD_BUTTON_R"] = CONTRPS_VPAD_BUTTON_R;
CONTPRStringToValue["VPAD_BUTTON_PLUS"] = CONTRPS_VPAD_BUTTON_PLUS;
CONTPRStringToValue["VPAD_BUTTON_MINUS"] = CONTRPS_VPAD_BUTTON_MINUS;
CONTPRStringToValue["VPAD_BUTTON_HOME"] = CONTRPS_VPAD_BUTTON_HOME;
CONTPRStringToValue["VPAD_BUTTON_SYNC"] = CONTRPS_VPAD_BUTTON_SYNC;
CONTPRStringToValue["VPAD_BUTTON_STICK_R"] = CONTRPS_VPAD_BUTTON_STICK_R;
CONTPRStringToValue["VPAD_BUTTON_STICK_L"] = CONTRPS_VPAD_BUTTON_STICK_L;
CONTPRStringToValue["VPAD_STICK_R_EMULATION_LEFT"] = CONTRPS_VPAD_STICK_R_EMULATION_LEFT;
CONTPRStringToValue["VPAD_STICK_R_EMULATION_RIGHT"] = CONTRPS_VPAD_STICK_R_EMULATION_RIGHT;
CONTPRStringToValue["VPAD_STICK_R_EMULATION_UP"] = CONTRPS_VPAD_STICK_R_EMULATION_UP;
CONTPRStringToValue["VPAD_STICK_R_EMULATION_DOWN"] = CONTRPS_VPAD_STICK_R_EMULATION_DOWN;
CONTPRStringToValue["VPAD_STICK_L_EMULATION_LEFT"] = CONTRPS_VPAD_STICK_L_EMULATION_LEFT;
CONTPRStringToValue["VPAD_STICK_L_EMULATION_RIGHT"] = CONTRPS_VPAD_STICK_L_EMULATION_RIGHT;
CONTPRStringToValue["VPAD_STICK_L_EMULATION_UP"] = CONTRPS_VPAD_STICK_L_EMULATION_UP;
CONTPRStringToValue["VPAD_STICK_L_EMULATION_DOWN"] = CONTRPS_VPAD_STICK_L_EMULATION_DOWN;
CONTPRStringToValue["VPAD_STICK_R_EMULATION_LEFT"] = CONTRPS_VPAD_STICK_R_EMULATION_LEFT;
CONTPRStringToValue["VPAD_STICK_R_EMULATION_RIGHT"] = CONTRPS_VPAD_STICK_R_EMULATION_RIGHT;
CONTPRStringToValue["VPAD_STICK_R_EMULATION_UP"] = CONTRPS_VPAD_STICK_R_EMULATION_UP;
CONTPRStringToValue["VPAD_STICK_R_EMULATION_DOWN"] = CONTRPS_VPAD_STICK_R_EMULATION_DOWN;
CONTPRStringToValue["VPAD_STICK_L_EMULATION_LEFT"] = CONTRPS_VPAD_STICK_L_EMULATION_LEFT;
CONTPRStringToValue["VPAD_STICK_L_EMULATION_RIGHT"] = CONTRPS_VPAD_STICK_L_EMULATION_RIGHT;
CONTPRStringToValue["VPAD_STICK_L_EMULATION_UP"] = CONTRPS_VPAD_STICK_L_EMULATION_UP;
CONTPRStringToValue["VPAD_STICK_L_EMULATION_DOWN"] = CONTRPS_VPAD_STICK_L_EMULATION_DOWN;
CONTPRStringToValue["VPAD_L_STICK_UP"] = CONTRPS_VPAD_BUTTON_L_STICK_UP;
CONTPRStringToValue["VPAD_L_STICK_DOWN"] = CONTRPS_VPAD_BUTTON_L_STICK_DOWN;
CONTPRStringToValue["VPAD_L_STICK_LEFT"] = CONTRPS_VPAD_BUTTON_L_STICK_LEFT;
CONTPRStringToValue["VPAD_L_STICK_RIGHT"] = CONTRPS_VPAD_BUTTON_L_STICK_RIGHT;
CONTPRStringToValue["VPAD_L_STICK_UP"] = CONTRPS_VPAD_BUTTON_L_STICK_UP;
CONTPRStringToValue["VPAD_L_STICK_DOWN"] = CONTRPS_VPAD_BUTTON_L_STICK_DOWN;
CONTPRStringToValue["VPAD_L_STICK_LEFT"] = CONTRPS_VPAD_BUTTON_L_STICK_LEFT;
CONTPRStringToValue["VPAD_L_STICK_RIGHT"] = CONTRPS_VPAD_BUTTON_L_STICK_RIGHT;
CONTPRStringToValue["VPAD_R_STICK_UP"] = CONTRPS_VPAD_BUTTON_R_STICK_UP;
CONTPRStringToValue["VPAD_R_STICK_DOWN"] = CONTRPS_VPAD_BUTTON_R_STICK_DOWN;
CONTPRStringToValue["VPAD_R_STICK_LEFT"] = CONTRPS_VPAD_BUTTON_R_STICK_LEFT;
CONTPRStringToValue["VPAD_R_STICK_RIGHT"] = CONTRPS_VPAD_BUTTON_R_STICK_RIGHT;
CONTPRStringToValue["VPAD_R_STICK_UP"] = CONTRPS_VPAD_BUTTON_R_STICK_UP;
CONTPRStringToValue["VPAD_R_STICK_DOWN"] = CONTRPS_VPAD_BUTTON_R_STICK_DOWN;
CONTPRStringToValue["VPAD_R_STICK_LEFT"] = CONTRPS_VPAD_BUTTON_R_STICK_LEFT;
CONTPRStringToValue["VPAD_R_STICK_RIGHT"] = CONTRPS_VPAD_BUTTON_R_STICK_RIGHT;
CONTPRStringToValue["VPAD_L_STICK_X"] = CONTRPS_VPAD_BUTTON_L_STICK_X;
CONTPRStringToValue["VPAD_L_STICK_X_MINMAX"] = CONTRPS_VPAD_BUTTON_L_STICK_X_MINMAX;
CONTPRStringToValue["VPAD_L_STICK_Y"] = CONTRPS_VPAD_BUTTON_L_STICK_Y;
CONTPRStringToValue["VPAD_L_STICK_Y_MINMAX"] = CONTRPS_VPAD_BUTTON_L_STICK_Y_MINMAX;
CONTPRStringToValue["VPAD_R_STICK_X"] = CONTRPS_VPAD_BUTTON_R_STICK_X;
CONTPRStringToValue["VPAD_R_STICK_X_MINMAX"] = CONTRPS_VPAD_BUTTON_R_STICK_X_MINMAX;
CONTPRStringToValue["VPAD_R_STICK_Y"] = CONTRPS_VPAD_BUTTON_R_STICK_Y;
CONTPRStringToValue["VPAD_R_STICK_Y_MINMAX"] = CONTRPS_VPAD_BUTTON_R_STICK_Y_MINMAX;
CONTPRStringToValue["VPAD_BUTTON_TV"] = CONTRPS_VPAD_BUTTON_TV;
CONTPRStringToValue["VPAD_L_STICK_X"] = CONTRPS_VPAD_BUTTON_L_STICK_X;
CONTPRStringToValue["VPAD_L_STICK_X_MINMAX"] = CONTRPS_VPAD_BUTTON_L_STICK_X_MINMAX;
CONTPRStringToValue["VPAD_L_STICK_Y"] = CONTRPS_VPAD_BUTTON_L_STICK_Y;
CONTPRStringToValue["VPAD_L_STICK_Y_MINMAX"] = CONTRPS_VPAD_BUTTON_L_STICK_Y_MINMAX;
CONTPRStringToValue["VPAD_R_STICK_X"] = CONTRPS_VPAD_BUTTON_R_STICK_X;
CONTPRStringToValue["VPAD_R_STICK_X_MINMAX"] = CONTRPS_VPAD_BUTTON_R_STICK_X_MINMAX;
CONTPRStringToValue["VPAD_R_STICK_Y"] = CONTRPS_VPAD_BUTTON_R_STICK_Y;
CONTPRStringToValue["VPAD_R_STICK_Y_MINMAX"] = CONTRPS_VPAD_BUTTON_R_STICK_Y_MINMAX;
CONTPRStringToValue["VPAD_BUTTON_TV"] = CONTRPS_VPAD_BUTTON_TV;
CONTPRStringToValue["DOUBLE_USE_BUTTON_ACTIVATOR"] = CONTRPS_DOUBLE_USE_BUTTON_ACTIVATOR,
CONTPRStringToValue["INPUT_FILTER"] = CONTRPS_INPUT_FILTER;
CONTPRStringToValue["PAD1_FILTER"] = CONTRPS_PAD1_FILTER;
CONTPRStringToValue["PAD2_FILTER"] = CONTRPS_PAD2_FILTER;
CONTPRStringToValue["PAD3_FILTER"] = CONTRPS_PAD3_FILTER;
CONTPRStringToValue["PAD4_FILTER"] = CONTRPS_PAD4_FILTER;
CONTPRStringToValue["PAD5_FILTER"] = CONTRPS_PAD5_FILTER;
CONTPRStringToValue["DOUBLE_USE_BUTTON_ACTIVATOR"] = CONTRPS_DOUBLE_USE_BUTTON_ACTIVATOR,
CONTPRStringToValue["INPUT_FILTER"] = CONTRPS_INPUT_FILTER;
CONTPRStringToValue["PAD1_FILTER"] = CONTRPS_PAD1_FILTER;
CONTPRStringToValue["PAD2_FILTER"] = CONTRPS_PAD2_FILTER;
CONTPRStringToValue["PAD3_FILTER"] = CONTRPS_PAD3_FILTER;
CONTPRStringToValue["PAD4_FILTER"] = CONTRPS_PAD4_FILTER;
CONTPRStringToValue["PAD5_FILTER"] = CONTRPS_PAD5_FILTER;
CONTPRStringToValueSingle["DOUBLE_USE_BUTTON_1_PRESSED"] = CONTRPS_DOUBLE_USE_BUTTON_1_PRESSED;
CONTPRStringToValueSingle["DOUBLE_USE_BUTTON_2_PRESSED"] = CONTRPS_DOUBLE_USE_BUTTON_2_PRESSED;
CONTPRStringToValueSingle["DOUBLE_USE_BUTTON_3_PRESSED"] = CONTRPS_DOUBLE_USE_BUTTON_3_PRESSED;
CONTPRStringToValueSingle["DOUBLE_USE_BUTTON_4_PRESSED"] = CONTRPS_DOUBLE_USE_BUTTON_4_PRESSED;
CONTPRStringToValueSingle["DOUBLE_USE_BUTTON_5_PRESSED"] = CONTRPS_DOUBLE_USE_BUTTON_5_PRESSED;
CONTPRStringToValueSingle["DOUBLE_USE_BUTTON_1_RELEASED"] = CONTRPS_DOUBLE_USE_BUTTON_1_RELEASED;
CONTPRStringToValueSingle["DOUBLE_USE_BUTTON_2_RELEASED"] = CONTRPS_DOUBLE_USE_BUTTON_2_RELEASED;
CONTPRStringToValueSingle["DOUBLE_USE_BUTTON_3_RELEASED"] = CONTRPS_DOUBLE_USE_BUTTON_3_RELEASED;
CONTPRStringToValueSingle["DOUBLE_USE_BUTTON_4_RELEASED"] = CONTRPS_DOUBLE_USE_BUTTON_4_RELEASED;
CONTPRStringToValueSingle["DOUBLE_USE_BUTTON_5_RELEASED"] = CONTRPS_DOUBLE_USE_BUTTON_5_RELEASED;
CONTPRStringToValueSingle["DOUBLE_USE_BUTTON_1_PRESSED"] = CONTRPS_DOUBLE_USE_BUTTON_1_PRESSED;
CONTPRStringToValueSingle["DOUBLE_USE_BUTTON_2_PRESSED"] = CONTRPS_DOUBLE_USE_BUTTON_2_PRESSED;
CONTPRStringToValueSingle["DOUBLE_USE_BUTTON_3_PRESSED"] = CONTRPS_DOUBLE_USE_BUTTON_3_PRESSED;
CONTPRStringToValueSingle["DOUBLE_USE_BUTTON_4_PRESSED"] = CONTRPS_DOUBLE_USE_BUTTON_4_PRESSED;
CONTPRStringToValueSingle["DOUBLE_USE_BUTTON_5_PRESSED"] = CONTRPS_DOUBLE_USE_BUTTON_5_PRESSED;
CONTPRStringToValueSingle["DOUBLE_USE_BUTTON_1_RELEASED"] = CONTRPS_DOUBLE_USE_BUTTON_1_RELEASED;
CONTPRStringToValueSingle["DOUBLE_USE_BUTTON_2_RELEASED"] = CONTRPS_DOUBLE_USE_BUTTON_2_RELEASED;
CONTPRStringToValueSingle["DOUBLE_USE_BUTTON_3_RELEASED"] = CONTRPS_DOUBLE_USE_BUTTON_3_RELEASED;
CONTPRStringToValueSingle["DOUBLE_USE_BUTTON_4_RELEASED"] = CONTRPS_DOUBLE_USE_BUTTON_4_RELEASED;
CONTPRStringToValueSingle["DOUBLE_USE_BUTTON_5_RELEASED"] = CONTRPS_DOUBLE_USE_BUTTON_5_RELEASED;
CONTPRStringToValueSingle["BUF_SIZE"] = CONTRPS_BUF_SIZE;
CONTPRStringToValueSingle["DPAD_MODE"] = CONTRPS_DPAD_MODE;
CONTPRStringToValueSingle["DPAD_MASK"] = CONTRPS_DPAD_MASK;
CONTPRStringToValueSingle["VPAD_L_STICK_X_DEADZONE"] = CONTRPS_VPAD_BUTTON_L_STICK_X_DEADZONE;
CONTPRStringToValueSingle["VPAD_L_STICK_Y_DEADZONE"] = CONTRPS_VPAD_BUTTON_L_STICK_Y_DEADZONE;
CONTPRStringToValueSingle["VPAD_R_STICK_X_DEADZONE"] = CONTRPS_VPAD_BUTTON_R_STICK_X_DEADZONE;
CONTPRStringToValueSingle["VPAD_R_STICK_Y_DEADZONE"] = CONTRPS_VPAD_BUTTON_R_STICK_Y_DEADZONE;
CONTPRStringToValueSingle["VPAD_L_STICK_X_INVERT"] = CONTRPS_VPAD_BUTTON_L_STICK_X_INVERT;
CONTPRStringToValueSingle["VPAD_L_STICK_Y_INVERT"] = CONTRPS_VPAD_BUTTON_L_STICK_Y_INVERT;
CONTPRStringToValueSingle["VPAD_R_STICK_X_INVERT"] = CONTRPS_VPAD_BUTTON_R_STICK_X_INVERT;
CONTPRStringToValueSingle["VPAD_R_STICK_Y_INVERT"] = CONTRPS_VPAD_BUTTON_R_STICK_Y_INVERT;
CONTPRStringToValueSingle["BUF_SIZE"] = CONTRPS_BUF_SIZE;
CONTPRStringToValueSingle["DPAD_MODE"] = CONTRPS_DPAD_MODE;
CONTPRStringToValueSingle["DPAD_MASK"] = CONTRPS_DPAD_MASK;
CONTPRStringToValueSingle["VPAD_L_STICK_X_DEADZONE"] = CONTRPS_VPAD_BUTTON_L_STICK_X_DEADZONE;
CONTPRStringToValueSingle["VPAD_L_STICK_Y_DEADZONE"] = CONTRPS_VPAD_BUTTON_L_STICK_Y_DEADZONE;
CONTPRStringToValueSingle["VPAD_R_STICK_X_DEADZONE"] = CONTRPS_VPAD_BUTTON_R_STICK_X_DEADZONE;
CONTPRStringToValueSingle["VPAD_R_STICK_Y_DEADZONE"] = CONTRPS_VPAD_BUTTON_R_STICK_Y_DEADZONE;
CONTPRStringToValueSingle["VPAD_L_STICK_X_INVERT"] = CONTRPS_VPAD_BUTTON_L_STICK_X_INVERT;
CONTPRStringToValueSingle["VPAD_L_STICK_Y_INVERT"] = CONTRPS_VPAD_BUTTON_L_STICK_Y_INVERT;
CONTPRStringToValueSingle["VPAD_R_STICK_X_INVERT"] = CONTRPS_VPAD_BUTTON_R_STICK_X_INVERT;
CONTPRStringToValueSingle["VPAD_R_STICK_Y_INVERT"] = CONTRPS_VPAD_BUTTON_R_STICK_Y_INVERT;
CONTPRStringToValueSingle["DOUBLE_USE"] = CONTRPS_DOUBLE_USE;
CONTPRStringToValueSingle["PAD_COUNT"] = CONTRPS_PAD_COUNT;
CONTPRStringToValueSingle["DOUBLE_USE"] = CONTRPS_DOUBLE_USE;
CONTPRStringToValueSingle["PAD_COUNT"] = CONTRPS_PAD_COUNT;
CONTPRStringToValueSingle["VPAD_L_STICK_COPY_DPAD"] = CONTRPS_VPAD_STICK_L_COPY_DPAD;
CONTPRStringToValueSingle["VPAD_R_STICK_COPY_DPAD"] = CONTRPS_VPAD_STICK_R_COPY_DPAD;
CONTPRStringToValueSingle["VPAD_L_STICK_COPY_DPAD"] = CONTRPS_VPAD_STICK_L_COPY_DPAD;
CONTPRStringToValueSingle["VPAD_R_STICK_COPY_DPAD"] = CONTRPS_VPAD_STICK_R_COPY_DPAD;
mouseLeftValues["LEFT_CLICK"] = CONTRPS_VPAD_BUTTON_LEFT;
mouseLeftValues["RIGHT_CLICK"] = CONTRPS_VPAD_BUTTON_RIGHT;
mouseLeftValues["EMULATED_STICK"] = CONTRPS_MOUSE_STICK;
mouseLeftValues["LEFT_CLICK"] = CONTRPS_VPAD_BUTTON_LEFT;
mouseLeftValues["RIGHT_CLICK"] = CONTRPS_VPAD_BUTTON_RIGHT;
mouseLeftValues["EMULATED_STICK"] = CONTRPS_MOUSE_STICK;
presetGCValues["GC_BUTTON_A"] = HID_GC_BUTTON_A;
presetGCValues["GC_BUTTON_B"] = HID_GC_BUTTON_B;
presetGCValues["GC_BUTTON_X"] = HID_GC_BUTTON_X;
presetGCValues["GC_BUTTON_Y"] = HID_GC_BUTTON_Y;
presetGCValues["GC_BUTTON_LEFT"] = HID_GC_BUTTON_LEFT;
presetGCValues["GC_BUTTON_RIGHT"] = HID_GC_BUTTON_RIGHT;
presetGCValues["GC_BUTTON_DOWN"] = HID_GC_BUTTON_DOWN;
presetGCValues["GC_BUTTON_UP"] = HID_GC_BUTTON_UP;
presetGCValues["GC_BUTTON_START"] = HID_GC_BUTTON_START;
presetGCValues["GC_BUTTON_Z"] = HID_GC_BUTTON_Z;
presetGCValues["GC_BUTTON_L"] = HID_GC_BUTTON_L;
presetGCValues["GC_BUTTON_R"] = HID_GC_BUTTON_R;
presetGCValues["GC_BUTTON_A"] = HID_GC_BUTTON_A;
presetGCValues["GC_BUTTON_B"] = HID_GC_BUTTON_B;
presetGCValues["GC_BUTTON_X"] = HID_GC_BUTTON_X;
presetGCValues["GC_BUTTON_Y"] = HID_GC_BUTTON_Y;
presetGCValues["GC_BUTTON_LEFT"] = HID_GC_BUTTON_LEFT;
presetGCValues["GC_BUTTON_RIGHT"] = HID_GC_BUTTON_RIGHT;
presetGCValues["GC_BUTTON_DOWN"] = HID_GC_BUTTON_DOWN;
presetGCValues["GC_BUTTON_UP"] = HID_GC_BUTTON_UP;
presetGCValues["GC_BUTTON_START"] = HID_GC_BUTTON_START;
presetGCValues["GC_BUTTON_Z"] = HID_GC_BUTTON_Z;
presetGCValues["GC_BUTTON_L"] = HID_GC_BUTTON_L;
presetGCValues["GC_BUTTON_R"] = HID_GC_BUTTON_R;
presetDS3Values["DS3_BUTTON_CROSS"] = HID_DS3_BUTTON_CROSS;
presetDS3Values["DS3_BUTTON_CIRCLE"] = HID_DS3_BUTTON_CIRCLE;
presetDS3Values["DS3_BUTTON_SQUARE"] = HID_DS3_BUTTON_SQUARE;
presetDS3Values["DS3_BUTTON_TRIANGLE"] = HID_DS3_BUTTON_TRIANGLE;
presetDS3Values["DS3_BUTTON_CROSS"] = HID_DS3_BUTTON_CROSS;
presetDS3Values["DS3_BUTTON_CIRCLE"] = HID_DS3_BUTTON_CIRCLE;
presetDS3Values["DS3_BUTTON_SQUARE"] = HID_DS3_BUTTON_SQUARE;
presetDS3Values["DS3_BUTTON_TRIANGLE"] = HID_DS3_BUTTON_TRIANGLE;
presetDS3Values["DS3_BUTTON_L1"] = HID_DS3_BUTTON_L1;
presetDS3Values["DS3_BUTTON_L2"] = HID_DS3_BUTTON_L2;
presetDS3Values["DS3_BUTTON_L3"] = HID_DS3_BUTTON_L3;
presetDS3Values["DS3_BUTTON_R1"] = HID_DS3_BUTTON_R1;
presetDS3Values["DS3_BUTTON_R2"] = HID_DS3_BUTTON_R2;
presetDS3Values["DS3_BUTTON_R3"] = HID_DS3_BUTTON_R3;
presetDS3Values["DS3_BUTTON_L1"] = HID_DS3_BUTTON_L1;
presetDS3Values["DS3_BUTTON_L2"] = HID_DS3_BUTTON_L2;
presetDS3Values["DS3_BUTTON_L3"] = HID_DS3_BUTTON_L3;
presetDS3Values["DS3_BUTTON_R1"] = HID_DS3_BUTTON_R1;
presetDS3Values["DS3_BUTTON_R2"] = HID_DS3_BUTTON_R2;
presetDS3Values["DS3_BUTTON_R3"] = HID_DS3_BUTTON_R3;
presetDS3Values["DS3_BUTTON_SELECT"] = HID_DS3_BUTTON_SELECT;
presetDS3Values["DS3_BUTTON_START"] = HID_DS3_BUTTON_START;
presetDS3Values["DS3_BUTTON_LEFT"] = HID_DS3_BUTTON_LEFT;
presetDS3Values["DS3_BUTTON_RIGHT"] = HID_DS3_BUTTON_RIGHT;
presetDS3Values["DS3_BUTTON_UP"] = HID_DS3_BUTTON_UP;
presetDS3Values["DS3_BUTTON_DOWN"] = HID_DS3_BUTTON_DOWN;
presetDS3Values["DS3_BUTTON_GUIDE"] = HID_DS3_BUTTON_GUIDE;
presetDS3Values["DS3_BUTTON_SELECT"] = HID_DS3_BUTTON_SELECT;
presetDS3Values["DS3_BUTTON_START"] = HID_DS3_BUTTON_START;
presetDS3Values["DS3_BUTTON_LEFT"] = HID_DS3_BUTTON_LEFT;
presetDS3Values["DS3_BUTTON_RIGHT"] = HID_DS3_BUTTON_RIGHT;
presetDS3Values["DS3_BUTTON_UP"] = HID_DS3_BUTTON_UP;
presetDS3Values["DS3_BUTTON_DOWN"] = HID_DS3_BUTTON_DOWN;
presetDS3Values["DS3_BUTTON_GUIDE"] = HID_DS3_BUTTON_GUIDE;
presetDS4Values["DS4_BUTTON_CROSS"] = HID_DS4_BUTTON_CROSS;
presetDS4Values["DS4_BUTTON_CIRCLE"] = HID_DS4_BUTTON_CIRCLE;
presetDS4Values["DS4_BUTTON_SQUARE"] = HID_DS4_BUTTON_SQUARE;
presetDS4Values["DS4_BUTTON_TRIANGLE"] = HID_DS4_BUTTON_TRIANGLE;
presetDS4Values["DS4_BUTTON_CROSS"] = HID_DS4_BUTTON_CROSS;
presetDS4Values["DS4_BUTTON_CIRCLE"] = HID_DS4_BUTTON_CIRCLE;
presetDS4Values["DS4_BUTTON_SQUARE"] = HID_DS4_BUTTON_SQUARE;
presetDS4Values["DS4_BUTTON_TRIANGLE"] = HID_DS4_BUTTON_TRIANGLE;
presetDS4Values["DS4_BUTTON_L1"] = HID_DS4_BUTTON_L1;
presetDS4Values["DS4_BUTTON_L2"] = HID_DS4_BUTTON_L2;
presetDS4Values["DS4_BUTTON_L3"] = HID_DS4_BUTTON_L3;
presetDS4Values["DS4_BUTTON_R1"] = HID_DS4_BUTTON_R1;
presetDS4Values["DS4_BUTTON_R2"] = HID_DS4_BUTTON_R2;
presetDS4Values["DS4_BUTTON_R3"] = HID_DS4_BUTTON_R3;
presetDS4Values["DS4_BUTTON_L1"] = HID_DS4_BUTTON_L1;
presetDS4Values["DS4_BUTTON_L2"] = HID_DS4_BUTTON_L2;
presetDS4Values["DS4_BUTTON_L3"] = HID_DS4_BUTTON_L3;
presetDS4Values["DS4_BUTTON_R1"] = HID_DS4_BUTTON_R1;
presetDS4Values["DS4_BUTTON_R2"] = HID_DS4_BUTTON_R2;
presetDS4Values["DS4_BUTTON_R3"] = HID_DS4_BUTTON_R3;
presetDS4Values["DS4_BUTTON_SHARE"] = HID_DS4_BUTTON_SHARE;
presetDS4Values["DS4_BUTTON_OPTIONS"] = HID_DS4_BUTTON_OPTIONS;
presetDS4Values["DS4_BUTTON_DPAD_TYPE"] = HID_DS4_BUTTON_DPAD_TYPE;
presetDS4Values["DS4_BUTTON_SHARE"] = HID_DS4_BUTTON_SHARE;
presetDS4Values["DS4_BUTTON_OPTIONS"] = HID_DS4_BUTTON_OPTIONS;
presetDS4Values["DS4_BUTTON_DPAD_TYPE"] = HID_DS4_BUTTON_DPAD_TYPE;
presetDS4Values["DS4_BUTTON_DPAD_N"] = HID_DS4_BUTTON_DPAD_N;
presetDS4Values["DS4_BUTTON_DPAD_NE"] = HID_DS4_BUTTON_DPAD_NE;
presetDS4Values["DS4_BUTTON_DPAD_E"] = HID_DS4_BUTTON_DPAD_E;
presetDS4Values["DS4_BUTTON_DPAD_SE"] = HID_DS4_BUTTON_DPAD_SE;
presetDS4Values["DS4_BUTTON_DPAD_S"] = HID_DS4_BUTTON_DPAD_S;
presetDS4Values["DS4_BUTTON_DPAD_SW"] = HID_DS4_BUTTON_DPAD_SW;
presetDS4Values["DS4_BUTTON_DPAD_W"] = HID_DS4_BUTTON_DPAD_W;
presetDS4Values["DS4_BUTTON_DPAD_NW"] = HID_DS4_BUTTON_DPAD_NW;
presetDS4Values["DS4_BUTTON_DPAD_NEUTRAL"] = HID_DS4_BUTTON_DPAD_NEUTRAL;
presetDS4Values["DS4_BUTTON_DPAD_N"] = HID_DS4_BUTTON_DPAD_N;
presetDS4Values["DS4_BUTTON_DPAD_NE"] = HID_DS4_BUTTON_DPAD_NE;
presetDS4Values["DS4_BUTTON_DPAD_E"] = HID_DS4_BUTTON_DPAD_E;
presetDS4Values["DS4_BUTTON_DPAD_SE"] = HID_DS4_BUTTON_DPAD_SE;
presetDS4Values["DS4_BUTTON_DPAD_S"] = HID_DS4_BUTTON_DPAD_S;
presetDS4Values["DS4_BUTTON_DPAD_SW"] = HID_DS4_BUTTON_DPAD_SW;
presetDS4Values["DS4_BUTTON_DPAD_W"] = HID_DS4_BUTTON_DPAD_W;
presetDS4Values["DS4_BUTTON_DPAD_NW"] = HID_DS4_BUTTON_DPAD_NW;
presetDS4Values["DS4_BUTTON_DPAD_NEUTRAL"] = HID_DS4_BUTTON_DPAD_NEUTRAL;
presetDS4Values["DS4_BUTTON_GUIDE"] = HID_DS4_BUTTON_GUIDE;
presetDS4Values["DS4_BUTTON_T_PAD_CLICK"] = HID_DS4_BUTTON_T_PAD_CLICK;
presetDS4Values["DS4_BUTTON_GUIDE"] = HID_DS4_BUTTON_GUIDE;
presetDS4Values["DS4_BUTTON_T_PAD_CLICK"] = HID_DS4_BUTTON_T_PAD_CLICK;
presetXInputValues["XINPUT_BUTTON_A"] = HID_XINPUT_BUTTON_A;
presetXInputValues["XINPUT_BUTTON_B"] = HID_XINPUT_BUTTON_B;
presetXInputValues["XINPUT_BUTTON_X"] = HID_XINPUT_BUTTON_X;
presetXInputValues["XINPUT_BUTTON_Y"] = HID_XINPUT_BUTTON_Y;
presetXInputValues["XINPUT_BUTTON_A"] = HID_XINPUT_BUTTON_A;
presetXInputValues["XINPUT_BUTTON_B"] = HID_XINPUT_BUTTON_B;
presetXInputValues["XINPUT_BUTTON_X"] = HID_XINPUT_BUTTON_X;
presetXInputValues["XINPUT_BUTTON_Y"] = HID_XINPUT_BUTTON_Y;
presetXInputValues["XINPUT_BUTTON_LB"] = HID_XINPUT_BUTTON_LB;
presetXInputValues["XINPUT_BUTTON_LT"] = HID_XINPUT_BUTTON_LT;
presetXInputValues["XINPUT_BUTTON_L3"] = HID_XINPUT_BUTTON_L3;
presetXInputValues["XINPUT_BUTTON_RB"] = HID_XINPUT_BUTTON_RB;
presetXInputValues["XINPUT_BUTTON_RT"] = HID_XINPUT_BUTTON_RT;
presetXInputValues["XINPUT_BUTTON_R3"] = HID_XINPUT_BUTTON_R3;
presetXInputValues["XINPUT_BUTTON_LB"] = HID_XINPUT_BUTTON_LB;
presetXInputValues["XINPUT_BUTTON_LT"] = HID_XINPUT_BUTTON_LT;
presetXInputValues["XINPUT_BUTTON_L3"] = HID_XINPUT_BUTTON_L3;
presetXInputValues["XINPUT_BUTTON_RB"] = HID_XINPUT_BUTTON_RB;
presetXInputValues["XINPUT_BUTTON_RT"] = HID_XINPUT_BUTTON_RT;
presetXInputValues["XINPUT_BUTTON_R3"] = HID_XINPUT_BUTTON_R3;
presetXInputValues["XINPUT_BUTTON_START"] = HID_XINPUT_BUTTON_START;
presetXInputValues["XINPUT_BUTTON_BACK"] = HID_XINPUT_BUTTON_BACK;
presetXInputValues["XINPUT_BUTTON_DPAD_TYPE"] = HID_XINPUT_BUTTON_DPAD_TYPE;
presetXInputValues["XINPUT_BUTTON_START"] = HID_XINPUT_BUTTON_START;
presetXInputValues["XINPUT_BUTTON_BACK"] = HID_XINPUT_BUTTON_BACK;
presetXInputValues["XINPUT_BUTTON_DPAD_TYPE"] = HID_XINPUT_BUTTON_DPAD_TYPE;
presetXInputValues["XINPUT_BUTTON_DPAD_UP"] = HID_XINPUT_BUTTON_UP;
presetXInputValues["XINPUT_BUTTON_DPAD_DOWN"] = HID_XINPUT_BUTTON_DOWN;
presetXInputValues["XINPUT_BUTTON_DPAD_LEFT"] = HID_XINPUT_BUTTON_LEFT;
presetXInputValues["XINPUT_BUTTON_DPAD_RIGHT"] = HID_XINPUT_BUTTON_RIGHT;
presetXInputValues["XINPUT_BUTTON_DPAD_UP"] = HID_XINPUT_BUTTON_UP;
presetXInputValues["XINPUT_BUTTON_DPAD_DOWN"] = HID_XINPUT_BUTTON_DOWN;
presetXInputValues["XINPUT_BUTTON_DPAD_LEFT"] = HID_XINPUT_BUTTON_LEFT;
presetXInputValues["XINPUT_BUTTON_DPAD_RIGHT"] = HID_XINPUT_BUTTON_RIGHT;
presetXInputValues["XINPUT_BUTTON_GUIDE"] = HID_XINPUT_BUTTON_GUIDE;
presetXInputValues["XINPUT_BUTTON_GUIDE"] = HID_XINPUT_BUTTON_GUIDE;
presetSwitchProValues["SWITCH_PRO_BUTTON_A"] = HID_SWITCH_PRO_BT_BUTTON_A;
presetSwitchProValues["SWITCH_PRO_BUTTON_B"] = HID_SWITCH_PRO_BT_BUTTON_B;
presetSwitchProValues["SWITCH_PRO_BUTTON_X"] = HID_SWITCH_PRO_BT_BUTTON_X;
presetSwitchProValues["SWITCH_PRO_BUTTON_Y"] = HID_SWITCH_PRO_BT_BUTTON_Y;
presetSwitchProValues["SWITCH_PRO_BUTTON_A"] = HID_SWITCH_PRO_BT_BUTTON_A;
presetSwitchProValues["SWITCH_PRO_BUTTON_B"] = HID_SWITCH_PRO_BT_BUTTON_B;
presetSwitchProValues["SWITCH_PRO_BUTTON_X"] = HID_SWITCH_PRO_BT_BUTTON_X;
presetSwitchProValues["SWITCH_PRO_BUTTON_Y"] = HID_SWITCH_PRO_BT_BUTTON_Y;
presetSwitchProValues["SWITCH_PRO_BUTTON_PLUS"] = HID_SWITCH_PRO_BT_BUTTON_PLUS;
presetSwitchProValues["SWITCH_PRO_BUTTON_MINUS"] = HID_SWITCH_PRO_BT_BUTTON_MINUS;
presetSwitchProValues["SWITCH_PRO_BUTTON_HOME"] = HID_SWITCH_PRO_BT_BUTTON_HOME;
presetSwitchProValues["SWITCH_PRO_BUTTON_PLUS"] = HID_SWITCH_PRO_BT_BUTTON_PLUS;
presetSwitchProValues["SWITCH_PRO_BUTTON_MINUS"] = HID_SWITCH_PRO_BT_BUTTON_MINUS;
presetSwitchProValues["SWITCH_PRO_BUTTON_HOME"] = HID_SWITCH_PRO_BT_BUTTON_HOME;
presetSwitchProValues["SWITCH_PRO_BUTTON_L"] = HID_SWITCH_PRO_BT_BUTTON_L;
presetSwitchProValues["SWITCH_PRO_BUTTON_R"] = HID_SWITCH_PRO_BT_BUTTON_R;
presetSwitchProValues["SWITCH_PRO_BUTTON_L"] = HID_SWITCH_PRO_BT_BUTTON_L;
presetSwitchProValues["SWITCH_PRO_BUTTON_R"] = HID_SWITCH_PRO_BT_BUTTON_R;
presetSwitchProValues["SWITCH_PRO_BUTTON_ZL"] = HID_SWITCH_PRO_BT_BUTTON_ZL;
presetSwitchProValues["SWITCH_PRO_BUTTON_ZR"] = HID_SWITCH_PRO_BT_BUTTON_ZR;
presetSwitchProValues["SWITCH_PRO_BUTTON_ZL"] = HID_SWITCH_PRO_BT_BUTTON_ZL;
presetSwitchProValues["SWITCH_PRO_BUTTON_ZR"] = HID_SWITCH_PRO_BT_BUTTON_ZR;
presetSwitchProValues["SWITCH_PRO_BUTTON_STICK_L"] = HID_SWITCH_PRO_BT_BUTTON_STICK_L;
presetSwitchProValues["SWITCH_PRO_BUTTON_STICK_R"] = HID_SWITCH_PRO_BT_BUTTON_STICK_R;
presetSwitchProValues["SWITCH_PRO_BUTTON_STICK_L"] = HID_SWITCH_PRO_BT_BUTTON_STICK_L;
presetSwitchProValues["SWITCH_PRO_BUTTON_STICK_R"] = HID_SWITCH_PRO_BT_BUTTON_STICK_R;
presetSwitchProValues["SWITCH_PRO_BUTTON_DPAD_N"] = HID_SWITCH_PRO_BT_BUTTON_DPAD_N;
presetSwitchProValues["SWITCH_PRO_BUTTON_DPAD_NE"] = HID_SWITCH_PRO_BT_BUTTON_DPAD_NE;
presetSwitchProValues["SWITCH_PRO_BUTTON_DPAD_E"] = HID_SWITCH_PRO_BT_BUTTON_DPAD_E;
presetSwitchProValues["SWITCH_PRO_BUTTON_DPAD_SE"] = HID_SWITCH_PRO_BT_BUTTON_DPAD_SE;
presetSwitchProValues["SWITCH_PRO_BUTTON_DPAD_S"] = HID_SWITCH_PRO_BT_BUTTON_DPAD_S;
presetSwitchProValues["SWITCH_PRO_BUTTON_DPAD_SW"] = HID_SWITCH_PRO_BT_BUTTON_DPAD_SW;
presetSwitchProValues["SWITCH_PRO_BUTTON_DPAD_W"] = HID_SWITCH_PRO_BT_BUTTON_DPAD_W;
presetSwitchProValues["SWITCH_PRO_BUTTON_DPAD_NW"] = HID_SWITCH_PRO_BT_BUTTON_DPAD_NW;
presetSwitchProValues["SWITCH_PRO_BUTTON_DPAD_NEUTRAL"] = HID_SWITCH_PRO_BT_BUTTON_DPAD_NEUTRAL;
presetSwitchProValues["SWITCH_PRO_BUTTON_DPAD_N"] = HID_SWITCH_PRO_BT_BUTTON_DPAD_N;
presetSwitchProValues["SWITCH_PRO_BUTTON_DPAD_NE"] = HID_SWITCH_PRO_BT_BUTTON_DPAD_NE;
presetSwitchProValues["SWITCH_PRO_BUTTON_DPAD_E"] = HID_SWITCH_PRO_BT_BUTTON_DPAD_E;
presetSwitchProValues["SWITCH_PRO_BUTTON_DPAD_SE"] = HID_SWITCH_PRO_BT_BUTTON_DPAD_SE;
presetSwitchProValues["SWITCH_PRO_BUTTON_DPAD_S"] = HID_SWITCH_PRO_BT_BUTTON_DPAD_S;
presetSwitchProValues["SWITCH_PRO_BUTTON_DPAD_SW"] = HID_SWITCH_PRO_BT_BUTTON_DPAD_SW;
presetSwitchProValues["SWITCH_PRO_BUTTON_DPAD_W"] = HID_SWITCH_PRO_BT_BUTTON_DPAD_W;
presetSwitchProValues["SWITCH_PRO_BUTTON_DPAD_NW"] = HID_SWITCH_PRO_BT_BUTTON_DPAD_NW;
presetSwitchProValues["SWITCH_PRO_BUTTON_DPAD_NEUTRAL"] = HID_SWITCH_PRO_BT_BUTTON_DPAD_NEUTRAL;
presetKeyboardValues["KEYBOARD_SHIFT"] = HID_KEYBOARD_BUTTON_SHIFT;
presetKeyboardValues["KEYBOARD_A"] = HID_KEYBOARD_BUTTON_A;
presetKeyboardValues["KEYBOARD_B"] = HID_KEYBOARD_BUTTON_B;
presetKeyboardValues["KEYBOARD_C"] = HID_KEYBOARD_BUTTON_C;
presetKeyboardValues["KEYBOARD_D"] = HID_KEYBOARD_BUTTON_D;
presetKeyboardValues["KEYBOARD_E"] = HID_KEYBOARD_BUTTON_E;
presetKeyboardValues["KEYBOARD_F"] = HID_KEYBOARD_BUTTON_F;
presetKeyboardValues["KEYBOARD_G"] = HID_KEYBOARD_BUTTON_G;
presetKeyboardValues["KEYBOARD_H"] = HID_KEYBOARD_BUTTON_H;
presetKeyboardValues["KEYBOARD_I"] = HID_KEYBOARD_BUTTON_I;
presetKeyboardValues["KEYBOARD_J"] = HID_KEYBOARD_BUTTON_J;
presetKeyboardValues["KEYBOARD_K"] = HID_KEYBOARD_BUTTON_K;
presetKeyboardValues["KEYBOARD_L"] = HID_KEYBOARD_BUTTON_L;
presetKeyboardValues["KEYBOARD_M"] = HID_KEYBOARD_BUTTON_M;
presetKeyboardValues["KEYBOARD_N"] = HID_KEYBOARD_BUTTON_N;
presetKeyboardValues["KEYBOARD_O"] = HID_KEYBOARD_BUTTON_O;
presetKeyboardValues["KEYBOARD_P"] = HID_KEYBOARD_BUTTON_P;
presetKeyboardValues["KEYBOARD_Q"] = HID_KEYBOARD_BUTTON_Q;
presetKeyboardValues["KEYBOARD_R"] = HID_KEYBOARD_BUTTON_R;
presetKeyboardValues["KEYBOARD_S"] = HID_KEYBOARD_BUTTON_S;
presetKeyboardValues["KEYBOARD_T"] = HID_KEYBOARD_BUTTON_T;
presetKeyboardValues["KEYBOARD_U"] = HID_KEYBOARD_BUTTON_U;
presetKeyboardValues["KEYBOARD_V"] = HID_KEYBOARD_BUTTON_V;
presetKeyboardValues["KEYBOARD_W"] = HID_KEYBOARD_BUTTON_W;
presetKeyboardValues["KEYBOARD_X"] = HID_KEYBOARD_BUTTON_X;
presetKeyboardValues["KEYBOARD_Y"] = HID_KEYBOARD_BUTTON_Y;
presetKeyboardValues["KEYBOARD_Z"] = HID_KEYBOARD_BUTTON_Z;
presetKeyboardValues["KEYBOARD_F1"] = HID_KEYBOARD_BUTTON_F1;
presetKeyboardValues["KEYBOARD_F2"] = HID_KEYBOARD_BUTTON_F2;
presetKeyboardValues["KEYBOARD_F3"] = HID_KEYBOARD_BUTTON_F3;
presetKeyboardValues["KEYBOARD_F4"] = HID_KEYBOARD_BUTTON_F4;
presetKeyboardValues["KEYBOARD_F5"] = HID_KEYBOARD_BUTTON_F5;
presetKeyboardValues["KEYBOARD_F6"] = HID_KEYBOARD_BUTTON_F6;
presetKeyboardValues["KEYBOARD_F7"] = HID_KEYBOARD_BUTTON_F7;
presetKeyboardValues["KEYBOARD_F8"] = HID_KEYBOARD_BUTTON_F8;
presetKeyboardValues["KEYBOARD_F9"] = HID_KEYBOARD_BUTTON_F9;
presetKeyboardValues["KEYBOARD_F10"] = HID_KEYBOARD_BUTTON_F10;
presetKeyboardValues["KEYBOARD_F11"] = HID_KEYBOARD_BUTTON_F11;
presetKeyboardValues["KEYBOARD_F12"] = HID_KEYBOARD_BUTTON_F12;
presetKeyboardValues["KEYBOARD_1"] = HID_KEYBOARD_BUTTON_1;
presetKeyboardValues["KEYBOARD_2"] = HID_KEYBOARD_BUTTON_2;
presetKeyboardValues["KEYBOARD_3"] = HID_KEYBOARD_BUTTON_3;
presetKeyboardValues["KEYBOARD_4"] = HID_KEYBOARD_BUTTON_4;
presetKeyboardValues["KEYBOARD_5"] = HID_KEYBOARD_BUTTON_5;
presetKeyboardValues["KEYBOARD_6"] = HID_KEYBOARD_BUTTON_6;
presetKeyboardValues["KEYBOARD_7"] = HID_KEYBOARD_BUTTON_7;
presetKeyboardValues["KEYBOARD_8"] = HID_KEYBOARD_BUTTON_8;
presetKeyboardValues["KEYBOARD_9"] = HID_KEYBOARD_BUTTON_9;
presetKeyboardValues["KEYBOARD_0"] = HID_KEYBOARD_BUTTON_0;
presetKeyboardValues["KEYBOARD_SHIFT"] = HID_KEYBOARD_BUTTON_SHIFT;
presetKeyboardValues["KEYBOARD_A"] = HID_KEYBOARD_BUTTON_A;
presetKeyboardValues["KEYBOARD_B"] = HID_KEYBOARD_BUTTON_B;
presetKeyboardValues["KEYBOARD_C"] = HID_KEYBOARD_BUTTON_C;
presetKeyboardValues["KEYBOARD_D"] = HID_KEYBOARD_BUTTON_D;
presetKeyboardValues["KEYBOARD_E"] = HID_KEYBOARD_BUTTON_E;
presetKeyboardValues["KEYBOARD_F"] = HID_KEYBOARD_BUTTON_F;
presetKeyboardValues["KEYBOARD_G"] = HID_KEYBOARD_BUTTON_G;
presetKeyboardValues["KEYBOARD_H"] = HID_KEYBOARD_BUTTON_H;
presetKeyboardValues["KEYBOARD_I"] = HID_KEYBOARD_BUTTON_I;
presetKeyboardValues["KEYBOARD_J"] = HID_KEYBOARD_BUTTON_J;
presetKeyboardValues["KEYBOARD_K"] = HID_KEYBOARD_BUTTON_K;
presetKeyboardValues["KEYBOARD_L"] = HID_KEYBOARD_BUTTON_L;
presetKeyboardValues["KEYBOARD_M"] = HID_KEYBOARD_BUTTON_M;
presetKeyboardValues["KEYBOARD_N"] = HID_KEYBOARD_BUTTON_N;
presetKeyboardValues["KEYBOARD_O"] = HID_KEYBOARD_BUTTON_O;
presetKeyboardValues["KEYBOARD_P"] = HID_KEYBOARD_BUTTON_P;
presetKeyboardValues["KEYBOARD_Q"] = HID_KEYBOARD_BUTTON_Q;
presetKeyboardValues["KEYBOARD_R"] = HID_KEYBOARD_BUTTON_R;
presetKeyboardValues["KEYBOARD_S"] = HID_KEYBOARD_BUTTON_S;
presetKeyboardValues["KEYBOARD_T"] = HID_KEYBOARD_BUTTON_T;
presetKeyboardValues["KEYBOARD_U"] = HID_KEYBOARD_BUTTON_U;
presetKeyboardValues["KEYBOARD_V"] = HID_KEYBOARD_BUTTON_V;
presetKeyboardValues["KEYBOARD_W"] = HID_KEYBOARD_BUTTON_W;
presetKeyboardValues["KEYBOARD_X"] = HID_KEYBOARD_BUTTON_X;
presetKeyboardValues["KEYBOARD_Y"] = HID_KEYBOARD_BUTTON_Y;
presetKeyboardValues["KEYBOARD_Z"] = HID_KEYBOARD_BUTTON_Z;
presetKeyboardValues["KEYBOARD_F1"] = HID_KEYBOARD_BUTTON_F1;
presetKeyboardValues["KEYBOARD_F2"] = HID_KEYBOARD_BUTTON_F2;
presetKeyboardValues["KEYBOARD_F3"] = HID_KEYBOARD_BUTTON_F3;
presetKeyboardValues["KEYBOARD_F4"] = HID_KEYBOARD_BUTTON_F4;
presetKeyboardValues["KEYBOARD_F5"] = HID_KEYBOARD_BUTTON_F5;
presetKeyboardValues["KEYBOARD_F6"] = HID_KEYBOARD_BUTTON_F6;
presetKeyboardValues["KEYBOARD_F7"] = HID_KEYBOARD_BUTTON_F7;
presetKeyboardValues["KEYBOARD_F8"] = HID_KEYBOARD_BUTTON_F8;
presetKeyboardValues["KEYBOARD_F9"] = HID_KEYBOARD_BUTTON_F9;
presetKeyboardValues["KEYBOARD_F10"] = HID_KEYBOARD_BUTTON_F10;
presetKeyboardValues["KEYBOARD_F11"] = HID_KEYBOARD_BUTTON_F11;
presetKeyboardValues["KEYBOARD_F12"] = HID_KEYBOARD_BUTTON_F12;
presetKeyboardValues["KEYBOARD_1"] = HID_KEYBOARD_BUTTON_1;
presetKeyboardValues["KEYBOARD_2"] = HID_KEYBOARD_BUTTON_2;
presetKeyboardValues["KEYBOARD_3"] = HID_KEYBOARD_BUTTON_3;
presetKeyboardValues["KEYBOARD_4"] = HID_KEYBOARD_BUTTON_4;
presetKeyboardValues["KEYBOARD_5"] = HID_KEYBOARD_BUTTON_5;
presetKeyboardValues["KEYBOARD_6"] = HID_KEYBOARD_BUTTON_6;
presetKeyboardValues["KEYBOARD_7"] = HID_KEYBOARD_BUTTON_7;
presetKeyboardValues["KEYBOARD_8"] = HID_KEYBOARD_BUTTON_8;
presetKeyboardValues["KEYBOARD_9"] = HID_KEYBOARD_BUTTON_9;
presetKeyboardValues["KEYBOARD_0"] = HID_KEYBOARD_BUTTON_0;
presetKeyboardValues["KEYBOARD_RETURN"] = HID_KEYBOARD_BUTTON_RETURN;
presetKeyboardValues["KEYBOARD_ESCAPE"] = HID_KEYBOARD_BUTTON_ESCAPE;
presetKeyboardValues["KEYBOARD_DELETE"] = HID_KEYBOARD_BUTTON_DELETE;
presetKeyboardValues["KEYBOARD_TAB"] = HID_KEYBOARD_BUTTON_TAB;
presetKeyboardValues["KEYBOARD_SPACEBAR"] = HID_KEYBOARD_BUTTON_SPACEBAR;
presetKeyboardValues["KEYBOARD_CAPSLOCK"] = HID_KEYBOARD_BUTTON_CAPSLOCK;
presetKeyboardValues["KEYBOARD_PRINTSCREEN"] = HID_KEYBOARD_BUTTON_PRINTSCREEN;
presetKeyboardValues["KEYBOARD_SCROLLLOCK"] = HID_KEYBOARD_BUTTON_SCROLLLOCK;
presetKeyboardValues["KEYBOARD_PAUSE"] = HID_KEYBOARD_BUTTON_PAUSE;
presetKeyboardValues["KEYBOARD_INSERT"] = HID_KEYBOARD_BUTTON_INSERT;
presetKeyboardValues["KEYBOARD_HOME"] = HID_KEYBOARD_BUTTON_HOME;
presetKeyboardValues["KEYBOARD_PAGEUP"] = HID_KEYBOARD_BUTTON_PAGEUP;
presetKeyboardValues["KEYBOARD_PAGEDOWN"] = HID_KEYBOARD_BUTTON_PAGEDOWN;
presetKeyboardValues["KEYBOARD_DELETEFORWARD"] = HID_KEYBOARD_BUTTON_DELETEFORWARD;
presetKeyboardValues["KEYBOARD_LEFT_CONTROL"] = HID_KEYBOARD_BUTTON_LEFT_CONTROL;
presetKeyboardValues["KEYBOARD_LEFT_ALT"] = HID_KEYBOARD_BUTTON_LEFT_ALT;
presetKeyboardValues["KEYBOARD_RIGHT_CONTROL"] = HID_KEYBOARD_BUTTON_RIGHT_CONTROL;
presetKeyboardValues["KEYBOARD_RIGHT_SHIFT"] = HID_KEYBOARD_BUTTON_RIGHT_SHIFT;
presetKeyboardValues["KEYBOARD_RIGHT_ALT"] = HID_KEYBOARD_BUTTON_RIGHT_ALT;
presetKeyboardValues["KEYBOARD_END"] = HID_KEYBOARD_BUTTON_END;
presetKeyboardValues["KEYBOARD_RETURN"] = HID_KEYBOARD_BUTTON_RETURN;
presetKeyboardValues["KEYBOARD_ESCAPE"] = HID_KEYBOARD_BUTTON_ESCAPE;
presetKeyboardValues["KEYBOARD_DELETE"] = HID_KEYBOARD_BUTTON_DELETE;
presetKeyboardValues["KEYBOARD_TAB"] = HID_KEYBOARD_BUTTON_TAB;
presetKeyboardValues["KEYBOARD_SPACEBAR"] = HID_KEYBOARD_BUTTON_SPACEBAR;
presetKeyboardValues["KEYBOARD_CAPSLOCK"] = HID_KEYBOARD_BUTTON_CAPSLOCK;
presetKeyboardValues["KEYBOARD_PRINTSCREEN"] = HID_KEYBOARD_BUTTON_PRINTSCREEN;
presetKeyboardValues["KEYBOARD_SCROLLLOCK"] = HID_KEYBOARD_BUTTON_SCROLLLOCK;
presetKeyboardValues["KEYBOARD_PAUSE"] = HID_KEYBOARD_BUTTON_PAUSE;
presetKeyboardValues["KEYBOARD_INSERT"] = HID_KEYBOARD_BUTTON_INSERT;
presetKeyboardValues["KEYBOARD_HOME"] = HID_KEYBOARD_BUTTON_HOME;
presetKeyboardValues["KEYBOARD_PAGEUP"] = HID_KEYBOARD_BUTTON_PAGEUP;
presetKeyboardValues["KEYBOARD_PAGEDOWN"] = HID_KEYBOARD_BUTTON_PAGEDOWN;
presetKeyboardValues["KEYBOARD_DELETEFORWARD"] = HID_KEYBOARD_BUTTON_DELETEFORWARD;
presetKeyboardValues["KEYBOARD_LEFT_CONTROL"] = HID_KEYBOARD_BUTTON_LEFT_CONTROL;
presetKeyboardValues["KEYBOARD_LEFT_ALT"] = HID_KEYBOARD_BUTTON_LEFT_ALT;
presetKeyboardValues["KEYBOARD_RIGHT_CONTROL"] = HID_KEYBOARD_BUTTON_RIGHT_CONTROL;
presetKeyboardValues["KEYBOARD_RIGHT_SHIFT"] = HID_KEYBOARD_BUTTON_RIGHT_SHIFT;
presetKeyboardValues["KEYBOARD_RIGHT_ALT"] = HID_KEYBOARD_BUTTON_RIGHT_ALT;
presetKeyboardValues["KEYBOARD_END"] = HID_KEYBOARD_BUTTON_END;
presetKeyboardValues["KEYBOARD_LEFT"] = HID_KEYBOARD_BUTTON_LEFT;
presetKeyboardValues["KEYBOARD_RIGHT"] = HID_KEYBOARD_BUTTON_RIGHT;
presetKeyboardValues["KEYBOARD_DOWN"] = HID_KEYBOARD_BUTTON_DOWN;
presetKeyboardValues["KEYBOARD_UP"] = HID_KEYBOARD_BUTTON_UP;
presetKeyboardValues["KEYBOARD_LEFT"] = HID_KEYBOARD_BUTTON_LEFT;
presetKeyboardValues["KEYBOARD_RIGHT"] = HID_KEYBOARD_BUTTON_RIGHT;
presetKeyboardValues["KEYBOARD_DOWN"] = HID_KEYBOARD_BUTTON_DOWN;
presetKeyboardValues["KEYBOARD_UP"] = HID_KEYBOARD_BUTTON_UP;
presetKeyboardValues["KEYBOARD_KEYPAD_1"] = HID_KEYBOARD_KEYPAD_BUTTON_1;
presetKeyboardValues["KEYBOARD_KEYPAD_2"] = HID_KEYBOARD_KEYPAD_BUTTON_2;
presetKeyboardValues["KEYBOARD_KEYPAD_3"] = HID_KEYBOARD_KEYPAD_BUTTON_3;
presetKeyboardValues["KEYBOARD_KEYPAD_4"] = HID_KEYBOARD_KEYPAD_BUTTON_4;
presetKeyboardValues["KEYBOARD_KEYPAD_5"] = HID_KEYBOARD_KEYPAD_BUTTON_5;
presetKeyboardValues["KEYBOARD_KEYPAD_6"] = HID_KEYBOARD_KEYPAD_BUTTON_6;
presetKeyboardValues["KEYBOARD_KEYPAD_7"] = HID_KEYBOARD_KEYPAD_BUTTON_7;
presetKeyboardValues["KEYBOARD_KEYPAD_8"] = HID_KEYBOARD_KEYPAD_BUTTON_8;
presetKeyboardValues["KEYBOARD_KEYPAD_9"] = HID_KEYBOARD_KEYPAD_BUTTON_9;
presetKeyboardValues["KEYBOARD_KEYPAD_0"] = HID_KEYBOARD_KEYPAD_BUTTON_0;
presetKeyboardValues["KEYBOARD_KEYPAD_NUMLOCK"] = HID_KEYBOARD_KEYPAD_BUTTON_NUMLOCK;
presetKeyboardValues["KEYBOARD_KEYPAD_MINUS"] = HID_KEYBOARD_KEYPAD_BUTTON_MINUS;
presetKeyboardValues["KEYBOARD_KEYPAD_PLUS"] = HID_KEYBOARD_KEYPAD_BUTTON_PLUS;
presetKeyboardValues["KEYBOARD_KEYPAD_1"] = HID_KEYBOARD_KEYPAD_BUTTON_1;
presetKeyboardValues["KEYBOARD_KEYPAD_2"] = HID_KEYBOARD_KEYPAD_BUTTON_2;
presetKeyboardValues["KEYBOARD_KEYPAD_3"] = HID_KEYBOARD_KEYPAD_BUTTON_3;
presetKeyboardValues["KEYBOARD_KEYPAD_4"] = HID_KEYBOARD_KEYPAD_BUTTON_4;
presetKeyboardValues["KEYBOARD_KEYPAD_5"] = HID_KEYBOARD_KEYPAD_BUTTON_5;
presetKeyboardValues["KEYBOARD_KEYPAD_6"] = HID_KEYBOARD_KEYPAD_BUTTON_6;
presetKeyboardValues["KEYBOARD_KEYPAD_7"] = HID_KEYBOARD_KEYPAD_BUTTON_7;
presetKeyboardValues["KEYBOARD_KEYPAD_8"] = HID_KEYBOARD_KEYPAD_BUTTON_8;
presetKeyboardValues["KEYBOARD_KEYPAD_9"] = HID_KEYBOARD_KEYPAD_BUTTON_9;
presetKeyboardValues["KEYBOARD_KEYPAD_0"] = HID_KEYBOARD_KEYPAD_BUTTON_0;
presetKeyboardValues["KEYBOARD_KEYPAD_NUMLOCK"] = HID_KEYBOARD_KEYPAD_BUTTON_NUMLOCK;
presetKeyboardValues["KEYBOARD_KEYPAD_MINUS"] = HID_KEYBOARD_KEYPAD_BUTTON_MINUS;
presetKeyboardValues["KEYBOARD_KEYPAD_PLUS"] = HID_KEYBOARD_KEYPAD_BUTTON_PLUS;
presetValues["VPAD_L_STICK"] = DEF_L_STICK;
presetValues["VPAD_R_STICK"] = DEF_R_STICK;
presetValues["VPAD_L_STICK"] = DEF_L_STICK;
presetValues["VPAD_R_STICK"] = DEF_R_STICK;
presetValues["DPAD_NORMAL"] = CONTRPDM_Normal;
presetValues["DPAD_HAT"] = CONTRPDM_Hat;
presetValues["DPAD_ABSOLUTE_2VALUES"] = CONTRPDM_Absolute_2Values;
presetValues["TRUE"] = 1;
presetValues["YES"] = 1;
presetValues["ON"] = 1;
presetValues["FALSE"] = 0;
presetValues["NO"] = 0;
presetValues["OFF"] = 0;
presetValues["DPAD_NORMAL"] = CONTRPDM_Normal;
presetValues["DPAD_HAT"] = CONTRPDM_Hat;
presetValues["DPAD_ABSOLUTE_2VALUES"] = CONTRPDM_Absolute_2Values;
presetValues["TRUE"] = 1;
presetValues["YES"] = 1;
presetValues["ON"] = 1;
presetValues["FALSE"] = 0;
presetValues["NO"] = 0;
presetValues["OFF"] = 0;
presetSticks["GC_STICK_L_X"] = HID_GC_STICK_L_X;
presetSticks["GC_STICK_L_Y"] = HID_GC_STICK_L_Y;
presetSticks["GC_STICK_R_X"] = HID_GC_STICK_R_X;
presetSticks["GC_STICK_R_Y"] = HID_GC_STICK_R_Y;
presetSticks["GC_STICK_L_X"] = HID_GC_STICK_L_X;
presetSticks["GC_STICK_L_Y"] = HID_GC_STICK_L_Y;
presetSticks["GC_STICK_R_X"] = HID_GC_STICK_R_X;
presetSticks["GC_STICK_R_Y"] = HID_GC_STICK_R_Y;
presetSticks["DS3_STICK_L_X"] = HID_DS3_STICK_L_X;
presetSticks["DS3_STICK_L_Y"] = HID_DS3_STICK_L_Y;
presetSticks["DS3_STICK_R_X"] = HID_DS3_STICK_R_X;
presetSticks["DS3_STICK_R_Y"] = HID_DS3_STICK_R_Y;
presetSticks["DS3_STICK_L_X"] = HID_DS3_STICK_L_X;
presetSticks["DS3_STICK_L_Y"] = HID_DS3_STICK_L_Y;
presetSticks["DS3_STICK_R_X"] = HID_DS3_STICK_R_X;
presetSticks["DS3_STICK_R_Y"] = HID_DS3_STICK_R_Y;
presetSticks["DS4_STICK_L_X"] = HID_DS4_STICK_L_X;
presetSticks["DS4_STICK_L_Y"] = HID_DS4_STICK_L_Y;
presetSticks["DS4_STICK_R_X"] = HID_DS4_STICK_R_X;
presetSticks["DS4_STICK_R_Y"] = HID_DS4_STICK_R_Y;
presetSticks["DS4_STICK_L_X"] = HID_DS4_STICK_L_X;
presetSticks["DS4_STICK_L_Y"] = HID_DS4_STICK_L_Y;
presetSticks["DS4_STICK_R_X"] = HID_DS4_STICK_R_X;
presetSticks["DS4_STICK_R_Y"] = HID_DS4_STICK_R_Y;
presetSticks["XINPUT_STICK_L_X"] = HID_XINPUT_STICK_L_X;
presetSticks["XINPUT_STICK_L_Y"] = HID_XINPUT_STICK_L_Y;
presetSticks["XINPUT_STICK_R_X"] = HID_XINPUT_STICK_R_X;
presetSticks["XINPUT_STICK_R_Y"] = HID_XINPUT_STICK_R_Y;
presetSticks["XINPUT_STICK_L_X"] = HID_XINPUT_STICK_L_X;
presetSticks["XINPUT_STICK_L_Y"] = HID_XINPUT_STICK_L_Y;
presetSticks["XINPUT_STICK_R_X"] = HID_XINPUT_STICK_R_X;
presetSticks["XINPUT_STICK_R_Y"] = HID_XINPUT_STICK_R_Y;
presetSticks["SWITCH_PRO_STICK_L_X"] = HID_SWITCH_PRO_BT_STICK_L_X;
presetSticks["SWITCH_PRO_STICK_L_Y"] = HID_SWITCH_PRO_BT_STICK_L_Y;
presetSticks["SWITCH_PRO_STICK_R_X"] = HID_SWITCH_PRO_BT_STICK_R_X;
presetSticks["SWITCH_PRO_STICK_R_Y"] = HID_SWITCH_PRO_BT_STICK_R_Y;
presetSticks["SWITCH_PRO_STICK_L_X"] = HID_SWITCH_PRO_BT_STICK_L_X;
presetSticks["SWITCH_PRO_STICK_L_Y"] = HID_SWITCH_PRO_BT_STICK_L_Y;
presetSticks["SWITCH_PRO_STICK_R_X"] = HID_SWITCH_PRO_BT_STICK_R_X;
presetSticks["SWITCH_PRO_STICK_R_Y"] = HID_SWITCH_PRO_BT_STICK_R_Y;
presetSticks["GC_DPAD_MODE"] = HID_GC_BUTTON_DPAD_TYPE;
presetSticks["DS3_DPAD_MODE"] = HID_DS3_BUTTON_DPAD_TYPE;
presetSticks["DS4_DPAD_MODE"] = HID_DS4_BUTTON_DPAD_TYPE;
presetSticks["XINPUT_DPAD_MODE"] = HID_XINPUT_BUTTON_DPAD_TYPE;
presetSticks["SWITCH_PRO_DPAD_MODE"] = HID_SWITCH_PRO_BT_BUTTON_DPAD_TYPE;
presetSticks["GC_DPAD_MODE"] = HID_GC_BUTTON_DPAD_TYPE;
presetSticks["DS3_DPAD_MODE"] = HID_DS3_BUTTON_DPAD_TYPE;
presetSticks["DS4_DPAD_MODE"] = HID_DS4_BUTTON_DPAD_TYPE;
presetSticks["XINPUT_DPAD_MODE"] = HID_XINPUT_BUTTON_DPAD_TYPE;
presetSticks["SWITCH_PRO_DPAD_MODE"] = HID_SWITCH_PRO_BT_BUTTON_DPAD_TYPE;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_A"] = CONTRPS_VPAD_BUTTON_A;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_B"] = CONTRPS_VPAD_BUTTON_B;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_X"] = CONTRPS_VPAD_BUTTON_X;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_Y"] = CONTRPS_VPAD_BUTTON_Y;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_LEFT"] = CONTRPS_VPAD_BUTTON_LEFT;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_RIGHT"] = CONTRPS_VPAD_BUTTON_RIGHT;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_UP"] = CONTRPS_VPAD_BUTTON_UP;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_DOWN"] = CONTRPS_VPAD_BUTTON_DOWN;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_ZL"] = CONTRPS_VPAD_BUTTON_ZL;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_ZR"] = CONTRPS_VPAD_BUTTON_ZR;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_L"] = CONTRPS_VPAD_BUTTON_L;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_R"] = CONTRPS_VPAD_BUTTON_R;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_PLUS"] = CONTRPS_VPAD_BUTTON_PLUS;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_MINUS"] = CONTRPS_VPAD_BUTTON_MINUS;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_HOME"] = CONTRPS_VPAD_BUTTON_HOME;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_SYNC"] = CONTRPS_VPAD_BUTTON_SYNC;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_STICK_R"] = CONTRPS_VPAD_BUTTON_STICK_R;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_STICK_L"] = CONTRPS_VPAD_BUTTON_STICK_L;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_TV"] = CONTRPS_VPAD_BUTTON_TV;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_A"] = CONTRPS_VPAD_BUTTON_A;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_B"] = CONTRPS_VPAD_BUTTON_B;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_X"] = CONTRPS_VPAD_BUTTON_X;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_Y"] = CONTRPS_VPAD_BUTTON_Y;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_LEFT"] = CONTRPS_VPAD_BUTTON_LEFT;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_RIGHT"] = CONTRPS_VPAD_BUTTON_RIGHT;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_UP"] = CONTRPS_VPAD_BUTTON_UP;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_DOWN"] = CONTRPS_VPAD_BUTTON_DOWN;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_ZL"] = CONTRPS_VPAD_BUTTON_ZL;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_ZR"] = CONTRPS_VPAD_BUTTON_ZR;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_L"] = CONTRPS_VPAD_BUTTON_L;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_R"] = CONTRPS_VPAD_BUTTON_R;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_PLUS"] = CONTRPS_VPAD_BUTTON_PLUS;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_MINUS"] = CONTRPS_VPAD_BUTTON_MINUS;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_HOME"] = CONTRPS_VPAD_BUTTON_HOME;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_SYNC"] = CONTRPS_VPAD_BUTTON_SYNC;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_STICK_R"] = CONTRPS_VPAD_BUTTON_STICK_R;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_STICK_L"] = CONTRPS_VPAD_BUTTON_STICK_L;
gGamePadValuesToCONTRPSString["VPAD_BUTTON_TV"] = CONTRPS_VPAD_BUTTON_TV;
gGamePadValuesToCONTRPSString["VPAD_STICK_R_EMULATION_LEFT"] = CONTRPS_VPAD_STICK_R_EMULATION_LEFT;
gGamePadValuesToCONTRPSString["VPAD_STICK_R_EMULATION_LEFT"] = CONTRPS_VPAD_STICK_R_EMULATION_LEFT;
gGamePadValuesToCONTRPSString["VPAD_STICK_R_EMULATION_RIGHT"] = CONTRPS_VPAD_STICK_R_EMULATION_RIGHT;
gGamePadValuesToCONTRPSString["VPAD_STICK_R_EMULATION_UP"] = CONTRPS_VPAD_STICK_R_EMULATION_UP;
gGamePadValuesToCONTRPSString["VPAD_STICK_R_EMULATION_DOWN"] = CONTRPS_VPAD_STICK_R_EMULATION_DOWN;
gGamePadValuesToCONTRPSString["VPAD_STICK_L_EMULATION_LEFT"] = CONTRPS_VPAD_STICK_L_EMULATION_LEFT;
gGamePadValuesToCONTRPSString["VPAD_STICK_R_EMULATION_UP"] = CONTRPS_VPAD_STICK_R_EMULATION_UP;
gGamePadValuesToCONTRPSString["VPAD_STICK_R_EMULATION_DOWN"] = CONTRPS_VPAD_STICK_R_EMULATION_DOWN;
gGamePadValuesToCONTRPSString["VPAD_STICK_L_EMULATION_LEFT"] = CONTRPS_VPAD_STICK_L_EMULATION_LEFT;
gGamePadValuesToCONTRPSString["VPAD_STICK_L_EMULATION_RIGHT"] = CONTRPS_VPAD_STICK_L_EMULATION_RIGHT;
gGamePadValuesToCONTRPSString["VPAD_STICK_L_EMULATION_UP"] = CONTRPS_VPAD_STICK_L_EMULATION_UP;
gGamePadValuesToCONTRPSString["VPAD_STICK_L_EMULATION_DOWN"] = CONTRPS_VPAD_STICK_L_EMULATION_DOWN;
gGamePadValuesToCONTRPSString["VPAD_STICK_L_EMULATION_UP"] = CONTRPS_VPAD_STICK_L_EMULATION_UP;
gGamePadValuesToCONTRPSString["VPAD_STICK_L_EMULATION_DOWN"] = CONTRPS_VPAD_STICK_L_EMULATION_DOWN;
deviceNames[StringTools::strfmt("%04X%04X",HID_GC_VID, HID_GC_PID).c_str()] = HID_GC_STRING;
deviceNames[StringTools::strfmt("%04X%04X",HID_KEYBOARD_VID, HID_KEYBOARD_PID).c_str()] = HID_KEYBOARD_STRING;
deviceNames[StringTools::strfmt("%04X%04X",HID_MOUSE_VID, HID_MOUSE_PID).c_str()] = HID_MOUSE_STRING;
deviceNames[StringTools::strfmt("%04X%04X",HID_DS3_VID, HID_DS3_PID).c_str()] = HID_DS3_STRING;
deviceNames[StringTools::strfmt("%04X%04X",HID_NEW_DS4_VID, HID_NEW_DS4_PID).c_str()] = HID_NEW_DS4_STRING;
deviceNames[StringTools::strfmt("%04X%04X",HID_DS4_VID, HID_DS4_PID).c_str()] = HID_DS4_STRING;
deviceNames[StringTools::strfmt("%04X%04X",HID_XINPUT_VID, HID_XINPUT_PID).c_str()] = HID_XINPUT_STRING;
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_GC_VID, HID_GC_PID).c_str()] = HID_GC_STRING;
deviceNames[StringTools::strfmt("%04X%04X", HID_KEYBOARD_VID, HID_KEYBOARD_PID).c_str()] = HID_KEYBOARD_STRING;
deviceNames[StringTools::strfmt("%04X%04X", HID_MOUSE_VID, HID_MOUSE_PID).c_str()] = HID_MOUSE_STRING;
deviceNames[StringTools::strfmt("%04X%04X", HID_DS3_VID, HID_DS3_PID).c_str()] = HID_DS3_STRING;
deviceNames[StringTools::strfmt("%04X%04X", HID_NEW_DS4_VID, HID_NEW_DS4_PID).c_str()] = HID_NEW_DS4_STRING;
deviceNames[StringTools::strfmt("%04X%04X", HID_DS4_VID, HID_DS4_PID).c_str()] = HID_DS4_STRING;
deviceNames[StringTools::strfmt("%04X%04X", HID_XINPUT_VID, HID_XINPUT_PID).c_str()] = HID_XINPUT_STRING;
deviceNames[StringTools::strfmt("%04X%04X", HID_SWITCH_PRO_VID, HID_SWITCH_PRO_PID).c_str()] = HID_SWITCH_PRO_STRING;
}
const uint8_t * getValuesForPreset(std::map<std::string,const uint8_t*> 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 uint8_t*> values,std::string possibleValue,int32_t slot,int32_t keyslot);
BOOL setIfValueIsAControllerPresetEx(std::string value,int32_t slot,int32_t 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, int32_t slot, int32_t keyslot);
void addDeviceNameEx(uint16_t vid,uint16_t pid,std::string value);
std::string getStringByVIDPIDEx(uint16_t vid,uint16_t pid);
void addDeviceNameEx(uint16_t vid, uint16_t pid, std::string value);
std::string getStringByVIDPIDEx(uint16_t vid, uint16_t pid);
};
#endif

18
source/fs/CFile.cpp
View File

@ -1,13 +1,13 @@
#include "CFile.hpp"
#include <stdarg.h>
#include <stdio.h>
#include <strings.h>
#include "CFile.hpp"
CFile::CFile() {
iFd = -1;
iFd = -1;
mem_file = NULL;
filesize = 0;
pos = 0;
pos = 0;
}
CFile::CFile(const std::string &filepath, eOpenTypes mode) {
@ -33,7 +33,7 @@ int32_t CFile::open(const std::string &filepath, eOpenTypes mode) {
switch (mode) {
default:
case ReadOnly: // file must exist
case ReadOnly: // file must exist
openMode = O_RDONLY;
break;
case WriteOnly: // file will be created / zerod
@ -75,10 +75,10 @@ void CFile::close() {
if (iFd >= 0)
::close(iFd);
iFd = -1;
iFd = -1;
mem_file = NULL;
filesize = 0;
pos = 0;
pos = 0;
}
int32_t CFile::read(uint8_t *ptr, size_t size) {
@ -125,7 +125,7 @@ int32_t CFile::write(const uint8_t *ptr, size_t size) {
}
int32_t CFile::seek(long int offset, int32_t origin) {
int32_t ret = 0;
int32_t ret = 0;
int64_t newPos = pos;
if (origin == SEEK_SET) {
@ -156,7 +156,7 @@ int32_t CFile::seek(long int offset, int32_t origin) {
int32_t CFile::fwrite(const char *format, ...) {
char tmp[512];
tmp[0] = 0;
tmp[0] = 0;
int32_t result = -1;
va_list va;
@ -169,5 +169,3 @@ int32_t CFile::fwrite(const char *format, ...) {
return result;
}

6
source/fs/CFile.hpp
View File

@ -1,10 +1,10 @@
#ifndef CFILE_HPP_
#define CFILE_HPP_
#include <stdio.h>
#include <string>
#include <string.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <string>
#include <unistd.h>
#include <wut_types.h>

19
source/fs/FSUtils.cpp
View File

@ -1,11 +1,11 @@
#include <malloc.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include "FSUtils.h"
#include "CFile.hpp"
#include "utils/logger.h"
#include <fcntl.h>
#include <malloc.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
int32_t FSUtils::LoadFileToMem(const char *filepath, uint8_t **inbuffer, uint32_t *size) {
//! always initialze input
@ -27,8 +27,8 @@ int32_t FSUtils::LoadFileToMem(const char *filepath, uint8_t **inbuffer, uint32_
}
uint32_t blocksize = 0x4000;
uint32_t done = 0;
int32_t readBytes = 0;
uint32_t done = 0;
int32_t readBytes = 0;
while (done < filesize) {
if (done + blocksize > filesize) {
@ -136,7 +136,7 @@ bool FSUtils::copyFile(const std::string &in, const std::string &out) {
size_t size;
int source = open(in.c_str(), O_RDONLY, 0);
int dest = open(out.c_str(), 0x602, 0644);
int dest = open(out.c_str(), 0x602, 0644);
if (source < 0) {
return false;
}
@ -146,7 +146,7 @@ bool FSUtils::copyFile(const std::string &in, const std::string &out) {
}
auto bufferSize = 1024 * 1024;
char *buf = (char *) malloc(bufferSize);
char *buf = (char *) malloc(bufferSize);
if (buf == NULL) {
return false;
}
@ -171,4 +171,3 @@ int32_t FSUtils::saveBufferToFile(const char *path, const void *buffer, uint32_t
file.close();
return written;
}

2
source/fs/FSUtils.h
View File

@ -1,7 +1,7 @@
#pragma once
#include <wut_types.h>
#include <string>
#include <wut_types.h>
class FSUtils {
public:

352
source/network/CPTCPServer.cpp
View File

@ -15,16 +15,16 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include "CPTCPServer.hpp"
#include <netinet/in.h>
#include <malloc.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <utils/logger.h>
CPTCPServer * CPTCPServer::instance = NULL;
CPTCPServer *CPTCPServer::instance = NULL;
CPTCPServer::CPTCPServer(int32_t port): TCPServer(port,CPTCPServer::getPriority()) {
CPTCPServer::CPTCPServer(int32_t port) : TCPServer(port, CPTCPServer::getPriority()) {
CPTCPServer::AttachDetach(HID_DEVICE_DETACH);
}
@ -33,34 +33,34 @@ CPTCPServer::~CPTCPServer() {
}
void CPTCPServer::AttachDetach(HIDAttachEvent attach) {
if(HID_DEBUG) {
if(attach) {
if (HID_DEBUG) {
if (attach) {
DEBUG_FUNCTION_LINE("Network Attach");
} else {
DEBUG_FUNCTION_LINE("Network Detach");
}
}
for(int32_t i= 0; i< gHIDMaxDevices; i++) {
for(int32_t j= 0; j< HID_MAX_PADS_COUNT; j++) {
if(gNetworkController[i][j][NETWORK_CONTROLLER_ACTIVE] > 0) {
DEBUG_FUNCTION_LINE("Found a registered pad in deviceslot %d and padslot %d! Lets detach it.",i,j);
for (int32_t i = 0; i < gHIDMaxDevices; i++) {
for (int32_t j = 0; j < HID_MAX_PADS_COUNT; j++) {
if (gNetworkController[i][j][NETWORK_CONTROLLER_ACTIVE] > 0) {
DEBUG_FUNCTION_LINE("Found a registered pad in deviceslot %d and padslot %d! Lets detach it.", i, j);
HIDDevice device;
memset(&device,0,sizeof(device));
memset(&device, 0, sizeof(device));
device.interfaceIndex = 0;
device.vid = gNetworkController[i][j][NETWORK_CONTROLLER_VID];
device.pid = gNetworkController[i][j][NETWORK_CONTROLLER_PID];
device.handle = gNetworkController[i][j][NETWORK_CONTROLLER_HANDLE];
device.interfaceIndex = 0;
device.vid = gNetworkController[i][j][NETWORK_CONTROLLER_VID];
device.pid = gNetworkController[i][j][NETWORK_CONTROLLER_PID];
device.handle = gNetworkController[i][j][NETWORK_CONTROLLER_HANDLE];
device.maxPacketSizeRx = 8;
ControllerPatcherHID::externAttachDetachCallback(&device,attach);
memset(gNetworkController[i][j],0,sizeof(gNetworkController[i][j]));
ControllerPatcherHID::externAttachDetachCallback(&device, attach);
memset(gNetworkController[i][j], 0, sizeof(gNetworkController[i][j]));
}
}
}
if(HID_DEBUG) {
if(attach) {
if (HID_DEBUG) {
if (attach) {
DEBUG_FUNCTION_LINE("Network Attach DONE!");
} else {
DEBUG_FUNCTION_LINE("Network Detach DONE!");
@ -70,19 +70,19 @@ void CPTCPServer::AttachDetach(HIDAttachEvent attach) {
void CPTCPServer::DetachAndDelete() {
CPTCPServer::AttachDetach(HID_DEVICE_DETACH);
memset(&gNetworkController,0,sizeof(gNetworkController));
memset(&gNetworkController, 0, sizeof(gNetworkController));
}
BOOL CPTCPServer::whileLoop() {
int32_t ret;
int32_t clientfd = getClientFD();
while (1) {
if(shouldExit()) {
if (shouldExit()) {
break;
}
ret = checkbyte(clientfd);
if (ret < 0) {
if(errno != EWOULDBLOCK) {
if (errno != EWOULDBLOCK) {
return false;
}
OSSleepTicks(OSMicrosecondsToTicks(1000));
@ -90,172 +90,172 @@ BOOL CPTCPServer::whileLoop() {
}
//DEBUG_FUNCTION_LINE("got byte from tcp! %01X",ret);
switch (ret) {
case WIIU_CP_TCP_ATTACH: { /*attach */
if(gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) {
int32_t handle;
ret = recvwait(clientfd, &handle, 4);
if(ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: recvwait handle",WIIU_CP_TCP_ATTACH);
return false;
}
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("got handle %d",handle);
}
uint16_t vid = 0;
uint16_t pid = 0;
ret = recvwait(clientfd, &vid, 2);
if(ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: recvwait vid",WIIU_CP_TCP_ATTACH);
return false;
}
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("got vid %04X",vid);
}
ret = recvwait(clientfd, &pid, 2);
if(ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: recvwait pid",WIIU_CP_TCP_ATTACH);
return false;
}
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("got pid %04X",pid);
}
HIDDevice device;
memset(&device,0,sizeof(device));
device.handle = handle;
device.interfaceIndex = 0;
device.vid = SWAP16(vid);
device.pid = SWAP16(pid);
device.maxPacketSizeRx = 8;
my_cb_user * user = NULL;
ControllerPatcherHID::externAttachDetachCallback(&device,HID_DEVICE_ATTACH);
if((ret = ControllerPatcherUtils::getDataByHandle(handle,&user)) < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: getDataByHandle(%d,%08X).",WIIU_CP_TCP_ATTACH,handle,&user);
DEBUG_FUNCTION_LINE("Error in %02X: Config for the controller is missing.",WIIU_CP_TCP_ATTACH);
if((ret = sendbyte(clientfd, WIIU_CP_TCP_ATTACH_CONFIG_NOT_FOUND) < 0)) {
DEBUG_FUNCTION_LINE("Error in %02X: Sending the WIIU_CP_TCP_ATTACH_CONFIG_NOT_FOUND byte failed. Error: %d.",WIIU_CP_TCP_ATTACH,ret);
}
return false;
}
if((ret = sendbyte(clientfd, WIIU_CP_TCP_ATTACH_CONFIG_FOUND) < 0)) {
DEBUG_FUNCTION_LINE("Error in %02X: Sending the WIIU_CP_TCP_ATTACH_CONFIG_FOUND byte failed. Error: %d.",WIIU_CP_TCP_ATTACH,ret);
return false;
}
if(user != NULL) {
if((ret = sendbyte(clientfd, WIIU_CP_TCP_ATTACH_USER_DATA_OKAY) < 0)) {
DEBUG_FUNCTION_LINE("Error in %02X: Sending the WIIU_CP_TCP_ATTACH_USER_DATA_OKAY byte failed. Error: %d.",WIIU_CP_TCP_ATTACH,ret);
case WIIU_CP_TCP_ATTACH: { /*attach */
if (gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) {
int32_t handle;
ret = recvwait(clientfd, &handle, 4);
if (ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: recvwait handle", WIIU_CP_TCP_ATTACH);
return false;
}
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("got handle %d", handle);
}
uint16_t vid = 0;
uint16_t pid = 0;
ret = recvwait(clientfd, &vid, 2);
if (ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: recvwait vid", WIIU_CP_TCP_ATTACH);
return false;
}
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("got vid %04X", vid);
}
ret = sendwait(clientfd,&user->slotdata.deviceslot,2);
if(ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: sendwait slotdata: %04X",WIIU_CP_TCP_ATTACH,user->slotdata.deviceslot);
ret = recvwait(clientfd, &pid, 2);
if (ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: recvwait pid", WIIU_CP_TCP_ATTACH);
return false;
}
ret = sendwait(clientfd,&user->pad_slot,1);
if(ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: sendwait pad_slot: %04X",WIIU_CP_TCP_ATTACH,user->pad_slot);
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("got pid %04X", pid);
}
HIDDevice device;
memset(&device, 0, sizeof(device));
device.handle = handle;
device.interfaceIndex = 0;
device.vid = SWAP16(vid);
device.pid = SWAP16(pid);
device.maxPacketSizeRx = 8;
my_cb_user *user = NULL;
ControllerPatcherHID::externAttachDetachCallback(&device, HID_DEVICE_ATTACH);
if ((ret = ControllerPatcherUtils::getDataByHandle(handle, &user)) < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: getDataByHandle(%d,%08X).", WIIU_CP_TCP_ATTACH, handle, &user);
DEBUG_FUNCTION_LINE("Error in %02X: Config for the controller is missing.", WIIU_CP_TCP_ATTACH);
if ((ret = sendbyte(clientfd, WIIU_CP_TCP_ATTACH_CONFIG_NOT_FOUND) < 0)) {
DEBUG_FUNCTION_LINE("Error in %02X: Sending the WIIU_CP_TCP_ATTACH_CONFIG_NOT_FOUND byte failed. Error: %d.", WIIU_CP_TCP_ATTACH, ret);
}
return false;
}
} else {
DEBUG_FUNCTION_LINE("Error in %02X: invalid user data.",WIIU_CP_TCP_ATTACH);
if((ret = sendbyte(clientfd, WIIU_CP_TCP_ATTACH_USER_DATA_BAD) < 0)) {
DEBUG_FUNCTION_LINE("Error in %02X: Sending the WIIU_CP_TCP_ATTACH_USER_DATA_BAD byte failed. Error: %d.",WIIU_CP_TCP_ATTACH,ret);
if ((ret = sendbyte(clientfd, WIIU_CP_TCP_ATTACH_CONFIG_FOUND) < 0)) {
DEBUG_FUNCTION_LINE("Error in %02X: Sending the WIIU_CP_TCP_ATTACH_CONFIG_FOUND byte failed. Error: %d.", WIIU_CP_TCP_ATTACH, ret);
return false;
}
return false;
if (user != NULL) {
if ((ret = sendbyte(clientfd, WIIU_CP_TCP_ATTACH_USER_DATA_OKAY) < 0)) {
DEBUG_FUNCTION_LINE("Error in %02X: Sending the WIIU_CP_TCP_ATTACH_USER_DATA_OKAY byte failed. Error: %d.", WIIU_CP_TCP_ATTACH, ret);
return false;
}
ret = sendwait(clientfd, &user->slotdata.deviceslot, 2);
if (ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: sendwait slotdata: %04X", WIIU_CP_TCP_ATTACH, user->slotdata.deviceslot);
return false;
}
ret = sendwait(clientfd, &user->pad_slot, 1);
if (ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: sendwait pad_slot: %04X", WIIU_CP_TCP_ATTACH, user->pad_slot);
return false;
}
} else {
DEBUG_FUNCTION_LINE("Error in %02X: invalid user data.", WIIU_CP_TCP_ATTACH);
if ((ret = sendbyte(clientfd, WIIU_CP_TCP_ATTACH_USER_DATA_BAD) < 0)) {
DEBUG_FUNCTION_LINE("Error in %02X: Sending the WIIU_CP_TCP_ATTACH_USER_DATA_BAD byte failed. Error: %d.", WIIU_CP_TCP_ATTACH, ret);
return false;
}
return false;
break;
}
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("attachted to device slot: %d , pad slot is: %d", user->slotdata.deviceslot, user->pad_slot);
}
gNetworkController[user->slotdata.deviceslot][user->pad_slot][NETWORK_CONTROLLER_VID] = device.vid;
gNetworkController[user->slotdata.deviceslot][user->pad_slot][NETWORK_CONTROLLER_PID] = device.pid;
gNetworkController[user->slotdata.deviceslot][user->pad_slot][NETWORK_CONTROLLER_ACTIVE] = 1;
gNetworkController[user->slotdata.deviceslot][user->pad_slot][NETWORK_CONTROLLER_HANDLE] = handle;
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("handle %d connected! vid: %02X pid: %02X deviceslot %d, padslot %d", handle, vid, pid, user->slotdata.deviceslot, user->pad_slot);
}
break;
}
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("attachted to device slot: %d , pad slot is: %d",user->slotdata.deviceslot,user->pad_slot);
}
gNetworkController[user->slotdata.deviceslot][user->pad_slot][NETWORK_CONTROLLER_VID] = device.vid;
gNetworkController[user->slotdata.deviceslot][user->pad_slot][NETWORK_CONTROLLER_PID] = device.pid;
gNetworkController[user->slotdata.deviceslot][user->pad_slot][NETWORK_CONTROLLER_ACTIVE] = 1;
gNetworkController[user->slotdata.deviceslot][user->pad_slot][NETWORK_CONTROLLER_HANDLE] = handle;
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("handle %d connected! vid: %02X pid: %02X deviceslot %d, padslot %d",handle,vid,pid,user->slotdata.deviceslot,user->pad_slot);
}
break;
}
break;
}
case WIIU_CP_TCP_DETACH: { /*detach */
if(gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) {
int32_t handle;
ret = recvwait(clientfd, &handle, 4);
if(ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: recvwait handle",WIIU_CP_TCP_DETACH);
return false;
break;
}
case WIIU_CP_TCP_DETACH: { /*detach */
if (gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) {
int32_t handle;
ret = recvwait(clientfd, &handle, 4);
if (ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: recvwait handle", WIIU_CP_TCP_DETACH);
return false;
break;
}
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("got detach for handle: %d",handle);
}
my_cb_user * user = NULL;
if(ControllerPatcherUtils::getDataByHandle(handle,&user) < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: getDataByHandle(%d,%08X).",WIIU_CP_TCP_DETACH,handle,&user);
return false;
break;
}
if(user == NULL) {
DEBUG_FUNCTION_LINE("Error in %02X: invalid user data.",WIIU_CP_TCP_DETACH);
return false;
break;
}
int32_t deviceslot = user->slotdata.deviceslot;
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("device slot is: %d , pad slot is: %d",deviceslot,user->pad_slot);
}
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("got detach for handle: %d", handle);
}
my_cb_user *user = NULL;
if (ControllerPatcherUtils::getDataByHandle(handle, &user) < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: getDataByHandle(%d,%08X).", WIIU_CP_TCP_DETACH, handle, &user);
return false;
break;
}
if (user == NULL) {
DEBUG_FUNCTION_LINE("Error in %02X: invalid user data.", WIIU_CP_TCP_DETACH);
return false;
break;
}
int32_t deviceslot = user->slotdata.deviceslot;
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("device slot is: %d , pad slot is: %d", deviceslot, user->pad_slot);
}
DeviceVIDPIDInfo vidpid;
int32_t result;
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",WIIU_CP_TCP_DETACH,deviceslot,ret);
return false;
DeviceVIDPIDInfo vidpid;
int32_t result;
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", WIIU_CP_TCP_DETACH, deviceslot, ret);
return false;
break;
}
HIDDevice device;
memset(&device, 0, sizeof(device));
device.handle = handle;
device.interfaceIndex = 0;
device.vid = SWAP16(vidpid.vid);
device.pid = SWAP16(vidpid.pid);
device.maxPacketSizeRx = 14;
ControllerPatcherHID::externAttachDetachCallback(&device, HID_DEVICE_DETACH);
memset(gNetworkController[deviceslot][user->pad_slot], 0, sizeof(gNetworkController[deviceslot][user->pad_slot]));
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("handle %d disconnected!", handle);
}
break;
}
HIDDevice device;
memset(&device,0,sizeof(device));
device.handle = handle;
device.interfaceIndex = 0;
device.vid = SWAP16(vidpid.vid);
device.pid = SWAP16(vidpid.pid);
device.maxPacketSizeRx = 14;
ControllerPatcherHID::externAttachDetachCallback(&device,HID_DEVICE_DETACH);
memset(gNetworkController[deviceslot][user->pad_slot],0,sizeof(gNetworkController[deviceslot][user->pad_slot]));
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("handle %d disconnected!",handle);
}
break;
}
break;
}
case WIIU_CP_TCP_PING: { /*ping*/
if(gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) {
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("Got Ping, sending now a Pong");
}
int32_t ret = sendbyte(clientfd, WIIU_CP_TCP_PONG);
if(ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: sendbyte PONG");
return false;
}
case WIIU_CP_TCP_PING: { /*ping*/
if (gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Got Ping, sending now a Pong");
}
int32_t ret = sendbyte(clientfd, WIIU_CP_TCP_PONG);
if (ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: sendbyte PONG");
return false;
}
break;
}
break;
}
break;
}
default:
return false;
break;
default:
return false;
break;
}
}
return true;
@ -263,37 +263,37 @@ BOOL CPTCPServer::whileLoop() {
BOOL CPTCPServer::acceptConnection() {
int32_t clientfd = getClientFD();
DEBUG_FUNCTION_LINE("TCP Connection accepted! Sending my protocol version: %d (0x%02X)", (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)", (WIIU_CP_TCP_HANDSHAKE - WIIU_CP_TCP_HANDSHAKE_VERSION_1) + 1, WIIU_CP_TCP_HANDSHAKE);
gUDPClientip = getSockAddr().sin_addr.s_addr;
UDPClient::createInstance();
int32_t ret;
ret = sendbyte(clientfd, WIIU_CP_TCP_HANDSHAKE); //Hey I'm a WiiU console!
if(ret < 0) {
DEBUG_FUNCTION_LINE("Error sendbyte: %02X",WIIU_CP_TCP_HANDSHAKE);
if (ret < 0) {
DEBUG_FUNCTION_LINE("Error sendbyte: %02X", WIIU_CP_TCP_HANDSHAKE);
return false;
}
uint8_t clientProtocolVersion = recvbyte(clientfd);
if(ret < 0) {
DEBUG_FUNCTION_LINE("Error recvbyte: %02X",WIIU_CP_TCP_HANDSHAKE);
if (ret < 0) {
DEBUG_FUNCTION_LINE("Error recvbyte: %02X", WIIU_CP_TCP_HANDSHAKE);
return false;
}
if(clientProtocolVersion == WIIU_CP_TCP_HANDSHAKE_ABORT) {
if (clientProtocolVersion == WIIU_CP_TCP_HANDSHAKE_ABORT) {
DEBUG_FUNCTION_LINE("The network client wants to abort.");
return false;
}
DEBUG_FUNCTION_LINE("received protocol version: %d (0x%02X)",(clientProtocolVersion - WIIU_CP_TCP_HANDSHAKE_VERSION_1)+1,clientProtocolVersion);
DEBUG_FUNCTION_LINE("received protocol version: %d (0x%02X)", (clientProtocolVersion - WIIU_CP_TCP_HANDSHAKE_VERSION_1) + 1, clientProtocolVersion);
if(clientProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_MIN && clientProtocolVersion <= WIIU_CP_TCP_HANDSHAKE_VERSION_MAX) {
if (clientProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_MIN && clientProtocolVersion <= WIIU_CP_TCP_HANDSHAKE_VERSION_MAX) {
DEBUG_FUNCTION_LINE("We support this protocol version. Let's confirm it to the network client.");
gUsedProtocolVersion = clientProtocolVersion;
ret = sendbyte(clientfd, clientProtocolVersion);
if(ret < 0) {
DEBUG_FUNCTION_LINE("Error sendbyte: %02X",clientProtocolVersion);
ret = sendbyte(clientfd, clientProtocolVersion);
if (ret < 0) {
DEBUG_FUNCTION_LINE("Error sendbyte: %02X", clientProtocolVersion);
return false;
}
} else {

51
source/network/CPTCPServer.hpp
View File

@ -19,12 +19,12 @@
#include "../ControllerPatcherIncludes.hpp"
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <utils/TCPServer.hpp>
#include <network/net.h>
#include <coreinit/title.h>
#include <errno.h>
#include <netinet/in.h>
#include <network/net.h>
#include <sys/socket.h>
#include <utils/TCPServer.hpp>
#define WIIU_CP_TCP_HANDSHAKE WIIU_CP_TCP_HANDSHAKE_VERSION_3
@ -35,26 +35,26 @@
#define WIIU_CP_TCP_HANDSHAKE_VERSION_2 0x13
#define WIIU_CP_TCP_HANDSHAKE_VERSION_3 0x14
#define WIIU_CP_TCP_HANDSHAKE_ABORT 0x30
#define WIIU_CP_TCP_HANDSHAKE_ABORT 0x30
#define WIIU_CP_TCP_ATTACH 0x01
#define WIIU_CP_TCP_DETACH 0x02
#define WIIU_CP_TCP_PING 0xF0
#define WIIU_CP_TCP_PONG 0xF1
#define WIIU_CP_TCP_ATTACH 0x01
#define WIIU_CP_TCP_DETACH 0x02
#define WIIU_CP_TCP_PING 0xF0
#define WIIU_CP_TCP_PONG 0xF1
#define WIIU_CP_TCP_ATTACH_CONFIG_FOUND 0xE0
#define WIIU_CP_TCP_ATTACH_CONFIG_NOT_FOUND 0xE1
#define WIIU_CP_TCP_ATTACH_USER_DATA_OKAY 0xE8
#define WIIU_CP_TCP_ATTACH_USER_DATA_BAD 0xE9
#define WIIU_CP_TCP_ATTACH_CONFIG_FOUND 0xE0
#define WIIU_CP_TCP_ATTACH_CONFIG_NOT_FOUND 0xE1
#define WIIU_CP_TCP_ATTACH_USER_DATA_OKAY 0xE8
#define WIIU_CP_TCP_ATTACH_USER_DATA_BAD 0xE9
#define DEFAULT_TCP_PORT 8112
#define DEFAULT_TCP_PORT 8112
class CPTCPServer: TCPServer {
class CPTCPServer : TCPServer {
friend class ControllerPatcher;
private:
static CPTCPServer *getInstance() {
if(!instance) {
if (!instance) {
instance = new CPTCPServer(DEFAULT_TCP_PORT);
}
@ -62,7 +62,7 @@ private:
}
static void destroyInstance() {
if(instance) {
if (instance) {
delete instance;
instance = NULL;
}
@ -70,13 +70,13 @@ private:
static int32_t getPriority() {
int32_t priority = 28;
if(OSGetTitleID() == 0x00050000101c9300 || //The Legend of Zelda Breath of the Wild JPN
OSGetTitleID() == 0x00050000101c9400 || //The Legend of Zelda Breath of the Wild USA
OSGetTitleID() == 0x00050000101c9500 || //The Legend of Zelda Breath of the Wild EUR
OSGetTitleID() == 0x00050000101c9b00 || //The Binding of Isaac: Rebirth EUR
OSGetTitleID() == 0x00050000101a3c00) { //The Binding of Isaac: Rebirth USA
if (OSGetTitleID() == 0x00050000101c9300 || //The Legend of Zelda Breath of the Wild JPN
OSGetTitleID() == 0x00050000101c9400 || //The Legend of Zelda Breath of the Wild USA
OSGetTitleID() == 0x00050000101c9500 || //The Legend of Zelda Breath of the Wild EUR
OSGetTitleID() == 0x00050000101c9b00 || //The Binding of Isaac: Rebirth EUR
OSGetTitleID() == 0x00050000101a3c00) { //The Binding of Isaac: Rebirth USA
priority = 10;
DEBUG_FUNCTION_LINE("This game needs higher thread priority. We set it to %d",priority);
DEBUG_FUNCTION_LINE("This game needs higher thread priority. We set it to %d", priority);
}
return priority;
}
@ -97,8 +97,7 @@ private:
virtual void onConnectionClosed();
static CPTCPServer * instance;
static CPTCPServer *instance;
};
#endif //_TCPSERVER_WINDOW_H_

18
source/network/UDPClient.cpp
View File

@ -23,7 +23,7 @@
#define MAX_UDP_SIZE 0x578
UDPClient * UDPClient::instance = NULL;
UDPClient *UDPClient::instance = NULL;
UDPClient::UDPClient(uint32_t ip, int32_t port) {
sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
@ -32,11 +32,11 @@ UDPClient::UDPClient(uint32_t ip, int32_t port) {
struct sockaddr_in connect_addr;
memset(&connect_addr, 0, sizeof(connect_addr));
connect_addr.sin_family = AF_INET;
connect_addr.sin_port = port;
connect_addr.sin_family = AF_INET;
connect_addr.sin_port = port;
connect_addr.sin_addr.s_addr = ip;
if(connect(sockfd, (struct sockaddr*)&connect_addr, sizeof(connect_addr)) < 0) {
if (connect(sockfd, (struct sockaddr *) &connect_addr, sizeof(connect_addr)) < 0) {
close(sockfd);
sockfd = -1;
}
@ -46,16 +46,16 @@ UDPClient::~UDPClient() {
if (this->sockfd != -1) {
close(sockfd);
}
if(HID_DEBUG) {
log_printf("UDPClient::~UDPClient(line %d): Thread has been closed",__LINE__);
if (HID_DEBUG) {
log_printf("UDPClient::~UDPClient(line %d): Thread has been closed", __LINE__);
}
}
BOOL UDPClient::sendData(char * data,int32_t length) {
if(sockfd < 0 || data == 0 || length < 0 || gUsedProtocolVersion < WIIU_CP_TCP_HANDSHAKE_VERSION_3) {
BOOL UDPClient::sendData(char *data, int32_t length) {
if (sockfd < 0 || data == 0 || length < 0 || gUsedProtocolVersion < WIIU_CP_TCP_HANDSHAKE_VERSION_3) {
return false;
}
if(length > 1400) length = 1400;
if (length > 1400) length = 1400;
int32_t ret = send(sockfd, data, length, 0);
return (ret >= 0);

20
source/network/UDPClient.hpp
View File

@ -18,20 +18,20 @@
#define _UDPCLIENT_WINDOW_H_
#include "../ControllerPatcherIncludes.hpp"
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/socket.h>
#define DEFAULT_UDP_CLIENT_PORT 8114
#define DEFAULT_UDP_CLIENT_PORT 8114
class UDPClient {
friend class ControllerPatcher;
friend class ControllerPatcherHID;
friend class CPTCPServer;
public:
public:
private:
static UDPClient *getInstance() {
if(instance == NULL) {
if (instance == NULL) {
createInstance();
}
return instance;
@ -39,24 +39,24 @@ private:
static UDPClient *createInstance() {
if(instance != NULL) {
if (instance != NULL) {
destroyInstance();
}
instance = new UDPClient(gUDPClientip,DEFAULT_UDP_CLIENT_PORT);
instance = new UDPClient(gUDPClientip, DEFAULT_UDP_CLIENT_PORT);
return getInstance();
return getInstance();
}
static void destroyInstance() {
if(instance != NULL) {
if (instance != NULL) {
delete instance;
instance = NULL;
}
}
UDPClient(uint32_t ip,int32_t port);
UDPClient(uint32_t ip, int32_t port);
~UDPClient();
BOOL sendData(char * data, int32_t length);
BOOL sendData(char *data, int32_t length);
volatile int32_t sockfd = -1;
struct sockaddr_in addr;

150
source/network/UDPServer.cpp
View File

@ -23,32 +23,32 @@
#define MAX_UDP_SIZE 0x578
CThread * UDPServer::pThread = NULL;
UDPServer * UDPServer::instance = NULL;
CThread *UDPServer::pThread = NULL;
UDPServer *UDPServer::instance = NULL;
UDPServer::UDPServer(int32_t port) {
int32_t ret;
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = port;
addr.sin_family = AF_INET;
addr.sin_port = port;
addr.sin_addr.s_addr = 0;
this->sockfd = ret = socket(AF_INET, SOCK_DGRAM, 0);
if(ret == -1) return;
if (ret == -1) return;
int32_t enable = 1;
setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable));
ret = bind(sockfd, (sockaddr *)&addr, 16);
if(ret < 0) return;
ret = bind(sockfd, (sockaddr *) &addr, 16);
if (ret < 0) return;
StartUDPThread(this);
}
UDPServer::~UDPServer() {
CThread * pThreadPointer = UDPServer::pThread;
if(pThreadPointer != NULL) {
CThread *pThreadPointer = UDPServer::pThread;
if (pThreadPointer != NULL) {
exitThread = 1;
if(pThreadPointer != NULL) {
if (pThreadPointer != NULL) {
delete pThreadPointer;
UDPServer::pThread = NULL;
if (this->sockfd != -1) {
@ -57,39 +57,37 @@ UDPServer::~UDPServer() {
this->sockfd = -1;
}
}
if(HID_DEBUG) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Thread has been closed");
}
}
void UDPServer::StartUDPThread(UDPServer * server) {
void UDPServer::StartUDPThread(UDPServer *server) {
int32_t priority = 28;
if(OSGetTitleID() == 0x00050000101c9300 || //The Legend of Zelda Breath of the Wild JPN
OSGetTitleID() == 0x00050000101c9400 || //The Legend of Zelda Breath of the Wild USA
OSGetTitleID() == 0x00050000101c9500 || //The Legend of Zelda Breath of the Wild EUR
OSGetTitleID() == 0x00050000101c9b00 || //The Binding of Isaac: Rebirth EUR
OSGetTitleID() == 0x00050000101a3c00) { //The Binding of Isaac: Rebirth USA
if (OSGetTitleID() == 0x00050000101c9300 || //The Legend of Zelda Breath of the Wild JPN
OSGetTitleID() == 0x00050000101c9400 || //The Legend of Zelda Breath of the Wild USA
OSGetTitleID() == 0x00050000101c9500 || //The Legend of Zelda Breath of the Wild EUR
OSGetTitleID() == 0x00050000101c9b00 || //The Binding of Isaac: Rebirth EUR
OSGetTitleID() == 0x00050000101a3c00) { //The Binding of Isaac: Rebirth USA
priority = 10;
DEBUG_FUNCTION_LINE("This game needs higher thread priority. We set it to %d",priority);
DEBUG_FUNCTION_LINE("This game needs higher thread priority. We set it to %d", priority);
}
UDPServer::pThread = CThread::create(UDPServer::DoUDPThread, (void*)server, CThread::eAttributeAffCore2,priority);
UDPServer::pThread = CThread::create(UDPServer::DoUDPThread, (void *) server, CThread::eAttributeAffCore2, priority);
UDPServer::pThread->resumeThread();
}
BOOL UDPServer::cpyIncrementBufferOffset(void * target, void * source, int32_t * offset, int32_t typesize, int32_t maximum) {
if(((int)*offset + typesize) > maximum) {
DEBUG_FUNCTION_LINE("Transfer error. Excepted %04X bytes, but only got %04X",(*offset + typesize),maximum);
BOOL UDPServer::cpyIncrementBufferOffset(void *target, void *source, int32_t *offset, int32_t typesize, int32_t maximum) {
if (((int) *offset + typesize) > maximum) {
DEBUG_FUNCTION_LINE("Transfer error. Excepted %04X bytes, but only got %04X", (*offset + typesize), maximum);
return false;
}
memcpy(target,(void*)((uint32_t)source+(*offset)),typesize);
memcpy(target, (void *) ((uint32_t) source + (*offset)), typesize);
*offset += typesize;
return true;
}
void UDPServer::DoUDPThread(CThread *thread, void *arg) {
UDPServer * args = (UDPServer * )arg;
UDPServer *args = (UDPServer *) arg;
args->DoUDPThreadInternal();
}
@ -97,75 +95,75 @@ void UDPServer::DoUDPThreadInternal() {
uint8_t buffer[MAX_UDP_SIZE];
int32_t n;
my_cb_user user;
while(1) {
my_cb_user user;
while (1) {
//int32_t usingVar = exitThread;
if(exitThread)break;
memset(buffer,0,MAX_UDP_SIZE);
n = recv(sockfd,buffer,MAX_UDP_SIZE,0);
if (exitThread) break;
memset(buffer, 0, MAX_UDP_SIZE);
n = recv(sockfd, buffer, MAX_UDP_SIZE, 0);
if (n < 0) {
int32_t errno_ = errno;
OSSleepTicks(OSMicrosecondsToTicks(2000));
if(errno_ != EINVAL && errno_ != ENOTCONN) {
if (errno_ != EINVAL && errno_ != ENOTCONN) {
break;
}
continue;
}
int32_t bufferoffset = 0;
uint8_t type;
memcpy((void *)&type,buffer,sizeof(type));
memcpy((void *) &type, buffer, sizeof(type));
bufferoffset += sizeof(type);
switch (buffer[0]) {
case WIIU_CP_UDP_CONTROLLER_READ_DATA: {
if(gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) {
uint8_t count_commands;
memcpy((void *)&count_commands,buffer+bufferoffset,sizeof(count_commands));
bufferoffset += sizeof(count_commands);
for(int32_t i = 0; i<count_commands; i++) {
int32_t handle;
uint16_t deviceSlot;
uint32_t hid;
uint8_t padslot;
uint8_t datasize;
case WIIU_CP_UDP_CONTROLLER_READ_DATA: {
if (gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) {
uint8_t count_commands;
memcpy((void *) &count_commands, buffer + bufferoffset, sizeof(count_commands));
bufferoffset += sizeof(count_commands);
for (int32_t i = 0; i < count_commands; i++) {
int32_t handle;
uint16_t deviceSlot;
uint32_t hid;
uint8_t padslot;
uint8_t datasize;
if(!cpyIncrementBufferOffset((void *)&handle, (void *)buffer,&bufferoffset,sizeof(handle), n))continue;
if(!cpyIncrementBufferOffset((void *)&deviceSlot, (void *)buffer,&bufferoffset,sizeof(deviceSlot),n))continue;
hid = (1 << deviceSlot);
if(!cpyIncrementBufferOffset((void *)&padslot, (void *)buffer,&bufferoffset,sizeof(padslot), n))continue;
if(!cpyIncrementBufferOffset((void *)&datasize, (void *)buffer,&bufferoffset,sizeof(datasize), n))continue;
uint8_t * databuffer = (uint8_t*) malloc(datasize * sizeof(uint8_t));
if(!databuffer) {
DEBUG_FUNCTION_LINE("Allocating memory failed");
continue;
}
if(!cpyIncrementBufferOffset((void *)databuffer, (void *)buffer,&bufferoffset,datasize, n))continue;
//DEBUG_FUNCTION_LINE("UDPServer::DoUDPThreadInternal(): Got handle: %d slot %04X hid %04X pad %02X datasize %02X\n",handle,deviceSlot,hid,padslot,datasize);
user.pad_slot = padslot;
user.slotdata.deviceslot = deviceSlot;
user.slotdata.hidmask = hid;
if(gNetworkController[deviceSlot][padslot][0] == 0) {
DEBUG_FUNCTION_LINE("Ehm. Pad is not connected. STOP SENDING DATA ;) \n");
} else {
ControllerPatcherHID::externHIDReadCallback(handle,databuffer,datasize,&user);
}
if(databuffer) {
free(databuffer);
databuffer = NULL;
if (!cpyIncrementBufferOffset((void *) &handle, (void *) buffer, &bufferoffset, sizeof(handle), n)) continue;
if (!cpyIncrementBufferOffset((void *) &deviceSlot, (void *) buffer, &bufferoffset, sizeof(deviceSlot), n)) continue;
hid = (1 << deviceSlot);
if (!cpyIncrementBufferOffset((void *) &padslot, (void *) buffer, &bufferoffset, sizeof(padslot), n)) continue;
if (!cpyIncrementBufferOffset((void *) &datasize, (void *) buffer, &bufferoffset, sizeof(datasize), n)) continue;
uint8_t *databuffer = (uint8_t *) malloc(datasize * sizeof(uint8_t));
if (!databuffer) {
DEBUG_FUNCTION_LINE("Allocating memory failed");
continue;
}
if (!cpyIncrementBufferOffset((void *) databuffer, (void *) buffer, &bufferoffset, datasize, n)) continue;
//DEBUG_FUNCTION_LINE("UDPServer::DoUDPThreadInternal(): Got handle: %d slot %04X hid %04X pad %02X datasize %02X\n",handle,deviceSlot,hid,padslot,datasize);
user.pad_slot = padslot;
user.slotdata.deviceslot = deviceSlot;
user.slotdata.hidmask = hid;
if (gNetworkController[deviceSlot][padslot][0] == 0) {
DEBUG_FUNCTION_LINE("Ehm. Pad is not connected. STOP SENDING DATA ;) \n");
} else {
ControllerPatcherHID::externHIDReadCallback(handle, databuffer, datasize, &user);
}
if (databuffer) {
free(databuffer);
databuffer = NULL;
}
}
break;
}
break;
}
break;
}
default: {
break;
}
default: {
break;
}
}
}
if(HID_DEBUG) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("UDPServer Thread ended");
}
}

14
source/network/UDPServer.hpp
View File

@ -19,22 +19,22 @@
#include "../ControllerPatcherIncludes.hpp"
#define DEFAULT_UDP_PORT 8113
#define DEFAULT_UDP_PORT 8113
#define WIIU_CP_UDP_CONTROLLER_READ_DATA 0x03
#define WIIU_CP_UDP_CONTROLLER_READ_DATA 0x03
class UDPServer {
friend class ControllerPatcher;
private:
static UDPServer *getInstance() {
if(instance == NULL)
if (instance == NULL)
instance = new UDPServer(DEFAULT_UDP_PORT);
return instance;
}
static void destroyInstance() {
if(instance != NULL) {
if (instance != NULL) {
delete instance;
instance = NULL;
}
@ -42,12 +42,12 @@ private:
UDPServer(int32_t port);
~UDPServer();
void StartUDPThread(UDPServer * server);
void StartUDPThread(UDPServer *server);
static void DoUDPThread(CThread *thread, void *arg);
void DoUDPThreadInternal();
BOOL cpyIncrementBufferOffset(void * target, void * source, int32_t * offset, int32_t typesize, int32_t maximum);
BOOL cpyIncrementBufferOffset(void *target, void *source, int32_t *offset, int32_t typesize, int32_t maximum);
volatile int32_t sockfd = -1;
volatile int32_t sockfd = -1;
volatile int32_t exitThread = 0;
static UDPServer *instance;

21
source/network/net.c
View File

@ -4,23 +4,22 @@
static volatile int socket_lock __attribute__((section(".data"))) = 0;
void initNetwork(){
void initNetwork() {
}
int32_t recvwait(int32_t sock, void *buffer, int32_t len) {
while(socket_lock) {
while (socket_lock) {
OSSleepTicks(OSMicrosecondsToTicks(1000));
}
int32_t ret;
while (len > 0) {
ret = recv(sock, buffer, len, 0);
if(ret < 0) {
if (ret < 0) {
socket_lock = 0;
return ret;
}
len -= ret;
buffer = (void *)(((char *) buffer) + ret);
buffer = (void *) (((char *) buffer) + ret);
}
socket_lock = 0;
return 0;
@ -45,13 +44,13 @@ uint32_t recvword(int32_t sock) {
}
int32_t checkbyte(int32_t sock) {
while(socket_lock) {
while (socket_lock) {
OSSleepTicks(OSMicrosecondsToTicks(1000));
}
unsigned char buffer[1];
int32_t ret;
ret = recv(sock, buffer, 1, MSG_DONTWAIT);
ret = recv(sock, buffer, 1, MSG_DONTWAIT);
socket_lock = 0;
if (ret < 0) return ret;
if (ret == 0) return -1;
@ -59,20 +58,20 @@ int32_t checkbyte(int32_t sock) {
}
int32_t sendwait(int32_t sock, const void *buffer, int32_t len) {
while(socket_lock) {
while (socket_lock) {
OSSleepTicks(OSMicrosecondsToTicks(1000));
}
int32_t ret;
while (len > 0) {
// For some reason the send blocks/crashes if the buffer is too big..
int cur_length = len <= 0x30 ? len : 0x30;
ret = send(sock, buffer, cur_length, 0);
if(ret < 0) {
ret = send(sock, buffer, cur_length, 0);
if (ret < 0) {
socket_lock = 0;
return ret;
}
len -= ret;
buffer = (void *)(((char *) buffer) + ret);
buffer = (void *) (((char *) buffer) + ret);
}
socket_lock = 0;
return 0;

499
source/patcher/ControllerPatcherHID.cpp
View File

@ -28,12 +28,12 @@
int32_t ControllerPatcherHID::externAttachDetachCallback(HIDDevice *p_device, HIDAttachEvent attach) {
HIDClient client;
memset(&client,0,sizeof(client));
return AttachDetachCallback(&client,p_device,attach);
memset(&client, 0, sizeof(client));
return AttachDetachCallback(&client, p_device, attach);
}
void ControllerPatcherHID::externHIDReadCallback(uint32_t handle, unsigned char *buf, uint32_t bytes_transfered, my_cb_user * usr) {
HIDReadCallback(handle,buf,bytes_transfered,usr);
void ControllerPatcherHID::externHIDReadCallback(uint32_t handle, unsigned char *buf, uint32_t bytes_transfered, my_cb_user *usr) {
HIDReadCallback(handle, buf, bytes_transfered, usr);
}
/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
@ -41,26 +41,26 @@ void ControllerPatcherHID::externHIDReadCallback(uint32_t handle, unsigned char
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
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(uint32_t handle, int32_t error, unsigned char *buf, uint32_t bytes_transfered, void *p_user) {
if(error == 0) {
my_cb_user *usr = (my_cb_user*)p_user;
if (error == 0) {
my_cb_user *usr = (my_cb_user *) p_user;
uint32_t slot = 0;
if(usr->pad_slot < HID_MAX_PADS_COUNT) {
if (usr->pad_slot < HID_MAX_PADS_COUNT) {
slot = usr->pad_slot;
}
HID_Data * data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[slot]);
HID_Mouse_Data * cur_mouse_data = &data_ptr->data_union.mouse.cur_mouse_data;
HID_Data *data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[slot]);
HID_Mouse_Data *cur_mouse_data = &data_ptr->data_union.mouse.cur_mouse_data;
data_ptr->type = DEVICE_TYPE_MOUSE;
//DEBUG_FUNCTION_LINE("%02X %02X %02X %02X %02X bytes_transfered: %d\n",buf[0],buf[1],buf[2],buf[3],buf[4],bytes_transfered);
if(buf[0] == 2 && bytes_transfered > 3) { // using the other mouse mode
buf +=1;
if (buf[0] == 2 && bytes_transfered > 3) { // using the other mouse mode
buf += 1;
}
int8_t x_value = 0;
@ -75,14 +75,14 @@ void ControllerPatcherHID::myHIDMouseReadCallback(uint32_t handle, int32_t error
cur_mouse_data->Y += y_value;
cur_mouse_data->deltaY = y_value;
cur_mouse_data->left_click = buf[0];
cur_mouse_data->right_click = buf[0]>>1;
cur_mouse_data->left_click = buf[0];
cur_mouse_data->right_click = buf[0] >> 1;
if(cur_mouse_data->X < 0) cur_mouse_data->X = 0;
if(cur_mouse_data->X > 1280) cur_mouse_data->X = 1280;
if (cur_mouse_data->X < 0) cur_mouse_data->X = 0;
if (cur_mouse_data->X > 1280) cur_mouse_data->X = 1280;
if(cur_mouse_data->Y < 0) cur_mouse_data->Y = 0;
if(cur_mouse_data->Y > 720) cur_mouse_data->Y = 720;
if (cur_mouse_data->Y < 0) cur_mouse_data->Y = 0;
if (cur_mouse_data->Y > 720) cur_mouse_data->Y = 720;
cur_mouse_data->valuedChanged = 1;
@ -93,12 +93,12 @@ void ControllerPatcherHID::myHIDMouseReadCallback(uint32_t handle, int32_t error
}
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) {
my_cb_user *usr = (my_cb_user*)p_user;
if (error == 0 && p_user != NULL && gHIDAttached) {
my_cb_user *usr = (my_cb_user *) p_user;
HIDReadCallback(handle,buf,bytes_transfered,usr);
HIDReadCallback(handle, buf, bytes_transfered, usr);
if(usr->slotdata.hidmask == gHID_LIST_DS4) {
if (usr->slotdata.hidmask == gHID_LIST_DS4) {
OSSleepTicks(OSMicrosecondsToTicks(2000)); //DS4 is way tooo fast. sleeping to reduce lag. (need to check the other pads)
}
HIDRead(handle, usr->buf, bytes_transfered, myHIDReadCallback, usr);
@ -110,9 +110,9 @@ void ControllerPatcherHID::myHIDReadCallback(uint32_t handle, int32_t error, uns
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevice *p_device, HIDAttachEvent attach) {
if(attach) {
DEBUG_FUNCTION_LINE("vid %04x pid %04x connected", SWAP16(p_device->vid),SWAP16(p_device->pid));
if(HID_DEBUG) {
if (attach) {
DEBUG_FUNCTION_LINE("vid %04x pid %04x connected", SWAP16(p_device->vid), SWAP16(p_device->pid));
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("interface index %02x", p_device->interfaceIndex);
DEBUG_FUNCTION_LINE("sub class %02x", p_device->subClass);
DEBUG_FUNCTION_LINE("protocol %02x", p_device->protocol);
@ -120,67 +120,67 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
DEBUG_FUNCTION_LINE("max packet out %02x", p_device->maxPacketSizeRx);
}
}
if(!attach) {
DEBUG_FUNCTION_LINE("vid %04x pid %04x disconnected", SWAP16(p_device->vid),SWAP16(p_device->pid));
if (!attach) {
DEBUG_FUNCTION_LINE("vid %04x pid %04x disconnected", SWAP16(p_device->vid), SWAP16(p_device->pid));
}
DeviceInfo device_info;
memset(&device_info,0,sizeof(DeviceInfo));
memset(&device_info, 0, sizeof(DeviceInfo));
device_info.slotdata.deviceslot = -1;
device_info.vidpid.vid = SWAP16(p_device->vid);
device_info.vidpid.pid = SWAP16(p_device->pid);
device_info.vidpid.vid = SWAP16(p_device->vid);
device_info.vidpid.pid = SWAP16(p_device->pid);
HIDSlotData * slotdata = &(device_info.slotdata);
HIDSlotData *slotdata = &(device_info.slotdata);
if ((p_device->subClass == 1) && (p_device->protocol == 1)) { //Keyboard
slotdata->hidmask = gHID_LIST_KEYBOARD;
slotdata->hidmask = gHID_LIST_KEYBOARD;
slotdata->deviceslot = gHID_SLOT_KEYBOARD;
//DEBUG_FUNCTION_LINE("Found Keyboard: device: %s slot: %d",byte_to_binary(device_info.slotdata.hidmask),device_info.slotdata.deviceslot);
} else if ((p_device->subClass == 1) && (p_device->protocol == 2)) { // MOUSE
slotdata->hidmask = gHID_LIST_MOUSE;
slotdata->hidmask = gHID_LIST_MOUSE;
slotdata->deviceslot = gMouseSlot;
//DEBUG_FUNCTION_LINE("Found Mouse: device: %s slot: %d",byte_to_binary(device_info.hid),device_info.slot);
} else {
int32_t ret;
if((ret = ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info)) < 0) {
DEBUG_FUNCTION_LINE("ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info) failed %d ",ret);
if ((ret = ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info)) < 0) {
DEBUG_FUNCTION_LINE("ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info) failed %d ", ret);
return HID_DEVICE_DETACH;
} else {
//DEBUG_FUNCTION_LINE("ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info) success %d ",ret);
}
}
if(slotdata->hidmask) {
if(attach) {
if (slotdata->hidmask) {
if (attach) {
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];
}
unsigned char *buf = (unsigned char *) memalign(64,bufSize);
memset(buf,0,bufSize);
my_cb_user *usr = (my_cb_user *) memalign(64,sizeof(my_cb_user));
usr->buf = buf;
usr->slotdata = device_info.slotdata;
unsigned char *buf = (unsigned char *) memalign(64, bufSize);
memset(buf, 0, bufSize);
my_cb_user *usr = (my_cb_user *) memalign(64, sizeof(my_cb_user));
usr->buf = buf;
usr->slotdata = device_info.slotdata;
usr->transfersize = p_device->maxPacketSizeRx;
usr->handle = p_device->handle;
usr->handle = p_device->handle;
gHIDAttached |= slotdata->hidmask;
gHIDCurrentDevice |= slotdata->hidmask;
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];
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
pads_per_device = HID_MAX_PADS_COUNT;
}
}
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; //???
int32_t pad_slot = 0;
int32_t failed = 1;
for(int32_t i = 0; i<HID_MAX_PADS_COUNT; i += pads_per_device) {
if(!(pad_count & (1 << i))) {
for (int32_t i = 0; i < HID_MAX_PADS_COUNT; i += pads_per_device) {
if (!(pad_count & (1 << i))) {
failed = 0;
pad_count |= (1 << i);
pad_slot = i;
@ -188,13 +188,13 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
}
}
if(failed) {
DEBUG_FUNCTION_LINE("error: I can only handle %d devices of the same type. Sorry ",HID_MAX_PADS_COUNT);
if(buf) {
if (failed) {
DEBUG_FUNCTION_LINE("error: I can only handle %d devices of the same type. Sorry ", HID_MAX_PADS_COUNT);
if (buf) {
free(buf);
buf = NULL;
}
if(usr) {
if (usr) {
free(usr);
usr = NULL;
}
@ -203,30 +203,30 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1] = pad_count;
DCFlushRange(&config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1],sizeof(config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1]));
DCInvalidateRange(&config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1],sizeof(config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1]));
DCFlushRange(&config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1], sizeof(config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1]));
DCInvalidateRange(&config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1], sizeof(config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1]));
usr->pads_per_device = pads_per_device;
usr->pad_slot = pad_slot;
usr->pad_slot = pad_slot;
for(int32_t i = 0; i<pads_per_device; i++) {
memset(&gHID_Devices[slotdata->deviceslot].pad_data[pad_slot+i],0,sizeof(HID_Data));
for (int32_t i = 0; i < pads_per_device; i++) {
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;
//DEBUG_FUNCTION_LINE("saved handle %d to slot %d and pad %d",p_device->handle,slotdata->deviceslot,pad_slot);
gHID_Devices[slotdata->deviceslot].pad_data[pad_slot+i].user_data = usr;
gHID_Devices[slotdata->deviceslot].pad_data[pad_slot+i].slotdata = device_info.slotdata;
gHID_Devices[slotdata->deviceslot].pad_data[pad_slot + i].user_data = usr;
gHID_Devices[slotdata->deviceslot].pad_data[pad_slot + i].slotdata = device_info.slotdata;
DCFlushRange(&gHID_Devices[slotdata->deviceslot].pad_data[pad_slot+i],sizeof(HID_Data));
DCInvalidateRange(&gHID_Devices[slotdata->deviceslot].pad_data[pad_slot+i],sizeof(HID_Data));
DCFlushRange(&gHID_Devices[slotdata->deviceslot].pad_data[pad_slot + i], sizeof(HID_Data));
DCInvalidateRange(&gHID_Devices[slotdata->deviceslot].pad_data[pad_slot + i], sizeof(HID_Data));
}
if(HID_DEBUG) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Device successfully attached");
}
if(slotdata->hidmask == gHID_LIST_GC) { // GC PAD
if (slotdata->hidmask == gHID_LIST_GC) { // GC PAD
//The GC Adapter has all ports in one device. Set them all.
gHID_Devices[slotdata->deviceslot].pad_data[0].slotdata = device_info.slotdata;
gHID_Devices[slotdata->deviceslot].pad_data[1].slotdata = device_info.slotdata;
@ -234,18 +234,18 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
gHID_Devices[slotdata->deviceslot].pad_data[3].slotdata = device_info.slotdata;
buf[0] = 0x13;
HIDWrite(p_device->handle, usr->buf, 1, NULL,NULL);
HIDWrite(p_device->handle, usr->buf, 1, NULL, NULL);
HIDRead(p_device->handle, usr->buf, usr->transfersize, myHIDReadCallback, usr);
} else if (slotdata->hidmask == gHID_LIST_MOUSE) {
HIDSetProtocol(p_device->handle, p_device->interfaceIndex, 0, 0, 0);
//HIDGetDescriptor(p_device->handle,0x22,0x00,0,my_buf,512,my_foo_cb,NULL);
HIDSetIdle(p_device->handle,p_device->interfaceIndex,1,NULL,NULL,NULL);
HIDSetIdle(p_device->handle, p_device->interfaceIndex, 1, NULL, NULL, NULL);
gHID_Mouse_Mode = HID_MOUSE_MODE_AIM;
HIDRead(p_device->handle, buf, p_device->maxPacketSizeRx, myHIDMouseReadCallback, usr);
} else if (slotdata->hidmask == gHID_LIST_SWITCH_PRO) {
int32_t read_result = HIDRead(p_device->handle, usr->buf, usr->transfersize, NULL, NULL);
if(read_result == 64) {
if(usr->buf[01] == 0x01) { //We need to do the handshake
if (read_result == 64) {
if (usr->buf[01] == 0x01) { //We need to do the handshake
DEBUG_FUNCTION_LINE("Switch Pro Controller handshake needed");
/**
Thanks to ShinyQuagsire23 for the values (https://github.com/shinyquagsire23/HID-Joy-Con-Whispering)
@ -253,17 +253,17 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
//Get MAC
buf[0] = 0x80;
buf[1] = 0x01;
HIDWrite(p_device->handle, usr->buf, 2, NULL,NULL);
HIDWrite(p_device->handle, usr->buf, 2, NULL, NULL);
HIDRead(p_device->handle, usr->buf, usr->transfersize, NULL, NULL);
//Do handshake
buf[0] = 0x80;
buf[1] = 0x02;
HIDWrite(p_device->handle, usr->buf, 2, NULL,NULL);
HIDWrite(p_device->handle, usr->buf, 2, NULL, NULL);
HIDRead(p_device->handle, usr->buf, usr->transfersize, NULL, NULL);
//Talk over HID only.
buf[0] = 0x80;
buf[1] = 0x04;
HIDWrite(p_device->handle, usr->buf, 2, NULL,NULL);
HIDWrite(p_device->handle, usr->buf, 2, NULL, NULL);
HIDRead(p_device->handle, usr->buf, usr->transfersize, NULL, NULL);
} else {
DEBUG_FUNCTION_LINE("Switch Pro Controller handshake already done");
@ -276,7 +276,7 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
HIDRead(p_device->handle, buf, p_device->maxPacketSizeRx, myHIDReadCallback, usr);
} else if (slotdata->hidmask == gHID_LIST_DS3) {
HIDSetProtocol(p_device->handle, p_device->interfaceIndex, 1, 0, 0);
HIDDS3Rumble(p_device->handle,usr,0);
HIDDS3Rumble(p_device->handle, usr, 0);
buf[0] = 0x42;
buf[1] = 0x0c;
buf[2] = 0x00;
@ -289,14 +289,14 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
return HID_DEVICE_ATTACH;
} else {
my_cb_user * user_data = NULL;
int32_t founddata = 0;
for(int32_t i = 0; i<HID_MAX_PADS_COUNT; i++) {
if(gHID_Devices[slotdata->deviceslot].pad_data[i].handle == p_device->handle) {
my_cb_user *user_data = NULL;
int32_t founddata = 0;
for (int32_t i = 0; i < HID_MAX_PADS_COUNT; i++) {
if (gHID_Devices[slotdata->deviceslot].pad_data[i].handle == p_device->handle) {
gHID_Devices[slotdata->deviceslot].pad_data[i].handle = 0;
DCFlushRange(&gHID_Devices[slotdata->deviceslot].pad_data[i].handle,sizeof(gHID_Devices[slotdata->deviceslot].pad_data[i].handle));
DCInvalidateRange(&gHID_Devices[slotdata->deviceslot].pad_data[i].handle,sizeof(gHID_Devices[slotdata->deviceslot].pad_data[i].handle));
DCFlushRange(&gHID_Devices[slotdata->deviceslot].pad_data[i].handle, sizeof(gHID_Devices[slotdata->deviceslot].pad_data[i].handle));
DCInvalidateRange(&gHID_Devices[slotdata->deviceslot].pad_data[i].handle, sizeof(gHID_Devices[slotdata->deviceslot].pad_data[i].handle));
user_data = (my_cb_user *) gHID_Devices[slotdata->deviceslot].pad_data[i].user_data;
@ -305,40 +305,40 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
}
}
if(user_data) {
config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1] &= ~ (1 << user_data->pad_slot);
DCFlushRange(&config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1],sizeof(config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1]));
DCInvalidateRange(&config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1],sizeof(config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1]));
if(user_data->buf) {
if (user_data) {
config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1] &= ~(1 << user_data->pad_slot);
DCFlushRange(&config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1], sizeof(config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1]));
DCInvalidateRange(&config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1], sizeof(config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1]));
if (user_data->buf) {
free(user_data->buf);
user_data->buf = NULL;
}
free(user_data);
user_data = NULL;
} else {
if(founddata) {
if (founddata) {
DEBUG_FUNCTION_LINE("user_data null. You may have a memory leak.");
}
return HID_DEVICE_DETACH;
}
if(config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1] == 0) {
if (config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1] == 0) {
gHIDAttached &= ~slotdata->hidmask;
gHIDCurrentDevice &= ~slotdata->hidmask;
DCFlushRange(&gHIDAttached,sizeof(gHIDAttached));
DCInvalidateRange(&gHIDAttached,sizeof(gHIDAttached));
DCFlushRange(&gHIDCurrentDevice,sizeof(gHIDCurrentDevice));
DCInvalidateRange(&gHIDCurrentDevice,sizeof(gHIDCurrentDevice));
DCFlushRange(&gHIDAttached, sizeof(gHIDAttached));
DCInvalidateRange(&gHIDAttached, sizeof(gHIDAttached));
DCFlushRange(&gHIDCurrentDevice, sizeof(gHIDCurrentDevice));
DCInvalidateRange(&gHIDCurrentDevice, sizeof(gHIDCurrentDevice));
if (slotdata->hidmask == gHID_LIST_MOUSE) {
gHID_Mouse_Mode = HID_MOUSE_MODE_AIM;
}
} else {
if(HID_DEBUG) {
DEBUG_FUNCTION_LINE("We still have pad for deviceslot %d connected.",slotdata->deviceslot);
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("We still have pad for deviceslot %d connected.", slotdata->deviceslot);
}
}
if(HID_DEBUG) {
if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Device successfully detached");
}
}
@ -348,19 +348,18 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
return HID_DEVICE_DETACH;
}
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);
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);
//DEBUG_FUNCTION_LINE("my_read_cbInternal: %d %08X %d",bytes_transfered,usr->slotdata.hidmask,usr->slotdata.deviceslot);
if(usr->slotdata.hidmask == gHID_LIST_GC) {
if (usr->slotdata.hidmask == gHID_LIST_GC) {
HID_Data * data_ptr = NULL;
HID_Data *data_ptr = NULL;
//Copy the data for all 4 pads
for(int32_t i = 0; i<4; i++) {
for (int32_t i = 0; i < 4; 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.cur_hid_data[0]),&buf[(i*9)+1],9); //save new 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.
}
/*
@ -369,13 +368,13 @@ void ControllerPatcherHID::HIDReadCallback(uint32_t handle, unsigned char *buf,
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("GC4 %08X: %02X %02X %02X %02X %02X %02X %02X %02X %02X \n", 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]);*/
HIDGCRumble(handle,usr);
} else if(usr->slotdata.hidmask != 0) {
HIDGCRumble(handle, usr);
} else if (usr->slotdata.hidmask != 0) {
//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.
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) {
uint8_t buffer[0x13];
memcpy(buffer,buf+0x0D,0x013);
memcpy(buffer, buf + 0x0D, 0x013);
/**
Thanks to ShinyQuagsire23 for the values (https://github.com/shinyquagsire23/HID-Joy-Con-Whispering)
@ -390,65 +389,65 @@ void ControllerPatcherHID::HIDReadCallback(uint32_t handle, unsigned char *buf,
buf[7] = 0x00;
buf[8] = 0x1F;
//We want to get the next input!
int32_t 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(buffer[1] == 0) return;
if (res == 9) { //Check if it's the USB data format.
if (buffer[1] == 0) return;
//Converting the buttons
uint32_t buttons = (((uint32_t*)(buffer))[0]) & 0xFFFFFF00;
uint32_t buttons = (((uint32_t *) (buffer))[0]) & 0xFFFFFF00;
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_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_Y_VALUE) == HID_SWITCH_PRO_USB_BUTTON_Y_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_Y_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_X_VALUE) == HID_SWITCH_PRO_USB_BUTTON_X_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_X_VALUE;
if ((buttons & HID_SWITCH_PRO_USB_BUTTON_Y_VALUE) == HID_SWITCH_PRO_USB_BUTTON_Y_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_Y_VALUE;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_PLUS_VALUE) == HID_SWITCH_PRO_USB_BUTTON_PLUS_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_PLUS_VALUE;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_MINUS_VALUE) == HID_SWITCH_PRO_USB_BUTTON_MINUS_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_MINUS_VALUE;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_HOME_VALUE) == HID_SWITCH_PRO_USB_BUTTON_HOME_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_HOME_VALUE;
if ((buttons & HID_SWITCH_PRO_USB_BUTTON_PLUS_VALUE) == HID_SWITCH_PRO_USB_BUTTON_PLUS_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_PLUS_VALUE;
if ((buttons & HID_SWITCH_PRO_USB_BUTTON_MINUS_VALUE) == HID_SWITCH_PRO_USB_BUTTON_MINUS_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_MINUS_VALUE;
if ((buttons & HID_SWITCH_PRO_USB_BUTTON_HOME_VALUE) == HID_SWITCH_PRO_USB_BUTTON_HOME_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_HOME_VALUE;
//if((buttons & SWITCH_PRO_USB_BUTTON_SCREENSHOT) == HID_SWITCH_PRO_USB_BUTTON_SCREENSHOT) newButtons |= HID_SWITCH_PRO_BT_BUTTON_SCREENSHOT;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_R_VALUE) == HID_SWITCH_PRO_USB_BUTTON_R_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_R_VALUE;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_ZR_VALUE) == HID_SWITCH_PRO_USB_BUTTON_ZR_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_ZR_VALUE;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_STICK_R_VALUE) == HID_SWITCH_PRO_USB_BUTTON_STICK_R_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_STICK_R_VALUE;
if ((buttons & HID_SWITCH_PRO_USB_BUTTON_R_VALUE) == HID_SWITCH_PRO_USB_BUTTON_R_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_R_VALUE;
if ((buttons & HID_SWITCH_PRO_USB_BUTTON_ZR_VALUE) == HID_SWITCH_PRO_USB_BUTTON_ZR_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_ZR_VALUE;
if ((buttons & HID_SWITCH_PRO_USB_BUTTON_STICK_R_VALUE) == HID_SWITCH_PRO_USB_BUTTON_STICK_R_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_STICK_R_VALUE;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_L_VALUE) == HID_SWITCH_PRO_USB_BUTTON_L_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_L_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_L_VALUE) == HID_SWITCH_PRO_USB_BUTTON_L_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_L_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;
uint8_t dpad = buffer[2];
uint8_t dpad = buffer[2];
uint8_t dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_NEUTRAL_VALUE;
//Converting the DPAD
if(((dpad & HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) == HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) &&
((dpad & HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE)) {
if (((dpad & HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) == HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) &&
((dpad & HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE)) {
dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_NE_VALUE;
} else if(((dpad & HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) == HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) &&
((dpad & HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE)) {
} else if (((dpad & HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) == HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) &&
((dpad & HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE)) {
dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_SE_VALUE;
} else if(((dpad & HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) == HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) &&
((dpad & HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE)) {
} else if (((dpad & HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) == HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) &&
((dpad & HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE)) {
dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_SW_VALUE;
} else if(((dpad & HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) == HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) &&
((dpad & HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE)) {
} else if (((dpad & HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) == HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) &&
((dpad & HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE)) {
dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_NW_VALUE;
} else if((dpad & HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) == HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) {
} else if ((dpad & HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) == HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) {
dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_N_VALUE;
} else if((dpad & HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE) {
} else if ((dpad & HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE) {
dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_E_VALUE;
} else if((dpad & HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) == HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) {
} else if ((dpad & HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) == HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) {
dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_S_VALUE;
} else if((dpad & HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE) {
} else if ((dpad & HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE) {
dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_W_VALUE;
}
//Converting the stick data
uint8_t LX = (uint8_t) ((uint16_t) ((buffer[0x04] << 8 &0xFF00) | (((uint16_t)buffer[0x03])&0xFF)) >> 0x04);
uint8_t LY = (uint8_t)((buffer[0x05] *-1));
uint8_t RX = (uint8_t) ((uint16_t) ((buffer[0x07] << 8 &0xFF00) | (((uint16_t)buffer[0x06])&0xFF)) >> 0x04);
uint8_t RY = (uint8_t)((buffer[0x08] *-1));
uint8_t LX = (uint8_t) ((uint16_t) ((buffer[0x04] << 8 & 0xFF00) | (((uint16_t) buffer[0x03]) & 0xFF)) >> 0x04);
uint8_t LY = (uint8_t) ((buffer[0x05] * -1));
uint8_t RX = (uint8_t) ((uint16_t) ((buffer[0x07] << 8 & 0xFF00) | (((uint16_t) buffer[0x06]) & 0xFF)) >> 0x04);
uint8_t RY = (uint8_t) ((buffer[0x08] * -1));
buf[0] = (newButtons >> 24) & 0xFF;
buf[1] = (newButtons >> 16) & 0xFF;
buf[0] = (newButtons >> 24) & 0xFF;
buf[1] = (newButtons >> 16) & 0xFF;
buf[2] |= dpadResult;
buf[4] = LX;
buf[6] = LY;
@ -457,33 +456,33 @@ void ControllerPatcherHID::HIDReadCallback(uint32_t handle, unsigned char *buf,
}
}
int32_t dsize = (HID_MAX_DATA_LENGTH_PER_PAD > bytes_transfered)? bytes_transfered : HID_MAX_DATA_LENGTH_PER_PAD;
int32_t skip = 0;
int32_t dsize = (HID_MAX_DATA_LENGTH_PER_PAD > bytes_transfered) ? bytes_transfered : HID_MAX_DATA_LENGTH_PER_PAD;
int32_t skip = 0;
//Input filter
if( config_controller[usr->slotdata.deviceslot][CONTRPS_INPUT_FILTER][0] != CONTROLLER_PATCHER_INVALIDVALUE) {
if(buf[config_controller[usr->slotdata.deviceslot][CONTRPS_INPUT_FILTER][0]] != config_controller[usr->slotdata.deviceslot][CONTRPS_INPUT_FILTER][1]) {
if (config_controller[usr->slotdata.deviceslot][CONTRPS_INPUT_FILTER][0] != CONTROLLER_PATCHER_INVALIDVALUE) {
if (buf[config_controller[usr->slotdata.deviceslot][CONTRPS_INPUT_FILTER][0]] != config_controller[usr->slotdata.deviceslot][CONTRPS_INPUT_FILTER][1]) {
skip = 1;
}
}
if(!skip) {
if (!skip) {
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 += ControllerPatcherUtils::getPadSlotInAdapter(usr->slotdata.deviceslot,buf); // If the controller has multiple slots, we need to use the right one.
slot += ControllerPatcherUtils::getPadSlotInAdapter(usr->slotdata.deviceslot, buf); // If the controller has multiple slots, we need to use the right one.
HID_Data * data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[slot]);
HID_Data *data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[slot]);
memcpy(&(data_ptr->data_union.controller.last_hid_data[0]),&(data_ptr->data_union.controller.cur_hid_data[0]),dsize); // save the last data.
memcpy(&(data_ptr->data_union.controller.cur_hid_data[0]),&buf[0],dsize); // save the new data.
memcpy(&(data_ptr->data_union.controller.last_hid_data[0]), &(data_ptr->data_union.controller.cur_hid_data[0]), dsize); // save the last data.
memcpy(&(data_ptr->data_union.controller.cur_hid_data[0]), &buf[0], dsize); // save the new data.
DCFlushRange(&gHID_Devices[usr->slotdata.deviceslot].pad_data[slot],sizeof(HID_Data));
DCFlushRange(&gHID_Devices[usr->slotdata.deviceslot].pad_data[slot], sizeof(HID_Data));
data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[slot]);
HIDRumble(handle,usr,slot);
HIDRumble(handle, usr, slot);
}
}
}
@ -492,17 +491,17 @@ void ControllerPatcherHID::HIDReadCallback(uint32_t handle, unsigned char *buf,
* Other functions
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherHID::setVPADControllerData(VPADStatus * buffer,std::vector<HID_Data *>& data) {
if(buffer == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
HID_Data * data_cur;
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherHID::setVPADControllerData(VPADStatus *buffer, std::vector<HID_Data *> &data) {
if (buffer == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
HID_Data *data_cur;
int32_t buttons_hold;
for(uint32_t i = 0; i<data.size(); i++) {
for (uint32_t i = 0; i < data.size(); i++) {
data_cur = data[i];
if(data_cur->slotdata.hidmask & gHID_LIST_MOUSE) { //Reset the input when we have no new inputs
HID_Mouse_Data * mouse_data = &data_cur->data_union.mouse.cur_mouse_data;
if(mouse_data->valuedChanged == 1) { //Fix for the mouse cursor
if (data_cur->slotdata.hidmask & gHID_LIST_MOUSE) { //Reset the input when we have no new inputs
HID_Mouse_Data *mouse_data = &data_cur->data_union.mouse.cur_mouse_data;
if (mouse_data->valuedChanged == 1) { //Fix for the mouse cursor
mouse_data->valuedChanged = 0;
} else {
mouse_data->deltaX = 0;
@ -511,49 +510,49 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherHID::setVPADControllerData(V
}
buttons_hold = 0;
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_A);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_B);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_X);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_Y);
ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_A);
ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_B);
ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_X);
ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_Y);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_LEFT);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_RIGHT);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_DOWN);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_UP);
ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_LEFT);
ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_RIGHT);
ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_DOWN);
ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_UP);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_MINUS);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_L);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_R);
ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_MINUS);
ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_L);
ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_R);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_PLUS);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_ZL);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_ZR);
ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_PLUS);
ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_ZL);
ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_ZR);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_HOME);
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_HOME);
ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_STICK_L);
ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_STICK_R);
uint32_t last_emulate_stick = (data_cur->last_buttons) & VPAD_MASK_EMULATED_STICKS; // We should only need the emulated stick data.
int32_t last_realbuttons = (data_cur->last_buttons) & VPAD_MASK_BUTTONS;
uint32_t last_emulate_stick = (data_cur->last_buttons) & VPAD_MASK_EMULATED_STICKS; // We should only need the emulated stick data.
int32_t last_realbuttons = (data_cur->last_buttons) & VPAD_MASK_BUTTONS;
buffer->hold |= buttons_hold;
buffer->trigger |= (buttons_hold & (~last_realbuttons));
buffer->release |= (last_realbuttons & (~buttons_hold));
ControllerPatcherUtils::convertAnalogSticks(data_cur,buffer);
ControllerPatcherUtils::convertAnalogSticks(data_cur, buffer);
ControllerPatcherUtils::setEmulatedSticks(buffer,&last_emulate_stick);
ControllerPatcherUtils::setEmulatedSticks(buffer, &last_emulate_stick);
ControllerPatcherUtils::checkAndSetMouseMode(data_cur);
ControllerPatcherUtils::setTouch(data_cur,buffer);
ControllerPatcherUtils::setTouch(data_cur, buffer);
data_cur->last_buttons = buttons_hold & VPAD_MASK_BUTTONS;
data_cur->last_buttons |= last_emulate_stick;
}
// Caculates a valid stick position
if(data.size() > 0) {
if (data.size() > 0) {
ControllerPatcherUtils::normalizeStickValues(&buffer->leftStick);
ControllerPatcherUtils::normalizeStickValues(&buffer->rightStick);
}
@ -565,17 +564,17 @@ std::vector<HID_Data *> ControllerPatcherHID::getHIDDataAll() {
uint32_t hid = gHIDCurrentDevice;
std::vector<HID_Data *> data_list;
for(int32_t i = 0; i < gHIDMaxDevices; i++) {
if((hid & (1 << i)) != 0) {
for (int32_t i = 0; i < gHIDMaxDevices; i++) {
if ((hid & (1 << i)) != 0) {
uint32_t cur_hidmask = config_controller_hidmask[i];
for(int32_t pad = 0; pad < HID_MAX_PADS_COUNT; pad++) {
for (int32_t pad = 0; pad < HID_MAX_PADS_COUNT; pad++) {
int32_t res;
HID_Data * new_data = NULL;
if((res = ControllerPatcherHID::getHIDData(cur_hidmask,pad,&new_data)) < 0) { // Checks if the pad is invalid.
HID_Data *new_data = NULL;
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);
continue;
}
if(new_data != NULL) data_list.push_back(new_data);
if (new_data != NULL) data_list.push_back(new_data);
}
}
}
@ -585,26 +584,26 @@ std::vector<HID_Data *> ControllerPatcherHID::getHIDDataAll() {
/*
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(uint32_t hidmask, int32_t pad, HID_Data ** data) {
if(data == NULL) return CONTROLLER_PATCHER_ERROR_INVALID_BUFFER;
if(!(hidmask & gHIDCurrentDevice)) return CONTROLLER_PATCHER_ERROR_HID_NOT_CONNECTED;
if(pad < 0 && pad > 3) return CONTROLLER_PATCHER_ERROR_INVALID_CHAN;
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 (!(hidmask & gHIDCurrentDevice)) return CONTROLLER_PATCHER_ERROR_HID_NOT_CONNECTED;
if (pad < 0 && pad > 3) return CONTROLLER_PATCHER_ERROR_INVALID_CHAN;
int32_t device_slot = ControllerPatcherUtils::getDeviceSlot(hidmask);
if(device_slot < 0) {
if (device_slot < 0) {
return CONTROLLER_PATCHER_ERROR_DEVICE_SLOT_NOT_FOUND;
}
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) {
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;
pad = (pad/(pad_count))*pad_count;
if (pad_count > HID_MAX_PADS_COUNT) pad_count = HID_MAX_PADS_COUNT;
pad = (pad / (pad_count)) * pad_count;
}
int32_t 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;
}
@ -614,45 +613,45 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherHID::getHIDData(uint32_t hid
}
void ControllerPatcherHID::HIDGCRumble(uint32_t handle,my_cb_user *usr) {
if(usr == NULL) return;
if(!ControllerPatcher::isRumbleActivated()) return;
void ControllerPatcherHID::HIDGCRumble(uint32_t handle, my_cb_user *usr) {
if (usr == NULL) return;
if (!ControllerPatcher::isRumbleActivated()) return;
int32_t rumblechanged = 0;
for(int32_t i = 0; i<HID_GC_PAD_COUNT; i++) {
HID_Data * data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[i]);
if(data_ptr->rumbleActive != usr->rumblestatus[i]) {
for (int32_t i = 0; i < HID_GC_PAD_COUNT; i++) {
HID_Data *data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[i]);
if (data_ptr->rumbleActive != usr->rumblestatus[i]) {
rumblechanged = 1;
}
usr->rumblestatus[i] = data_ptr->rumbleActive;
usr->buf[i+1] = usr->rumblestatus[i];
usr->buf[i + 1] = usr->rumblestatus[i];
}
usr->forceRumbleInTicks[0]--;
if(rumblechanged || usr->forceRumbleInTicks[0] <= 0) {
if (rumblechanged || usr->forceRumbleInTicks[0] <= 0) {
usr->buf[0] = 0x11;
HIDWrite(handle, usr->buf, 5, NULL, NULL);
usr->forceRumbleInTicks[0] = 10;
}
}
void ControllerPatcherHID::HIDRumble(uint32_t handle,my_cb_user *usr,uint32_t pad) {
if(usr == NULL || pad > HID_MAX_PADS_COUNT) return;
if(!ControllerPatcher::isRumbleActivated()) return;
void ControllerPatcherHID::HIDRumble(uint32_t handle, my_cb_user *usr, uint32_t pad) {
if (usr == NULL || pad > HID_MAX_PADS_COUNT) return;
if (!ControllerPatcher::isRumbleActivated()) return;
int32_t rumblechanged = 0;
HID_Data * data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[pad]);
if(data_ptr->rumbleActive != usr->rumblestatus[pad]) {
HID_Data *data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[pad]);
if (data_ptr->rumbleActive != usr->rumblestatus[pad]) {
usr->rumblestatus[pad] = data_ptr->rumbleActive;
rumblechanged = 1;
rumblechanged = 1;
}
usr->forceRumbleInTicks[pad]--;
if(rumblechanged || usr->forceRumbleInTicks[pad] <= 0) {
if (rumblechanged || usr->forceRumbleInTicks[pad] <= 0) {
//DEBUG_FUNCTION_LINE("Rumble: %d %d",usr->rumblestatus[pad],usr->rumbleForce[pad]);
//Seding to the network client!
char bytes[6];
int32_t i = 0;
int32_t i = 0;
bytes[i++] = 0x01;
bytes[i++] = (handle >> 24) & 0xFF;
bytes[i++] = (handle >> 16) & 0xFF;
@ -660,14 +659,14 @@ void ControllerPatcherHID::HIDRumble(uint32_t handle,my_cb_user *usr,uint32_t pa
bytes[i++] = handle & 0xFF;
bytes[i++] = usr->rumblestatus[pad];
UDPClient * instance = UDPClient::getInstance();
if(instance != NULL) {
instance->sendData(bytes,6);
UDPClient *instance = UDPClient::getInstance();
if (instance != NULL) {
instance->sendData(bytes, 6);
}
if(usr->slotdata.hidmask == gHID_LIST_DS3) {
HIDDS3Rumble(handle,usr,usr->rumblestatus[pad]);
if (usr->slotdata.hidmask == gHID_LIST_DS3) {
HIDDS3Rumble(handle, usr, usr->rumblestatus[pad]);
} else {
// Not implemented for other devices =(
}
@ -676,19 +675,57 @@ void ControllerPatcherHID::HIDRumble(uint32_t handle,my_cb_user *usr,uint32_t pa
}
static uint8_t ds3_rumble_Report[48] = {
0x00, 0xFF, 0x00, 0xFF, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0x27, 0x10, 0x00, 0x32,
0xFF, 0x27, 0x10, 0x00, 0x32,
0xFF, 0x27, 0x10, 0x00, 0x32,
0xFF, 0x27, 0x10, 0x00, 0x32,
0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00,
0x00,
0xFF,
0x00,
0xFF,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0xFF,
0x27,
0x10,
0x00,
0x32,
0xFF,
0x27,
0x10,
0x00,
0x32,
0xFF,
0x27,
0x10,
0x00,
0x32,
0xFF,
0x27,
0x10,
0x00,
0x32,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
};
void ControllerPatcherHID::HIDDS3Rumble(uint32_t handle,my_cb_user *usr,int32_t rumble) {
void ControllerPatcherHID::HIDDS3Rumble(uint32_t handle, my_cb_user *usr, int32_t rumble) {
memcpy(usr->buf, ds3_rumble_Report, 48);
if (rumble) {

27
source/patcher/ControllerPatcherHID.hpp
View File

@ -32,35 +32,36 @@
#include "../ControllerPatcherIncludes.hpp"
//! Own definitions
#define VPAD_BUTTON_TOUCH 0x00080000
#define VPAD_MASK_EMULATED_STICKS 0x7F800000
#define VPAD_MASK_BUTTONS ~VPAD_MASK_EMULATED_STICKS
#define VPAD_BUTTON_TOUCH 0x00080000
#define VPAD_MASK_EMULATED_STICKS 0x7F800000
#define VPAD_MASK_BUTTONS ~VPAD_MASK_EMULATED_STICKS
#define SWAP16(x) ((x>>8) | ((x&0xFF)<<8))
#define SWAP8(x) ((x>>4) | ((x&0xF)<<4))
#define SWAP16(x) ((x >> 8) | ((x & 0xFF) << 8))
#define SWAP8(x) ((x >> 4) | ((x & 0xF) << 4))
class ControllerPatcherHID {
friend class ControllerPatcher;
friend class ControllerPatcherUtils;
public:
static int32_t externAttachDetachCallback(HIDDevice *p_device, HIDAttachEvent attach);
static void externHIDReadCallback(uint32_t handle, unsigned char *buf, uint32_t bytes_transfered, my_cb_user * usr);
static int32_t externAttachDetachCallback(HIDDevice *p_device, HIDAttachEvent attach);
static void externHIDReadCallback(uint32_t handle, unsigned char *buf, uint32_t bytes_transfered, my_cb_user *usr);
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 CONTROLLER_PATCHER_RESULT_OR_ERROR getHIDData(uint32_t hidmask, int32_t pad, HID_Data ** data);
static CONTROLLER_PATCHER_RESULT_OR_ERROR getHIDData(uint32_t hidmask, int32_t pad, HID_Data **data);
/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Rumble
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
static void HIDRumble(uint32_t handle,my_cb_user *usr,uint32_t pad);
static void HIDRumble(uint32_t handle, my_cb_user *usr, uint32_t pad);
static void HIDGCRumble(uint32_t handle,my_cb_user *usr);
static void HIDGCRumble(uint32_t handle, my_cb_user *usr);
static void HIDDS3Rumble(uint32_t handle,my_cb_user *usr,int32_t rumble);
static void HIDDS3Rumble(uint32_t handle, my_cb_user *usr, int32_t rumble);
/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* HID Callbacks
@ -71,7 +72,7 @@ private:
static void myHIDReadCallback(uint32_t handle, int32_t error, unsigned char *buf, uint32_t bytes_transfered, void *p_user);
static int32_t AttachDetachCallback(HIDClient *p_client, HIDDevice *p_device, HIDAttachEvent attach);
static void HIDReadCallback(uint32_t handle, unsigned char *buf, uint32_t 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_ */

813
source/patcher/ControllerPatcherUtils.cpp
View File

File diff suppressed because it is too large Load Diff

49
source/patcher/ControllerPatcherUtils.hpp
View File

@ -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 **.
**/
static CONTROLLER_PATCHER_RESULT_OR_ERROR getDataByHandle(int32_t 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.
@ -66,7 +66,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 DeviceVIDPIDInfo *.
**/
static CONTROLLER_PATCHER_RESULT_OR_ERROR getVIDPIDbyDeviceSlot(int32_t 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.
*
@ -76,7 +76,8 @@ public:
* \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,uint32_t * lastButtonsPressesVPAD);
static CONTROLLER_PATCHER_RESULT_OR_ERROR translateToVPAD(VPADStatus *vpad_buffer, KPADStatus *pro_buffer, uint32_t *lastButtonsPressesVPAD);
private:
/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Analyse inputs
@ -90,7 +91,7 @@ private:
* \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, int32_t * buttons_hold, int32_t 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.
@ -100,7 +101,7 @@ private:
* \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,int32_t 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.
@ -110,7 +111,7 @@ private:
* \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,int32_t key);
static CONTROLLER_PATCHER_RESULT_OR_ERROR isInKeyboardData(unsigned char *keyboardData, int32_t key);
/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Utils for setting the Button data
@ -126,7 +127,7 @@ private:
* \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,uint32_t VPADButton, int32_t 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
@ -139,7 +140,7 @@ private:
\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,uint32_t oldVPADButton,uint32_t newVPADButton);
static CONTROLLER_PATCHER_RESULT_OR_ERROR setButtonData(VPADStatus *old_buffer, VPADStatus *new_buffer, uint32_t oldVPADButton, uint32_t newVPADButton);
/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Pad Status functions
@ -152,7 +153,7 @@ private:
\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(uint32_t hidmask,int32_t 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.
@ -173,7 +174,7 @@ private:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
**/
static CONTROLLER_PATCHER_RESULT_OR_ERROR normalizeStickValues(VPADVec2D * stick);
static CONTROLLER_PATCHER_RESULT_OR_ERROR normalizeStickValues(VPADVec2D *stick);
/**
\brief Converts the digital absolute stick data into a float value. It also applies the deadzones, and can invert the result.
@ -187,7 +188,7 @@ private:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
**/
static float convertAnalogValue(uint8_t value, uint8_t default_val, uint8_t min, uint8_t max, uint8_t invert,uint8_t 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.
@ -206,7 +207,7 @@ private:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
**/
static CONTROLLER_PATCHER_RESULT_OR_ERROR convertAnalogSticks(HID_Data * data,VPADStatus * buffer);
static CONTROLLER_PATCHER_RESULT_OR_ERROR convertAnalogSticks(HID_Data *data, VPADStatus *buffer);
/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Mouse functions
@ -220,7 +221,7 @@ private:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
**/
static CONTROLLER_PATCHER_RESULT_OR_ERROR setTouch(HID_Data * data,VPADStatus * buffer);
static CONTROLLER_PATCHER_RESULT_OR_ERROR setTouch(HID_Data *data, VPADStatus *buffer);
/** \brief Checks if the mouse mode needs to be changed. Sets it to the new mode if necessary.
* Currently the incoming data needs to be from a keyboard.
@ -229,7 +230,7 @@ private:
* \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
*
*/
static CONTROLLER_PATCHER_RESULT_OR_ERROR checkAndSetMouseMode(HID_Data * data);
static CONTROLLER_PATCHER_RESULT_OR_ERROR checkAndSetMouseMode(HID_Data *data);
/**
\brief Set the emulated sticks for a given VPAD data.
@ -239,7 +240,7 @@ private:
\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, uint32_t * last_emulatedSticks);
static CONTROLLER_PATCHER_RESULT_OR_ERROR setEmulatedSticks(VPADStatus *buffer, uint32_t *last_emulatedSticks);
/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Other functions
@ -252,8 +253,8 @@ private:
* \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, uint32_t * lastButtonsPressesPRO);
static CONTROLLER_PATCHER_RESULT_OR_ERROR translateToProWPADRead(VPADStatus * vpad_buffer,WPADStatusProController * pro_buffer);
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);
/**
\brief Checks if the value at the given device + CONTRPS slot equals the expected value.
@ -264,7 +265,7 @@ private:
\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(int32_t device_slot,int32_t CONTRPS_slot,int32_t expectedValue);
static CONTROLLER_PATCHER_RESULT_OR_ERROR checkValueinConfigController(int32_t device_slot, int32_t CONTRPS_slot, int32_t expectedValue);
/**
\brief Sets two uint8_t values to the given pointer.
@ -273,7 +274,7 @@ private:
\param first: Value that will be written in @p dest[0]
\param second: Value that will be written in @p dest[1]
**/
static void setConfigValue(uint8_t * dest , uint8_t first, uint8_t 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
@ -282,7 +283,7 @@ private:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
**/
static CONTROLLER_PATCHER_RESULT_OR_ERROR getNextSlotData(HIDSlotData * slotdata);
static CONTROLLER_PATCHER_RESULT_OR_ERROR getNextSlotData(HIDSlotData *slotdata);
/**
\brief Fills up a given DeviceInfo, which provides a valid VID/PID, with HIDSlotData.
@ -291,7 +292,7 @@ private:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
**/
static CONTROLLER_PATCHER_RESULT_OR_ERROR getDeviceInfoFromVidPid(DeviceInfo * info);
static CONTROLLER_PATCHER_RESULT_OR_ERROR getDeviceInfoFromVidPid(DeviceInfo *info);
/**
\brief returns the internal slot number of the device. Some adapters have multiple slot and send the data for each one
@ -302,7 +303,7 @@ private:
\param current input data
\return The relative slot in the device
**/
static int32_t getPadSlotInAdapter(int32_t deviceslot, uint8_t * 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
@ -311,9 +312,9 @@ private:
\return pointer to ControllerMapping data, null is type was invalid
**/
static ControllerMappingPAD * getControllerMappingByType(UController_Type type);
static ControllerMappingPAD *getControllerMappingByType(UController_Type type);
static CONTROLLER_PATCHER_RESULT_OR_ERROR doSampling(uint16_t deviceslot,uint8_t 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, uint16_t deviceslot, uint8_t padslot, BOOL ignorePadSlot);
};

60
source/system/CThread.h
View File

@ -18,30 +18,27 @@
#define CTHREAD_H_
#include <malloc.h>
#include <unistd.h>
#include <coreinit/systeminfo.h>
#include <coreinit/thread.h>
#include <malloc.h>
#include <unistd.h>
class CThread {
public:
typedef void (* Callback)(CThread *thread, void *arg);
typedef void (*Callback)(CThread *thread, void *arg);
//! constructor
CThread(int32_t iAttr, int32_t iPriority = 16, int32_t iStackSize = 0x8000, CThread::Callback callback = NULL, void *callbackArg = NULL)
: pThread(NULL)
, pThreadStack(NULL)
, pCallback(callback)
, pCallbackArg(callbackArg) {
: pThread(NULL), pThreadStack(NULL), pCallback(callback), pCallbackArg(callbackArg) {
//! save attribute assignment
iAttributes = iAttr;
//! allocate the thread
pThread = (OSThread*)memalign(8, sizeof(OSThread));
pThread = (OSThread *) memalign(8, sizeof(OSThread));
//! allocate the stack
pThreadStack = (uint8_t *) memalign(0x20, iStackSize);
//! create the thread
if(pThread && pThreadStack)
OSCreateThread(pThread, &CThread::threadCallback, 1, (char*)this, pThreadStack+iStackSize, iStackSize, iPriority, iAttributes);
if (pThread && pThreadStack)
OSCreateThread(pThread, &CThread::threadCallback, 1, (char *) this, pThreadStack + iStackSize, iStackSize, iPriority, iAttributes);
}
//! destructor
@ -50,40 +47,40 @@ public:
}
static CThread *create(CThread::Callback callback, void *callbackArg, int32_t iAttr = eAttributeNone, int32_t iPriority = 16, int32_t iStackSize = 0x8000) {
return ( new CThread(iAttr, iPriority, iStackSize, callback, callbackArg) );
return (new CThread(iAttr, iPriority, iStackSize, callback, callbackArg));
}
//! Get thread ID
virtual void* getThread() const {
virtual void *getThread() const {
return pThread;
}
//! Thread entry function
virtual void executeThread(void) {
if(pCallback)
if (pCallback)
pCallback(this, pCallbackArg);
}
//! Suspend thread
virtual void suspendThread(void) {
if(isThreadSuspended()) return;
if(pThread) OSSuspendThread(pThread);
if (isThreadSuspended()) return;
if (pThread) OSSuspendThread(pThread);
}
//! Resume thread
virtual void resumeThread(void) {
if(!isThreadSuspended()) return;
if(pThread) OSResumeThread(pThread);
if (!isThreadSuspended()) return;
if (pThread) OSResumeThread(pThread);
}
//! Set thread priority
virtual void setThreadPriority(int prio) {
if(pThread) OSSetThreadPriority(pThread, prio);
if (pThread) OSSetThreadPriority(pThread, prio);
}
//! Check if thread is suspended
virtual BOOL isThreadSuspended(void) const {
if(pThread) return OSIsThreadSuspended(pThread);
if (pThread) return OSIsThreadSuspended(pThread);
return false;
}
//! Check if thread is terminated
virtual BOOL isThreadTerminated(void) const {
if(pThread) return OSIsThreadTerminated(pThread);
if (pThread) return OSIsThreadTerminated(pThread);
return false;
}
//! Check if thread is running
@ -93,30 +90,31 @@ public:
//! Shutdown thread
virtual void shutdownThread(void) {
//! wait for thread to finish
if(pThread && !(iAttributes & eAttributeDetach)) {
if(isThreadSuspended())
if (pThread && !(iAttributes & eAttributeDetach)) {
if (isThreadSuspended())
resumeThread();
OSJoinThread(pThread, NULL);
}
//! free the thread stack buffer
if(pThreadStack)
if (pThreadStack)
free(pThreadStack);
if(pThread)
if (pThread)
free(pThread);
pThread = NULL;
pThread = NULL;
pThreadStack = NULL;
}
//! Thread attributes
enum eCThreadAttributes {
eAttributeNone = 0x07,
eAttributeAffCore0 = 0x01,
eAttributeAffCore1 = 0x02,
eAttributeAffCore2 = 0x04,
eAttributeDetach = 0x08,
eAttributePinnedAff = 0x10
eAttributeNone = 0x07,
eAttributeAffCore0 = 0x01,
eAttributeAffCore1 = 0x02,
eAttributeAffCore2 = 0x04,
eAttributeDetach = 0x08,
eAttributePinnedAff = 0x10
};
private:
static int threadCallback(int argc, const char **argv) {
//! After call to start() continue with the internal function

37
source/utils/CPRetainVars.cpp
View File

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

2
source/utils/CPRetainVars.hpp
View File

@ -71,6 +71,6 @@ extern uint8_t gGlobalRumbleActivated;
extern uint8_t gNetworkControllerActivated;
extern uint32_t gUDPClientip;
extern ControllerMappingPADInfo* gProPadInfo[4];
extern ControllerMappingPADInfo *gProPadInfo[4];
#endif // CP_RETAINS_VARS_H_

503
source/utils/PadConst.cpp
View File

@ -17,12 +17,12 @@
#include "PadConst.hpp"
#include <wut.h>
const uint8_t DEF_R_STICK = 220;
const uint8_t DEF_L_STICK = 221;
const uint8_t DEF_R_STICK = 220;
const uint8_t DEF_L_STICK = 221;
const uint8_t DEF_STICK_OFFSET_INVERT = CONTRPS_VPAD_BUTTON_L_STICK_X_INVERT - CONTRPS_VPAD_BUTTON_L_STICK_X;
const uint8_t DEF_STICK_OFFSET_DEADZONE = CONTRPS_VPAD_BUTTON_L_STICK_X_DEADZONE - CONTRPS_VPAD_BUTTON_L_STICK_X;
const uint8_t DEF_STICK_OFFSET_MINMAX = CONTRPS_VPAD_BUTTON_L_STICK_X_MINMAX - CONTRPS_VPAD_BUTTON_L_STICK_X;
const uint8_t DEF_STICK_OFFSET_INVERT = CONTRPS_VPAD_BUTTON_L_STICK_X_INVERT - CONTRPS_VPAD_BUTTON_L_STICK_X;
const uint8_t DEF_STICK_OFFSET_DEADZONE = CONTRPS_VPAD_BUTTON_L_STICK_X_DEADZONE - CONTRPS_VPAD_BUTTON_L_STICK_X;
const uint8_t DEF_STICK_OFFSET_MINMAX = CONTRPS_VPAD_BUTTON_L_STICK_X_MINMAX - CONTRPS_VPAD_BUTTON_L_STICK_X;
//!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//! Device names
@ -40,323 +40,302 @@ const char *HID_SWITCH_PRO_STRING = "Switch\nPro Controller";
//! GC-Adapter
//!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
const uint8_t HID_GC_BUTTON_A[] = { 0x01,HID_GC_BUTTON_A_VALUE};
const uint8_t HID_GC_BUTTON_B[] = { 0x01,HID_GC_BUTTON_B_VALUE};
const uint8_t HID_GC_BUTTON_X[] = { 0x01,HID_GC_BUTTON_X_VALUE};
const uint8_t HID_GC_BUTTON_Y[] = { 0x01,HID_GC_BUTTON_Y_VALUE};
const uint8_t HID_GC_BUTTON_LEFT[] = { 0x01,HID_GC_BUTTON_LEFT_VALUE};
const uint8_t HID_GC_BUTTON_RIGHT[] = { 0x01,HID_GC_BUTTON_RIGHT_VALUE};
const uint8_t HID_GC_BUTTON_DOWN[] = { 0x01,HID_GC_BUTTON_DOWN_VALUE};
const uint8_t HID_GC_BUTTON_UP[] = { 0x01,HID_GC_BUTTON_UP_VALUE};
const uint8_t HID_GC_BUTTON_A[] = {0x01, HID_GC_BUTTON_A_VALUE};
const uint8_t HID_GC_BUTTON_B[] = {0x01, HID_GC_BUTTON_B_VALUE};
const uint8_t HID_GC_BUTTON_X[] = {0x01, HID_GC_BUTTON_X_VALUE};
const uint8_t HID_GC_BUTTON_Y[] = {0x01, HID_GC_BUTTON_Y_VALUE};
const uint8_t HID_GC_BUTTON_LEFT[] = {0x01, HID_GC_BUTTON_LEFT_VALUE};
const uint8_t HID_GC_BUTTON_RIGHT[] = {0x01, HID_GC_BUTTON_RIGHT_VALUE};
const uint8_t HID_GC_BUTTON_DOWN[] = {0x01, HID_GC_BUTTON_DOWN_VALUE};
const uint8_t HID_GC_BUTTON_UP[] = {0x01, HID_GC_BUTTON_UP_VALUE};
const uint8_t HID_GC_BUTTON_START[] = { 0x02,HID_GC_BUTTON_START_VALUE};
const uint8_t HID_GC_BUTTON_Z[] = { 0x02,HID_GC_BUTTON_Z_VALUE};
const uint8_t HID_GC_BUTTON_START[] = {0x02, HID_GC_BUTTON_START_VALUE};
const uint8_t HID_GC_BUTTON_Z[] = {0x02, HID_GC_BUTTON_Z_VALUE};
const uint8_t HID_GC_BUTTON_L[] = { 0x07,HID_GC_BUTTON_L_VALUE};
const uint8_t HID_GC_BUTTON_R[] = { 0x08,HID_GC_BUTTON_R_VALUE};
const uint8_t HID_GC_BUTTON_L[] = {0x07, HID_GC_BUTTON_L_VALUE};
const uint8_t HID_GC_BUTTON_R[] = {0x08, HID_GC_BUTTON_R_VALUE};
const uint8_t HID_GC_BUTTON_DPAD_TYPE[] = { CONTRPDM_Normal,0x00};
const uint8_t HID_GC_BUTTON_DPAD_TYPE[] = {CONTRPDM_Normal, 0x00};
const uint8_t HID_GC_STICK_L_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x03, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x09, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x1A, //STICK_CONF_MIN,
0xE4
};//STICK_CONF_MAX,
const uint8_t HID_GC_STICK_L_X[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x03, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x09, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x1A, //STICK_CONF_MIN,
0xE4}; //STICK_CONF_MAX,
const uint8_t HID_GC_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x04, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x09, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x11, //STICK_CONF_MIN,
0xE1
};//STICK_CONF_MAX,
const uint8_t HID_GC_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x04, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x09, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x11, //STICK_CONF_MIN,
0xE1}; //STICK_CONF_MAX,
const uint8_t HID_GC_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x05, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x09, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x2B, //STICK_CONF_MIN,
0xE2
};//STICK_CONF_MAX,
const uint8_t HID_GC_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x05, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x09, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x2B, //STICK_CONF_MIN,
0xE2}; //STICK_CONF_MAX,
const uint8_t HID_GC_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x06, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x09, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x1D, //STICK_CONF_MIN,
0xDB
};//STICK_CONF_MAX,
const uint8_t HID_GC_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x06, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x09, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x1D, //STICK_CONF_MIN,
0xDB}; //STICK_CONF_MAX,
//!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//! DS3
//!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
const uint8_t HID_DS3_BUTTON_CROSS[] = { 0x03,HID_DS3_BUTTON_CROSS_VALUE};
const uint8_t HID_DS3_BUTTON_CIRCLE[] = { 0x03,HID_DS3_BUTTON_CIRCLE_VALUE};
const uint8_t HID_DS3_BUTTON_SQUARE [] = { 0x03,HID_DS3_BUTTON_SQUARE_VALUE};
const uint8_t HID_DS3_BUTTON_TRIANGLE[] = { 0x03,HID_DS3_BUTTON_TRIANGLE_VALUE};
const uint8_t HID_DS3_BUTTON_CROSS[] = {0x03, HID_DS3_BUTTON_CROSS_VALUE};
const uint8_t HID_DS3_BUTTON_CIRCLE[] = {0x03, HID_DS3_BUTTON_CIRCLE_VALUE};
const uint8_t HID_DS3_BUTTON_SQUARE[] = {0x03, HID_DS3_BUTTON_SQUARE_VALUE};
const uint8_t HID_DS3_BUTTON_TRIANGLE[] = {0x03, HID_DS3_BUTTON_TRIANGLE_VALUE};
const uint8_t HID_DS3_BUTTON_L1[] = { 0x03,HID_DS3_BUTTON_L1_VALUE};
const uint8_t HID_DS3_BUTTON_L2[] = { 0x03,HID_DS3_BUTTON_L2_VALUE};
const uint8_t HID_DS3_BUTTON_R1[] = { 0x03,HID_DS3_BUTTON_R1_VALUE};
const uint8_t HID_DS3_BUTTON_R2[] = { 0x03,HID_DS3_BUTTON_R2_VALUE};
const uint8_t HID_DS3_BUTTON_L1[] = {0x03, HID_DS3_BUTTON_L1_VALUE};
const uint8_t HID_DS3_BUTTON_L2[] = {0x03, HID_DS3_BUTTON_L2_VALUE};
const uint8_t HID_DS3_BUTTON_R1[] = {0x03, HID_DS3_BUTTON_R1_VALUE};
const uint8_t HID_DS3_BUTTON_R2[] = {0x03, HID_DS3_BUTTON_R2_VALUE};
const uint8_t HID_DS3_BUTTON_L3[] = { 0x02,HID_DS3_BUTTON_L3_VALUE};
const uint8_t HID_DS3_BUTTON_R3[] = { 0x02,HID_DS3_BUTTON_R3_VALUE};
const uint8_t HID_DS3_BUTTON_SELECT[] = { 0x02,HID_DS3_BUTTON_SELECT_VALUE};
const uint8_t HID_DS3_BUTTON_START[] = { 0x02,HID_DS3_BUTTON_START_VALUE};
const uint8_t HID_DS3_BUTTON_LEFT[] = { 0x02,HID_DS3_BUTTON_LEFT_VALUE};
const uint8_t HID_DS3_BUTTON_RIGHT[] = { 0x02,HID_DS3_BUTTON_RIGHT_VALUE};
const uint8_t HID_DS3_BUTTON_UP[] = { 0x02,HID_DS3_BUTTON_UP_VALUE};
const uint8_t HID_DS3_BUTTON_DOWN[] = { 0x02,HID_DS3_BUTTON_DOWN_VALUE};
const uint8_t HID_DS3_BUTTON_L3[] = {0x02, HID_DS3_BUTTON_L3_VALUE};
const uint8_t HID_DS3_BUTTON_R3[] = {0x02, HID_DS3_BUTTON_R3_VALUE};
const uint8_t HID_DS3_BUTTON_SELECT[] = {0x02, HID_DS3_BUTTON_SELECT_VALUE};
const uint8_t HID_DS3_BUTTON_START[] = {0x02, HID_DS3_BUTTON_START_VALUE};
const uint8_t HID_DS3_BUTTON_LEFT[] = {0x02, HID_DS3_BUTTON_LEFT_VALUE};
const uint8_t HID_DS3_BUTTON_RIGHT[] = {0x02, HID_DS3_BUTTON_RIGHT_VALUE};
const uint8_t HID_DS3_BUTTON_UP[] = {0x02, HID_DS3_BUTTON_UP_VALUE};
const uint8_t HID_DS3_BUTTON_DOWN[] = {0x02, HID_DS3_BUTTON_DOWN_VALUE};
const uint8_t HID_DS3_BUTTON_GUIDE[] = { 0x04,HID_DS3_BUTTON_GUIDE_VALUE};
const uint8_t HID_DS3_BUTTON_GUIDE[] = {0x04, HID_DS3_BUTTON_GUIDE_VALUE};
const uint8_t HID_DS3_BUTTON_DPAD_TYPE[] = { CONTRPDM_Normal,0x00};
const uint8_t HID_DS3_BUTTON_DPAD_TYPE[] = {CONTRPDM_Normal, 0x00};
const uint8_t HID_DS3_STICK_L_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x06, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x06, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF
};//STICK_CONF_MAX,
const uint8_t HID_DS3_STICK_L_X[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x06, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x06, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF}; //STICK_CONF_MAX,
const uint8_t HID_DS3_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x07, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x06, //STICK_CONF_DEADZONE,
0x01, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF
};//STICK_CONF_MAX,
const uint8_t HID_DS3_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x07, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x06, //STICK_CONF_DEADZONE,
0x01, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF}; //STICK_CONF_MAX,
const uint8_t HID_DS3_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x08, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x06, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF
};//STICK_CONF_MAX,
const uint8_t HID_DS3_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x08, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x06, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF}; //STICK_CONF_MAX,
const uint8_t HID_DS3_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x09, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x06, //STICK_CONF_DEADZONE,
0x01, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF
};//STICK_CONF_MAX,
const uint8_t HID_DS3_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x09, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x06, //STICK_CONF_DEADZONE,
0x01, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF}; //STICK_CONF_MAX,
//!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//! DS4
//!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
const uint8_t HID_DS4_BUTTON_CROSS[] = { 0x05,HID_DS4_BUTTON_CROSS_VALUE};
const uint8_t HID_DS4_BUTTON_CIRCLE[] = { 0x05,HID_DS4_BUTTON_CIRCLE_VALUE};
const uint8_t HID_DS4_BUTTON_SQUARE [] = { 0x05,HID_DS4_BUTTON_SQUARE_VALUE};
const uint8_t HID_DS4_BUTTON_TRIANGLE[] = { 0x05,HID_DS4_BUTTON_TRIANGLE_VALUE};
const uint8_t HID_DS4_BUTTON_CROSS[] = {0x05, HID_DS4_BUTTON_CROSS_VALUE};
const uint8_t HID_DS4_BUTTON_CIRCLE[] = {0x05, HID_DS4_BUTTON_CIRCLE_VALUE};
const uint8_t HID_DS4_BUTTON_SQUARE[] = {0x05, HID_DS4_BUTTON_SQUARE_VALUE};
const uint8_t HID_DS4_BUTTON_TRIANGLE[] = {0x05, HID_DS4_BUTTON_TRIANGLE_VALUE};
const uint8_t HID_DS4_BUTTON_L1[] = { 0x06,HID_DS4_BUTTON_L1_VALUE};
const uint8_t HID_DS4_BUTTON_L2[] = { 0x06,HID_DS4_BUTTON_L2_VALUE};
const uint8_t HID_DS4_BUTTON_L3[] = { 0x06,HID_DS4_BUTTON_L3_VALUE};
const uint8_t HID_DS4_BUTTON_L1[] = {0x06, HID_DS4_BUTTON_L1_VALUE};
const uint8_t HID_DS4_BUTTON_L2[] = {0x06, HID_DS4_BUTTON_L2_VALUE};
const uint8_t HID_DS4_BUTTON_L3[] = {0x06, HID_DS4_BUTTON_L3_VALUE};
const uint8_t HID_DS4_BUTTON_R1[] = { 0x06,HID_DS4_BUTTON_R1_VALUE};
const uint8_t HID_DS4_BUTTON_R2[] = { 0x06,HID_DS4_BUTTON_R2_VALUE};
const uint8_t HID_DS4_BUTTON_R3[] = { 0x06,HID_DS4_BUTTON_R3_VALUE};
const uint8_t HID_DS4_BUTTON_R1[] = {0x06, HID_DS4_BUTTON_R1_VALUE};
const uint8_t HID_DS4_BUTTON_R2[] = {0x06, HID_DS4_BUTTON_R2_VALUE};
const uint8_t HID_DS4_BUTTON_R3[] = {0x06, HID_DS4_BUTTON_R3_VALUE};
const uint8_t HID_DS4_BUTTON_SHARE[] = { 0x06,HID_DS4_BUTTON_SHARE_VALUE};
const uint8_t HID_DS4_BUTTON_OPTIONS[] = { 0x06,HID_DS4_BUTTON_OPTIONS_VALUE};
const uint8_t HID_DS4_BUTTON_SHARE[] = {0x06, HID_DS4_BUTTON_SHARE_VALUE};
const uint8_t HID_DS4_BUTTON_OPTIONS[] = {0x06, HID_DS4_BUTTON_OPTIONS_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_TYPE[] = { CONTRPDM_Hat,HID_DS4_BUTTON_DPAD_MASK_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_N[] = { 0x05,HID_DS4_BUTTON_DPAD_N_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_NE[] = { 0x05,HID_DS4_BUTTON_DPAD_NE_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_E[] = { 0x05,HID_DS4_BUTTON_DPAD_E_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_SE[] = { 0x05,HID_DS4_BUTTON_DPAD_SE_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_S[] = { 0x05,HID_DS4_BUTTON_DPAD_S_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_SW[] = { 0x05,HID_DS4_BUTTON_DPAD_SW_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_W[] = { 0x05,HID_DS4_BUTTON_DPAD_W_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_NW[] = { 0x05,HID_DS4_BUTTON_DPAD_NW_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_NEUTRAL[] = { 0x05,HID_DS4_BUTTON_DPAD_NEUTRAL_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_TYPE[] = {CONTRPDM_Hat, HID_DS4_BUTTON_DPAD_MASK_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_N[] = {0x05, HID_DS4_BUTTON_DPAD_N_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_NE[] = {0x05, HID_DS4_BUTTON_DPAD_NE_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_E[] = {0x05, HID_DS4_BUTTON_DPAD_E_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_SE[] = {0x05, HID_DS4_BUTTON_DPAD_SE_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_S[] = {0x05, HID_DS4_BUTTON_DPAD_S_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_SW[] = {0x05, HID_DS4_BUTTON_DPAD_SW_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_W[] = {0x05, HID_DS4_BUTTON_DPAD_W_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_NW[] = {0x05, HID_DS4_BUTTON_DPAD_NW_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_NEUTRAL[] = {0x05, HID_DS4_BUTTON_DPAD_NEUTRAL_VALUE};
const uint8_t HID_DS4_BUTTON_GUIDE[] = { 0x07,HID_DS4_BUTTON_GUIDE_VALUE};
const uint8_t HID_DS4_BUTTON_T_PAD_CLICK[] = { 0x07,HID_DS4_BUTTON_T_PAD_CLICK_VALUE};
const uint8_t HID_DS4_BUTTON_GUIDE[] = {0x07, HID_DS4_BUTTON_GUIDE_VALUE};
const uint8_t HID_DS4_BUTTON_T_PAD_CLICK[] = {0x07, HID_DS4_BUTTON_T_PAD_CLICK_VALUE};
const uint8_t HID_DS4_STICK_L_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x01, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x06, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF
};//STICK_CONF_MAX,
const uint8_t HID_DS4_STICK_L_X[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x01, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x06, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF}; //STICK_CONF_MAX,
const uint8_t HID_DS4_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x02, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x05, //STICK_CONF_DEADZONE,
0x01, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF
};//STICK_CONF_MAX,
const uint8_t HID_DS4_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x02, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x05, //STICK_CONF_DEADZONE,
0x01, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF}; //STICK_CONF_MAX,
const uint8_t HID_DS4_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x03, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x07, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF
};//STICK_CONF_MAX,
const uint8_t HID_DS4_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x03, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x07, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF}; //STICK_CONF_MAX,
const uint8_t HID_DS4_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x04, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x09, //STICK_CONF_DEADZONE,
0x01, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF
};//STICK_CONF_MAX,
const uint8_t HID_DS4_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x04, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x09, //STICK_CONF_DEADZONE,
0x01, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF}; //STICK_CONF_MAX,
//!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//! XInput
//!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
const uint8_t HID_XINPUT_BUTTON_A[] = { 0x07,HID_XINPUT_BUTTON_A_VALUE};
const uint8_t HID_XINPUT_BUTTON_B[] = { 0x07,HID_XINPUT_BUTTON_B_VALUE};
const uint8_t HID_XINPUT_BUTTON_X[] = { 0x07,HID_XINPUT_BUTTON_X_VALUE};
const uint8_t HID_XINPUT_BUTTON_Y[] = { 0x07,HID_XINPUT_BUTTON_Y_VALUE};
const uint8_t HID_XINPUT_BUTTON_A[] = {0x07, HID_XINPUT_BUTTON_A_VALUE};
const uint8_t HID_XINPUT_BUTTON_B[] = {0x07, HID_XINPUT_BUTTON_B_VALUE};
const uint8_t HID_XINPUT_BUTTON_X[] = {0x07, HID_XINPUT_BUTTON_X_VALUE};
const uint8_t HID_XINPUT_BUTTON_Y[] = {0x07, HID_XINPUT_BUTTON_Y_VALUE};
const uint8_t HID_XINPUT_BUTTON_LB[] = { 0x06,HID_XINPUT_BUTTON_LB_VALUE};
const uint8_t HID_XINPUT_BUTTON_LT[] = { 0x04,HID_XINPUT_BUTTON_LT_VALUE};
const uint8_t HID_XINPUT_BUTTON_L3[] = { 0x06,HID_XINPUT_BUTTON_L3_VALUE};
const uint8_t HID_XINPUT_BUTTON_LB[] = {0x06, HID_XINPUT_BUTTON_LB_VALUE};
const uint8_t HID_XINPUT_BUTTON_LT[] = {0x04, HID_XINPUT_BUTTON_LT_VALUE};
const uint8_t HID_XINPUT_BUTTON_L3[] = {0x06, HID_XINPUT_BUTTON_L3_VALUE};
const uint8_t HID_XINPUT_BUTTON_RB[] = { 0x06,HID_XINPUT_BUTTON_RB_VALUE};
const uint8_t HID_XINPUT_BUTTON_RT[] = { 0x05,HID_XINPUT_BUTTON_RT_VALUE};
const uint8_t HID_XINPUT_BUTTON_R3[] = { 0x06,HID_XINPUT_BUTTON_R3_VALUE};
const uint8_t HID_XINPUT_BUTTON_RB[] = {0x06, HID_XINPUT_BUTTON_RB_VALUE};
const uint8_t HID_XINPUT_BUTTON_RT[] = {0x05, HID_XINPUT_BUTTON_RT_VALUE};
const uint8_t HID_XINPUT_BUTTON_R3[] = {0x06, HID_XINPUT_BUTTON_R3_VALUE};
const uint8_t HID_XINPUT_BUTTON_START[] = { 0x06,HID_XINPUT_BUTTON_START_VALUE};
const uint8_t HID_XINPUT_BUTTON_BACK[] = { 0x06,HID_XINPUT_BUTTON_BACK_VALUE};
const uint8_t HID_XINPUT_BUTTON_GUIDE[] = { 0x06,HID_XINPUT_BUTTON_GUIDE_VALUE};
const uint8_t HID_XINPUT_BUTTON_START[] = {0x06, HID_XINPUT_BUTTON_START_VALUE};
const uint8_t HID_XINPUT_BUTTON_BACK[] = {0x06, HID_XINPUT_BUTTON_BACK_VALUE};
const uint8_t HID_XINPUT_BUTTON_GUIDE[] = {0x06, HID_XINPUT_BUTTON_GUIDE_VALUE};
const uint8_t HID_XINPUT_BUTTON_DPAD_TYPE[] = { CONTRPDM_Normal,HID_XINPUT_BUTTON_DPAD_MASK_VALUE};
const uint8_t HID_XINPUT_BUTTON_LEFT[] = { 0x07,HID_XINPUT_BUTTON_LEFT_VALUE};
const uint8_t HID_XINPUT_BUTTON_RIGHT[] = { 0x07,HID_XINPUT_BUTTON_RIGHT_VALUE};
const uint8_t HID_XINPUT_BUTTON_DOWN[] = { 0x07,HID_XINPUT_BUTTON_DOWN_VALUE};
const uint8_t HID_XINPUT_BUTTON_UP[] = { 0x07,HID_XINPUT_BUTTON_UP_VALUE};
const uint8_t HID_XINPUT_BUTTON_DPAD_TYPE[] = {CONTRPDM_Normal, HID_XINPUT_BUTTON_DPAD_MASK_VALUE};
const uint8_t HID_XINPUT_BUTTON_LEFT[] = {0x07, HID_XINPUT_BUTTON_LEFT_VALUE};
const uint8_t HID_XINPUT_BUTTON_RIGHT[] = {0x07, HID_XINPUT_BUTTON_RIGHT_VALUE};
const uint8_t HID_XINPUT_BUTTON_DOWN[] = {0x07, HID_XINPUT_BUTTON_DOWN_VALUE};
const uint8_t HID_XINPUT_BUTTON_UP[] = {0x07, HID_XINPUT_BUTTON_UP_VALUE};
const uint8_t HID_XINPUT_STICK_L_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x00, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x10, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF
};//STICK_CONF_MAX,
const uint8_t HID_XINPUT_STICK_L_X[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x00, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x10, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF}; //STICK_CONF_MAX,
const uint8_t HID_XINPUT_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x01, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x10, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF
};//STICK_CONF_MAX,
const uint8_t HID_XINPUT_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x01, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x10, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF}; //STICK_CONF_MAX,
const uint8_t HID_XINPUT_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x02, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x10, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF
};//STICK_CONF_MAX,
const uint8_t HID_XINPUT_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x03, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x10, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF
};//STICK_CONF_MAX,
const uint8_t HID_XINPUT_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x02, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x10, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF}; //STICK_CONF_MAX,
const uint8_t HID_XINPUT_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x03, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x10, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN,
0xFF}; //STICK_CONF_MAX,
//!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//! Switch Pro Controller
//!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
const uint8_t HID_SWITCH_PRO_BT_BUTTON_A[] = { 0x00,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_A_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_B[] = { 0x00,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_B_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_X[] = { 0x00,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_X_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_Y[] = { 0x00,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_Y_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_A[] = {0x00, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_A_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_B[] = {0x00, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_B_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_X[] = {0x00, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_X_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_Y[] = {0x00, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_Y_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_L[] = { 0x00,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_L_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_ZL[] = { 0x00,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_ZL_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_STICK_L[] = { 0x01,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_STICK_L_VALUE >> 16) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_L[] = {0x00, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_L_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_ZL[] = {0x00, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_ZL_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_STICK_L[] = {0x01, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_STICK_L_VALUE >> 16) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_R[] = { 0x00,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_R_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_ZR[] = { 0x00,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_ZR_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_STICK_R[] = { 0x01,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_STICK_R_VALUE >> 16) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_R[] = {0x00, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_R_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_ZR[] = {0x00, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_ZR_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_STICK_R[] = {0x01, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_STICK_R_VALUE >> 16) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_PLUS[] = { 0x01,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_PLUS_VALUE >> 16) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_MINUS[] = { 0x01,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_MINUS_VALUE >> 16) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_HOME[] = { 0x01,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_HOME_VALUE >> 16) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_PLUS[] = {0x01, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_PLUS_VALUE >> 16) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_MINUS[] = {0x01, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_MINUS_VALUE >> 16) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_HOME[] = {0x01, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_HOME_VALUE >> 16) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_TYPE[] = { CONTRPDM_Hat,HID_SWITCH_PRO_BT_BUTTON_DPAD_MASK_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_N[] = { 0x02,HID_SWITCH_PRO_BT_BUTTON_DPAD_N_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_NE[] = { 0x02,HID_SWITCH_PRO_BT_BUTTON_DPAD_NE_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_E[] = { 0x02,HID_SWITCH_PRO_BT_BUTTON_DPAD_E_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_SE[] = { 0x02,HID_SWITCH_PRO_BT_BUTTON_DPAD_SE_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_S[] = { 0x02,HID_SWITCH_PRO_BT_BUTTON_DPAD_S_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_SW[] = { 0x02,HID_SWITCH_PRO_BT_BUTTON_DPAD_SW_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_W[] = { 0x02,HID_SWITCH_PRO_BT_BUTTON_DPAD_W_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_NW[] = { 0x02,HID_SWITCH_PRO_BT_BUTTON_DPAD_NW_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_NEUTRAL[] = { 0x02,HID_SWITCH_PRO_BT_BUTTON_DPAD_NEUTRAL_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_TYPE[] = {CONTRPDM_Hat, HID_SWITCH_PRO_BT_BUTTON_DPAD_MASK_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_N[] = {0x02, HID_SWITCH_PRO_BT_BUTTON_DPAD_N_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_NE[] = {0x02, HID_SWITCH_PRO_BT_BUTTON_DPAD_NE_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_E[] = {0x02, HID_SWITCH_PRO_BT_BUTTON_DPAD_E_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_SE[] = {0x02, HID_SWITCH_PRO_BT_BUTTON_DPAD_SE_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_S[] = {0x02, HID_SWITCH_PRO_BT_BUTTON_DPAD_S_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_SW[] = {0x02, HID_SWITCH_PRO_BT_BUTTON_DPAD_SW_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_W[] = {0x02, HID_SWITCH_PRO_BT_BUTTON_DPAD_W_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_NW[] = {0x02, HID_SWITCH_PRO_BT_BUTTON_DPAD_NW_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_NEUTRAL[] = {0x02, HID_SWITCH_PRO_BT_BUTTON_DPAD_NEUTRAL_VALUE};
const uint8_t HID_SWITCH_PRO_BT_STICK_L_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x04, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x01, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x28, //STICK_CONF_MIN,
0xDF
};//STICK_CONF_MAX,
const uint8_t HID_SWITCH_PRO_BT_STICK_L_X[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x04, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x01, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x28, //STICK_CONF_MIN,
0xDF}; //STICK_CONF_MAX,
const uint8_t HID_SWITCH_PRO_BT_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x06, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x06, //STICK_CONF_DEADZONE,
0x01, //STICK_CONF_INVERT,
0x16, //STICK_CONF_MIN,
0xD7
};//STICK_CONF_MAX,
const uint8_t HID_SWITCH_PRO_BT_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x06, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x06, //STICK_CONF_DEADZONE,
0x01, //STICK_CONF_INVERT,
0x16, //STICK_CONF_MIN,
0xD7}; //STICK_CONF_MAX,
const uint8_t HID_SWITCH_PRO_BT_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x08, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x04, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x29, //STICK_CONF_MIN,
0xE2
};//STICK_CONF_MAX,
const uint8_t HID_SWITCH_PRO_BT_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x08, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x04, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT,
0x29, //STICK_CONF_MIN,
0xE2}; //STICK_CONF_MAX,
const uint8_t HID_SWITCH_PRO_BT_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x0A, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x08, //STICK_CONF_DEADZONE,
0x01, //STICK_CONF_INVERT,
0x22, //STICK_CONF_MIN,
0xE4
};//STICK_CONF_MAX,
const uint8_t HID_SWITCH_PRO_BT_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x0A, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT,
0x08, //STICK_CONF_DEADZONE,
0x01, //STICK_CONF_INVERT,
0x22, //STICK_CONF_MIN,
0xE4}; //STICK_CONF_MAX,

6
source/utils/PadConst.hpp
View File

@ -19,8 +19,8 @@
#define _PAD_CONST_H_
#include <string>
#include <controller_patcher/ControllerPatcherDefs.h>
#include <string>
extern const uint8_t DEF_R_STICK;
extern const uint8_t DEF_L_STICK;
@ -74,7 +74,7 @@ extern const uint8_t HID_GC_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE];
extern const uint8_t HID_DS3_BUTTON_CROSS[];
extern const uint8_t HID_DS3_BUTTON_CIRCLE[];
extern const uint8_t HID_DS3_BUTTON_SQUARE [];
extern const uint8_t HID_DS3_BUTTON_SQUARE[];
extern const uint8_t HID_DS3_BUTTON_TRIANGLE[];
extern const uint8_t HID_DS3_BUTTON_L1[];
@ -106,7 +106,7 @@ extern const uint8_t HID_DS3_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE];
extern const uint8_t HID_DS4_BUTTON_CROSS[];
extern const uint8_t HID_DS4_BUTTON_CIRCLE[];
extern const uint8_t HID_DS4_BUTTON_SQUARE [];
extern const uint8_t HID_DS4_BUTTON_SQUARE[];
extern const uint8_t HID_DS4_BUTTON_TRIANGLE[];
extern const uint8_t HID_DS4_BUTTON_L1[];

79
source/utils/StringTools.cpp
View File

@ -23,25 +23,24 @@
*
* for WiiXplorer 2010
***************************************************************************/
#include <vector>
#include <string>
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdio.h>
#include <wchar.h>
#include <string.h>
#include <string>
#include <strings.h>
#include <wut_types.h>
#include <stdio.h>
#include <utils/StringTools.h>
#include <vector>
#include <wchar.h>
#include <wut_types.h>
BOOL StringTools::EndsWith(const std::string& a, const std::string& b) {
BOOL StringTools::EndsWith(const std::string &a, const std::string &b) {
if (b.size() > a.size()) return false;
return std::equal(a.begin() + a.size() - b.size(), a.end(), b.begin());
}
const char * StringTools::byte_to_binary(int32_t x) {
const char *StringTools::byte_to_binary(int32_t x) {
static char b[9];
b[0] = '\0';
@ -53,25 +52,25 @@ const char * StringTools::byte_to_binary(int32_t x) {
return b;
}
std::string StringTools::removeCharFromString(std::string& input,char toBeRemoved) {
std::string StringTools::removeCharFromString(std::string &input, char toBeRemoved) {
std::string output = input;
size_t position;
while(1) {
while (1) {
position = output.find(toBeRemoved);
if(position == std::string::npos)
if (position == std::string::npos)
break;
output.erase(position, 1);
}
return output;
}
const char * StringTools::fmt(const char * format, ...) {
const char *StringTools::fmt(const char *format, ...) {
static char strChar[512];
strChar[0] = 0;
va_list va;
va_start(va, format);
if((vsprintf(strChar, format, va) >= 0)) {
if ((vsprintf(strChar, format, va) >= 0)) {
va_end(va);
return (const char *) strChar;
}
@ -80,26 +79,26 @@ const char * StringTools::fmt(const char * format, ...) {
return NULL;
}
const wchar_t * StringTools::wfmt(const char * format, ...) {
const wchar_t *StringTools::wfmt(const char *format, ...) {
static char tmp[512];
static wchar_t strWChar[512];
strWChar[0] = 0;
tmp[0] = 0;
tmp[0] = 0;
if(!format)
if (!format)
return (const wchar_t *) strWChar;
if(strcmp(format, "") == 0)
if (strcmp(format, "") == 0)
return (const wchar_t *) strWChar;
va_list va;
va_start(va, format);
if((vsprintf(tmp, format, va) >= 0)) {
int bt;
if ((vsprintf(tmp, format, va) >= 0)) {
int bt;
int32_t strlength = strlen(tmp);
bt = mbstowcs(strWChar, tmp, (strlength < 512) ? strlength : 512 );
bt = mbstowcs(strWChar, tmp, (strlength < 512) ? strlength : 512);
if(bt > 0) {
if (bt > 0) {
strWChar[bt] = 0;
return (const wchar_t *) strWChar;
}
@ -109,15 +108,15 @@ const wchar_t * StringTools::wfmt(const char * format, ...) {
return NULL;
}
int32_t StringTools::strprintf(std::string &str, const char * format, ...) {
int32_t StringTools::strprintf(std::string &str, const char *format, ...) {
static char tmp[512];
tmp[0] = 0;
tmp[0] = 0;
int32_t result = 0;
va_list va;
va_start(va, format);
if((vsprintf(tmp, format, va) >= 0)) {
str = tmp;
if ((vsprintf(tmp, format, va) >= 0)) {
str = tmp;
result = str.size();
}
va_end(va);
@ -125,14 +124,14 @@ int32_t StringTools::strprintf(std::string &str, const char * format, ...) {
return result;
}
std::string StringTools::strfmt(const char * format, ...) {
std::string StringTools::strfmt(const char *format, ...) {
std::string str;
static char tmp[512];
tmp[0] = 0;
va_list va;
va_start(va, format);
if((vsprintf(tmp, format, va) >= 0)) {
if ((vsprintf(tmp, format, va) >= 0)) {
str = tmp;
}
va_end(va);
@ -140,11 +139,11 @@ std::string StringTools::strfmt(const char * format, ...) {
return str;
}
BOOL StringTools::char2wchar_t(const char * strChar, wchar_t * dest) {
if(!strChar || !dest)
BOOL StringTools::char2wchar_t(const char *strChar, wchar_t *dest) {
if (!strChar || !dest)
return false;
int bt;
int bt;
bt = mbstowcs(dest, strChar, strlen(strChar));
if (bt > 0) {
dest[bt] = 0;
@ -154,39 +153,39 @@ BOOL StringTools::char2wchar_t(const char * strChar, wchar_t * dest) {
return false;
}
int32_t StringTools::strtokcmp(const char * string, const char * compare, const char * separator) {
if(!string || !compare)
int32_t StringTools::strtokcmp(const char *string, const char *compare, const char *separator) {
if (!string || !compare)
return -1;
char TokCopy[512];
strncpy(TokCopy, compare, sizeof(TokCopy));
TokCopy[511] = '\0';
char * strTok = strtok(TokCopy, separator);
char *strTok = strtok(TokCopy, separator);
while (strTok != NULL) {
if (strcasecmp(string, strTok) == 0) {
return 0;
}
strTok = strtok(NULL,separator);
strTok = strtok(NULL, separator);
}
return -1;
}
int32_t StringTools::strextcmp(const char * string, const char * extension, char seperator) {
if(!string || !extension)
int32_t StringTools::strextcmp(const char *string, const char *extension, char seperator) {
if (!string || !extension)
return -1;
char *ptr = strrchr(string, seperator);
if(!ptr)
if (!ptr)
return -1;
return strcasecmp(ptr + 1, extension);
}
std::vector<std::string> StringTools::stringSplit(const std::string & inValue, const std::string & splitter) {
std::vector<std::string> StringTools::stringSplit(const std::string &inValue, const std::string &splitter) {
std::string value = inValue;
std::vector<std::string> result;
while (true) {
@ -201,7 +200,7 @@ std::vector<std::string> StringTools::stringSplit(const std::string & inValue, c
result.push_back("");
break;
}
if(index + splitter.size() > value.length()) {
if (index + splitter.size() > value.length()) {
break;
}
value = value.substr(index + splitter.size(), value.length());

71
source/utils/StringTools.h
View File

@ -26,56 +26,53 @@
#ifndef __STRING_TOOLS_H
#define __STRING_TOOLS_H
#include <vector>
#include <string>
#include <vector>
#include <wut_types.h>
class StringTools{
public:
static BOOL EndsWith(const std::string& a, const std::string& b);
static const char * byte_to_binary(int32_t x);
static std::string removeCharFromString(std::string& input,char toBeRemoved);
static const char * fmt(const char * format, ...);
static const wchar_t * wfmt(const char * format, ...);
static int32_t strprintf(std::string &str, const char * format, ...);
static std::string strfmt(const char * format, ...);
static BOOL char2wchar_t(const char * src, wchar_t * dest);
static int32_t strtokcmp(const char * string, const char * compare, const char * separator);
static int32_t strextcmp(const char * string, const char * extension, char seperator);
class StringTools {
public:
static BOOL EndsWith(const std::string &a, const std::string &b);
static const char *byte_to_binary(int32_t x);
static std::string removeCharFromString(std::string &input, char toBeRemoved);
static const char *fmt(const char *format, ...);
static const wchar_t *wfmt(const char *format, ...);
static int32_t strprintf(std::string &str, const char *format, ...);
static std::string strfmt(const char *format, ...);
static BOOL char2wchar_t(const char *src, wchar_t *dest);
static int32_t strtokcmp(const char *string, const char *compare, const char *separator);
static int32_t strextcmp(const char *string, const char *extension, char seperator);
static const char * FullpathToFilename(const char *path){
if(!path) return path;
static const char *FullpathToFilename(const char *path) {
if (!path) return path;
const char * ptr = path;
const char * Filename = ptr;
const char *ptr = path;
const char *Filename = ptr;
while(*ptr != '\0')
{
if(ptr[0] == '/' && ptr[1] != '\0')
Filename = ptr+1;
while (*ptr != '\0') {
if (ptr[0] == '/' && ptr[1] != '\0')
Filename = ptr + 1;
++ptr;
}
return Filename;
++ptr;
}
static void RemoveDoubleSlashs(std::string &str){
uint32_t length = str.size();
return Filename;
}
//! clear path of double slashes
for(uint32_t i = 1; i < length; ++i)
{
if(str[i-1] == '/' && str[i] == '/')
{
str.erase(i, 1);
i--;
length--;
}
static void RemoveDoubleSlashs(std::string &str) {
uint32_t length = str.size();
//! clear path of double slashes
for (uint32_t i = 1; i < length; ++i) {
if (str[i - 1] == '/' && str[i] == '/') {
str.erase(i, 1);
i--;
length--;
}
}
}
static std::vector<std::string> stringSplit(const std::string & value, const std::string & splitter);
static std::vector<std::string> stringSplit(const std::string &value, const std::string &splitter);
};
#endif /* __STRING_TOOLS_H */

56
source/utils/TCPServer.cpp
View File

@ -1,20 +1,20 @@
#include <utils/TCPServer.hpp>
#include <malloc.h>
#include <stdio.h>
#include <string.h>
#include <utils/TCPServer.hpp>
#include <utils/logger.h>
#include <network/net.h>
#include <utils/logger.h>
#define wiiu_errno (*__gh_errno_ptr())
TCPServer::TCPServer(int32_t port,int32_t priority) {
this->port = port;
this->sockfd = -1;
TCPServer::TCPServer(int32_t port, int32_t priority) {
this->port = port;
this->sockfd = -1;
this->clientfd = -1;
memset(&(this->sock_addr),0,sizeof(this->sock_addr));
memset(&(this->sock_addr), 0, sizeof(this->sock_addr));
pThread = CThread::create(TCPServer::DoTCPThread, (void*)this, CThread::eAttributeAffCore2,priority);
pThread = CThread::create(TCPServer::DoTCPThread, (void *) this, CThread::eAttributeAffCore2, priority);
pThread->resumeThread();
}
@ -23,10 +23,10 @@ TCPServer::~TCPServer() {
//DEBUG_FUNCTION_LINE("Thread will be closed");
exitThread = 1;
ICInvalidateRange((void*)&exitThread, 4);
DCFlushRange((void*)&exitThread, 4);
ICInvalidateRange((void *) &exitThread, 4);
DCFlushRange((void *) &exitThread, 4);
if(pThread != NULL) {
if (pThread != NULL) {
//DEBUG_FUNCTION_LINE("Deleting it!");
delete pThread;
}
@ -41,13 +41,13 @@ void TCPServer::CloseSockets() {
if (this->clientfd != -1) {
close(this->clientfd);
}
this->sockfd = -1;
this->sockfd = -1;
this->clientfd = -1;
}
void TCPServer::ErrorHandling() {
CloseSockets();
OSSleepTicks(OSMicrosecondsToTicks(1000*1000*2));
OSSleepTicks(OSMicrosecondsToTicks(1000 * 1000 * 2));
}
void TCPServer::DoTCPThreadInternal() {
@ -55,16 +55,16 @@ void TCPServer::DoTCPThreadInternal() {
socklen_t len;
connected = false;
while (1) {
if(exitThread) {
if (exitThread) {
break;
}
memset(&(this->sock_addr),0,sizeof(sock_addr));
sock_addr.sin_family = AF_INET;
sock_addr.sin_port = this->port;
memset(&(this->sock_addr), 0, sizeof(sock_addr));
sock_addr.sin_family = AF_INET;
sock_addr.sin_port = this->port;
sock_addr.sin_addr.s_addr = 0;
this->sockfd = ret = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if(ret == -1) {
if (ret == -1) {
ErrorHandling();
continue;
}
@ -72,31 +72,31 @@ void TCPServer::DoTCPThreadInternal() {
setsockopt(this->sockfd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable));
ret = bind(this->sockfd, (sockaddr *)&sock_addr, 16);
if(ret < 0) {
ret = bind(this->sockfd, (sockaddr *) &sock_addr, 16);
if (ret < 0) {
ErrorHandling();
continue;
}
ret = listen(this->sockfd, 1);
if(ret < 0) {
if (ret < 0) {
ErrorHandling();
continue;
}
do {
DEBUG_FUNCTION_LINE("Waiting for a connection");
if(exitThread) {
if (exitThread) {
break;
}
len = 16;
clientfd = ret = accept(sockfd, (sockaddr *)&(sock_addr), &len);
len = 16;
clientfd = ret = accept(sockfd, (sockaddr *) &(sock_addr), &len);
if(ret == -1) {
if (ret == -1) {
ErrorHandling();
break;
}
if(!acceptConnection()) {
if (!acceptConnection()) {
ErrorHandling();
break;
}
@ -109,11 +109,11 @@ void TCPServer::DoTCPThreadInternal() {
DEBUG_FUNCTION_LINE("Client disconnected");
if(clientfd != -1) {
if (clientfd != -1) {
close(clientfd);
}
clientfd = -1;
} while(0);
} while (0);
DEBUG_FUNCTION_LINE("Closing TCPServer");
connected = false;
onConnectionClosed();
@ -124,6 +124,6 @@ void TCPServer::DoTCPThreadInternal() {
}
void TCPServer::DoTCPThread(CThread *thread, void *arg) {
TCPServer * args = (TCPServer * )arg;
TCPServer *args = (TCPServer *) arg;
return args->DoTCPThreadInternal();
}

16
source/utils/TCPServer.hpp
View File

@ -1,14 +1,14 @@
#ifndef _TCPSERVER_H_
#define _TCPSERVER_H_
#include <netinet/in.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <system/CThread.h>
#include <wut_types.h>
#include <coreinit/cache.h>
#include "utils/logger.h"
#include <coreinit/cache.h>
class TCPServer {
public:
@ -18,6 +18,7 @@ public:
BOOL isConnected() {
return connected;
}
protected:
BOOL shouldExit() {
return (exitThread == 1);
@ -32,7 +33,7 @@ protected:
}
void setThreadPriority(int32_t priority) {
if(pThread != NULL){
if (pThread != NULL) {
pThread->setThreadPriority(priority);
}
}
@ -40,6 +41,7 @@ protected:
struct sockaddr_in getSockAddr() {
return sock_addr;
}
private:
virtual void CloseSockets();
virtual void ErrorHandling();
@ -49,7 +51,7 @@ private:
virtual BOOL acceptConnection() = 0;
virtual void onConnectionClosed(){
virtual void onConnectionClosed() {
DEBUG_FUNCTION_LINE("Default onConnectionClosed ");
}
@ -59,14 +61,14 @@ private:
virtual BOOL whileLoop() = 0;
struct sockaddr_in sock_addr;
volatile int32_t sockfd = -1;
volatile int32_t sockfd = -1;
volatile int32_t clientfd = -1;
int32_t port = 0;
int32_t port = 0;
volatile BOOL connected = false;
volatile int32_t exitThread = 0;
CThread *pThread = NULL;
CThread *pThread = NULL;
};
#endif //_TCPSERVER_H_

16
source/utils/logger.h
View File

@ -8,19 +8,21 @@ extern "C" {
#include <whb/log.h>
#define __FILENAME_X__ (strrchr(__FILE__, '\\') ? strrchr(__FILE__, '\\') + 1 : __FILE__)
#define __FILENAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILENAME_X__)
#define __FILENAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILENAME_X__)
#ifdef __LOGGING__
#define log_print(str) WHBLogPrint(str)
#define log_printf(FMT, ARGS...) WHBLogPrintf(FMT, ## ARGS);
#define log_print(str) WHBLogPrint(str)
#define log_printf(FMT, ARGS...) WHBLogPrintf(FMT, ##ARGS);
#define DEBUG_FUNCTION_LINE(FMT, ARGS...)do { \
WHBLogPrintf("[%23s]%30s@L%04d: " FMT "",__FILENAME__,__FUNCTION__, __LINE__, ## ARGS); \
#define DEBUG_FUNCTION_LINE(FMT, ARGS...) \
do { \
WHBLogPrintf("[%23s]%30s@L%04d: " FMT "", __FILENAME__, __FUNCTION__, __LINE__, ##ARGS); \
} while (0);
#define DEBUG_FUNCTION_LINE_WRITE(FMT, ARGS...)do { \
WHBLogWritef("[%23s]%30s@L%04d: " FMT "",__FILENAME__,__FUNCTION__, __LINE__, ## ARGS); \
#define DEBUG_FUNCTION_LINE_WRITE(FMT, ARGS...) \
do { \
WHBLogWritef("[%23s]%30s@L%04d: " FMT "", __FILENAME__, __FUNCTION__, __LINE__, ##ARGS); \
} while (0);
#else