mirror of
https://github.com/Maschell/controller_patcher.git
synced 2024-11-22 03:59:16 +01:00
Add a .clang_format
This commit is contained in:
Maschell
parent
c8a077574e
commit
7c4232e177
67
.clang-format
Normal file
67
.clang-format
Normal 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
|
||||
@ -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
|
||||
|
||||
@ -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();
|
||||
|
||||
|
||||
@ -276,7 +276,7 @@ typedef struct _HID_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*/
|
||||
my_cb_user *user_data; /**< Pointer to the user data the read callback is using*/
|
||||
} HID_Data;
|
||||
|
||||
|
||||
|
||||
@ -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>
|
||||
|
||||
@ -39,13 +38,13 @@ 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");
|
||||
}
|
||||
}
|
||||
@ -65,7 +64,7 @@ std::vector<std::string> ConfigReader::ScanFolder(std::string path) {
|
||||
struct dirent *dirent = NULL;
|
||||
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;
|
||||
}
|
||||
@ -73,16 +72,16 @@ std::vector<std::string> ConfigReader::ScanFolder(std::string path) {
|
||||
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;
|
||||
}
|
||||
|
||||
@ -22,29 +22,30 @@
|
||||
|
||||
#include "ControllerPatcherIncludes.hpp"
|
||||
|
||||
class ConfigReader{
|
||||
class ConfigReader {
|
||||
friend class ControllerPatcher;
|
||||
friend class ConfigParser;
|
||||
private:
|
||||
|
||||
private:
|
||||
static ConfigReader *getInstance() {
|
||||
if(!instance){
|
||||
if (!instance) {
|
||||
instance = new ConfigReader();
|
||||
}
|
||||
return instance;
|
||||
}
|
||||
|
||||
static void destroyInstance() {
|
||||
if(instance){
|
||||
if (instance) {
|
||||
delete instance;
|
||||
instance = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
static int32_t getNumberOfLoadedFiles(){
|
||||
static int32_t getNumberOfLoadedFiles() {
|
||||
return ConfigReader::numberValidFiles;
|
||||
}
|
||||
|
||||
static void increaseNumberOfLoadedFiles(){
|
||||
static void increaseNumberOfLoadedFiles() {
|
||||
ConfigReader::numberValidFiles++;
|
||||
}
|
||||
BOOL ReadConfigs(std::string path);
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -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_ */
|
||||
|
||||
@ -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->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();
|
||||
const char *line = contentLines[0].c_str();
|
||||
int32_t len = strlen(line);
|
||||
if(len <= 4) {
|
||||
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;
|
||||
|
||||
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) {
|
||||
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,8 +259,8 @@ 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;
|
||||
}
|
||||
@ -269,38 +268,38 @@ BOOL ConfigParser::resetConfig() {
|
||||
}
|
||||
|
||||
int32_t ConfigParser::getSlotController(std::string identify) {
|
||||
if(HID_DEBUG) {
|
||||
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) {
|
||||
if (result < 0) {
|
||||
if (HID_DEBUG) {
|
||||
DEBUG_FUNCTION_LINE("Its a new controller, lets save it");
|
||||
}
|
||||
|
||||
@ -310,95 +309,95 @@ int32_t ConfigParser::getSlotController(std::string identify) {
|
||||
slot = slotdata.deviceslot;
|
||||
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) {
|
||||
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;
|
||||
}
|
||||
|
||||
@ -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();
|
||||
|
||||
|
||||
@ -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 ||
|
||||
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 (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 + 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;
|
||||
}
|
||||
|
||||
@ -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,29 +139,29 @@ 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;
|
||||
@ -553,22 +545,22 @@ private:
|
||||
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
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
#include "CFile.hpp"
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
#include <strings.h>
|
||||
#include "CFile.hpp"
|
||||
|
||||
CFile::CFile() {
|
||||
iFd = -1;
|
||||
@ -169,5 +169,3 @@ int32_t CFile::fwrite(const char *format, ...) {
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -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>
|
||||
|
||||
|
||||
@ -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
|
||||
@ -171,4 +171,3 @@ int32_t FSUtils::saveBufferToFile(const char *path, const void *buffer, uint32_t
|
||||
file.close();
|
||||
return written;
|
||||
}
|
||||
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
#include <wut_types.h>
|
||||
#include <string>
|
||||
#include <wut_types.h>
|
||||
|
||||
class FSUtils {
|
||||
public:
|
||||
|
||||
@ -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.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));
|
||||
@ -91,85 +91,85 @@ 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) {
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
if (HID_DEBUG) {
|
||||
DEBUG_FUNCTION_LINE("got pid %04X", pid);
|
||||
}
|
||||
HIDDevice device;
|
||||
memset(&device,0,sizeof(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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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;
|
||||
@ -177,74 +177,74 @@ BOOL CPTCPServer::whileLoop() {
|
||||
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);
|
||||
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) {
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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("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);
|
||||
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));
|
||||
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);
|
||||
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) {
|
||||
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) {
|
||||
if (ret < 0) {
|
||||
DEBUG_FUNCTION_LINE("Error in %02X: sendbyte PONG");
|
||||
return false;
|
||||
}
|
||||
@ -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);
|
||||
if (ret < 0) {
|
||||
DEBUG_FUNCTION_LINE("Error sendbyte: %02X", clientProtocolVersion);
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
|
||||
@ -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
|
||||
|
||||
@ -49,12 +49,12 @@
|
||||
|
||||
#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
|
||||
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_
|
||||
|
||||
@ -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);
|
||||
@ -36,7 +36,7 @@ UDPClient::UDPClient(uint32_t ip, int32_t port) {
|
||||
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);
|
||||
|
||||
@ -18,8 +18,8 @@
|
||||
#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
|
||||
|
||||
@ -27,11 +27,11 @@ 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();
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
@ -23,8 +23,8 @@
|
||||
|
||||
#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;
|
||||
@ -35,20 +35,20 @@ UDPServer::UDPServer(int32_t 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
|
||||
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();
|
||||
}
|
||||
|
||||
@ -98,60 +96,60 @@ void UDPServer::DoUDPThreadInternal() {
|
||||
int32_t n;
|
||||
|
||||
my_cb_user user;
|
||||
while(1) {
|
||||
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) {
|
||||
if (gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) {
|
||||
uint8_t count_commands;
|
||||
memcpy((void *)&count_commands,buffer+bufferoffset,sizeof(count_commands));
|
||||
memcpy((void *) &count_commands, buffer + bufferoffset, sizeof(count_commands));
|
||||
bufferoffset += sizeof(count_commands);
|
||||
for(int32_t i = 0; i<count_commands; i++) {
|
||||
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;
|
||||
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) {
|
||||
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;
|
||||
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) {
|
||||
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);
|
||||
ControllerPatcherHID::externHIDReadCallback(handle, databuffer, datasize, &user);
|
||||
}
|
||||
if(databuffer) {
|
||||
if (databuffer) {
|
||||
free(databuffer);
|
||||
databuffer = NULL;
|
||||
}
|
||||
@ -165,7 +163,7 @@ void UDPServer::DoUDPThreadInternal() {
|
||||
}
|
||||
}
|
||||
}
|
||||
if(HID_DEBUG) {
|
||||
if (HID_DEBUG) {
|
||||
DEBUG_FUNCTION_LINE("UDPServer Thread ended");
|
||||
}
|
||||
}
|
||||
|
||||
@ -28,13 +28,13 @@ class UDPServer {
|
||||
|
||||
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,10 +42,10 @@ 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 exitThread = 0;
|
||||
|
||||
@ -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,7 +44,7 @@ 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];
|
||||
@ -59,7 +58,7 @@ 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;
|
||||
@ -67,12 +66,12 @@ int32_t sendwait(int32_t sock, const void *buffer, int32_t len) {
|
||||
// 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) {
|
||||
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;
|
||||
|
||||
@ -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;
|
||||
@ -76,13 +76,13 @@ void ControllerPatcherHID::myHIDMouseReadCallback(uint32_t handle, int32_t error
|
||||
cur_mouse_data->deltaY = y_value;
|
||||
|
||||
cur_mouse_data->left_click = buf[0];
|
||||
cur_mouse_data->right_click = buf[0]>>1;
|
||||
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,16 +120,16 @@ 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);
|
||||
|
||||
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;
|
||||
@ -141,23 +141,23 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
|
||||
//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));
|
||||
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;
|
||||
@ -165,22 +165,22 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
|
||||
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;
|
||||
|
||||
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;
|
||||
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) {
|
||||
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,62 +389,62 @@ 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 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) &&
|
||||
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) &&
|
||||
} 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) &&
|
||||
} 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) &&
|
||||
} 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;
|
||||
@ -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 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,27 +510,27 @@ 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;
|
||||
@ -540,20 +539,20 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherHID::setVPADControllerData(V
|
||||
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,40 +613,40 @@ 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;
|
||||
}
|
||||
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];
|
||||
@ -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) {
|
||||
|
||||
@ -37,30 +37,31 @@
|
||||
#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 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_ */
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -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);
|
||||
};
|
||||
|
||||
@ -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,16 +90,16 @@ 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;
|
||||
@ -117,6 +114,7 @@ public:
|
||||
eAttributeDetach = 0x08,
|
||||
eAttributePinnedAff = 0x10
|
||||
};
|
||||
|
||||
private:
|
||||
static int threadCallback(int argc, const char **argv) {
|
||||
//! After call to start() continue with the internal function
|
||||
|
||||
@ -69,8 +69,7 @@ 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],
|
||||
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]};
|
||||
|
||||
@ -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_
|
||||
|
||||
@ -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
|
||||
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,
|
||||
0xE4}; //STICK_CONF_MAX,
|
||||
|
||||
const uint8_t HID_GC_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
|
||||
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,
|
||||
0xE1}; //STICK_CONF_MAX,
|
||||
|
||||
const uint8_t HID_GC_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
|
||||
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,
|
||||
0xE2}; //STICK_CONF_MAX,
|
||||
|
||||
const uint8_t HID_GC_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
|
||||
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,
|
||||
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
|
||||
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,
|
||||
0xFF}; //STICK_CONF_MAX,
|
||||
|
||||
const uint8_t HID_DS3_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
|
||||
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,
|
||||
0xFF}; //STICK_CONF_MAX,
|
||||
|
||||
const uint8_t HID_DS3_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
|
||||
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,
|
||||
0xFF}; //STICK_CONF_MAX,
|
||||
|
||||
const uint8_t HID_DS3_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
|
||||
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,
|
||||
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
|
||||
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,
|
||||
0xFF}; //STICK_CONF_MAX,
|
||||
|
||||
const uint8_t HID_DS4_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
|
||||
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,
|
||||
0xFF}; //STICK_CONF_MAX,
|
||||
|
||||
const uint8_t HID_DS4_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
|
||||
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,
|
||||
0xFF}; //STICK_CONF_MAX,
|
||||
|
||||
const uint8_t HID_DS4_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
|
||||
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,
|
||||
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
|
||||
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,
|
||||
0xFF}; //STICK_CONF_MAX,
|
||||
|
||||
const uint8_t HID_XINPUT_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
|
||||
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,
|
||||
0xFF}; //STICK_CONF_MAX,
|
||||
|
||||
const uint8_t HID_XINPUT_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
|
||||
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,
|
||||
0xFF}; //STICK_CONF_MAX,
|
||||
|
||||
const uint8_t HID_XINPUT_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
|
||||
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,
|
||||
|
||||
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
|
||||
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,
|
||||
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
|
||||
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,
|
||||
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
|
||||
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,
|
||||
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
|
||||
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,
|
||||
0xE4}; //STICK_CONF_MAX,
|
||||
|
||||
@ -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[];
|
||||
|
||||
@ -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;
|
||||
|
||||
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)) {
|
||||
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,14 +108,14 @@ 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;
|
||||
int32_t result = 0;
|
||||
|
||||
va_list va;
|
||||
va_start(va, format);
|
||||
if((vsprintf(tmp, format, va) >= 0)) {
|
||||
if ((vsprintf(tmp, format, va) >= 0)) {
|
||||
str = tmp;
|
||||
result = str.size();
|
||||
}
|
||||
@ -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,8 +139,8 @@ 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;
|
||||
@ -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());
|
||||
|
||||
@ -26,33 +26,32 @@
|
||||
#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;
|
||||
}
|
||||
@ -60,14 +59,12 @@ class StringTools{
|
||||
return Filename;
|
||||
}
|
||||
|
||||
static void RemoveDoubleSlashs(std::string &str){
|
||||
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] == '/')
|
||||
{
|
||||
for (uint32_t i = 1; i < length; ++i) {
|
||||
if (str[i - 1] == '/' && str[i] == '/') {
|
||||
str.erase(i, 1);
|
||||
i--;
|
||||
length--;
|
||||
@ -75,7 +72,7 @@ class StringTools{
|
||||
}
|
||||
}
|
||||
|
||||
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 */
|
||||
|
||||
@ -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) {
|
||||
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;
|
||||
}
|
||||
@ -47,7 +47,7 @@ void TCPServer::CloseSockets() {
|
||||
|
||||
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));
|
||||
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);
|
||||
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();
|
||||
}
|
||||
@ -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 ");
|
||||
}
|
||||
|
||||
|
||||
@ -13,14 +13,16 @@ extern "C" {
|
||||
#ifdef __LOGGING__
|
||||
|
||||
#define log_print(str) WHBLogPrint(str)
|
||||
#define log_printf(FMT, ARGS...) WHBLogPrintf(FMT, ## ARGS);
|
||||
#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
|
||||
|
||||
Loading…
Reference in New Issue
Block a user