The-Homebrew-Cloud/hid_to_vpad
2
0
Fork 0
mirror of https://github.com/Maschell/hid_to_vpad.git synced 2025-01-08 02:50:45 +01:00
Code Issues Packages Projects Releases Wiki Activity

clang format

Browse Source
This commit is contained in:
Maschell 2023-04-10 12:52:56 +02:00
parent b7143f814e
commit 3d19f8dff6
11 changed files with 378 additions and 288 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
.clang-format Normal file
View File

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

49
.github/workflows/ci.yml vendored
View File

@ -6,10 +6,25 @@ on:
- main - main
jobs: jobs:
build-binary: clang-format:
runs-on: ubuntu-18.04 runs-on: ubuntu-22.04
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v3
- name: clang-format
run: |
docker run --rm -v ${PWD}:/src ghcr.io/wiiu-env/clang-format:13.0.0-2 -r ./src
build-binary:
runs-on: ubuntu-22.04
needs: clang-format
steps:
- uses: actions/checkout@v3
- name: create version.h
run: |
git_hash=$(git rev-parse --short "$GITHUB_SHA")
cat <<EOF > ./src/version.h
#pragma once
#define VERSION_EXTRA " (nightly-$git_hash)"
EOF
- name: build binary - name: build binary
run: | run: |
docker build . -t builder docker build . -t builder
@ -20,7 +35,7 @@ jobs:
path: "*.wps" path: "*.wps"
deploy-binary: deploy-binary:
needs: build-binary needs: build-binary
runs-on: ubuntu-18.04 runs-on: ubuntu-22.04
steps: steps:
- name: Get environment variables - name: Get environment variables
id: get_repository_name id: get_repository_name
@ -30,29 +45,15 @@ jobs:
- uses: actions/download-artifact@master - uses: actions/download-artifact@master
with: with:
name: binary name: binary
path: wiiu/plugins
- name: zip artifact - name: zip artifact
run: zip -r ${{ env.REPOSITORY_NAME }}_${{ env.DATETIME }}.zip wiiu run: zip -r ${{ env.REPOSITORY_NAME }}_${{ env.DATETIME }}.zip *.wps
- name: Create Release - name: Create Release
id: create_release uses: "softprops/action-gh-release@v1"
uses: actions/create-release@v1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with: with:
tag_name: ${{ env.REPOSITORY_NAME }}-${{ env.DATETIME }} tag_name: ${{ env.REPOSITORY_NAME }}-${{ env.DATETIME }}
release_name: Nightly-${{ env.REPOSITORY_NAME }}-${{ env.DATETIME }}
draft: false draft: false
prerelease: true prerelease: true
body: | generate_release_notes: true
Not a stable release: name: Nightly-${{ env.REPOSITORY_NAME }}-${{ env.DATETIME }}
${{ github.event.head_commit.message }} files: |
- name: Upload Release Asset ./${{ env.REPOSITORY_NAME }}_${{ env.DATETIME }}.zip
id: upload-release-asset
uses: actions/upload-release-asset@v1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
upload_url: ${{ steps.create_release.outputs.upload_url }} # This pulls from the CREATE RELEASE step above, referencing it's ID to get its outputs object, which include a `upload_url`. See this blog post for more info: https://jasonet.co/posts/new-features-of-github-actions/#passing-data-to-future-steps
asset_path: ./${{ env.REPOSITORY_NAME }}_${{ env.DATETIME }}.zip
asset_name: ${{ env.REPOSITORY_NAME }}_${{ env.DATETIME }}.zip
asset_content_type: application/unknown

32
.github/workflows/pr.yml vendored
View File

@ -3,10 +3,36 @@ name: CI-PR
on: [pull_request] on: [pull_request]
jobs: jobs:
build-binary: clang-format:
runs-on: ubuntu-18.04 runs-on: ubuntu-22.04
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v3
- name: clang-format
run: |
docker run --rm -v ${PWD}:/src ghcr.io/wiiu-env/clang-format:13.0.0-2 -r ./src
check-build-with-logging:
runs-on: ubuntu-22.04
needs: clang-format
steps:
- uses: actions/checkout@v3
- name: build binary with logging
run: |
docker build . -t builder
docker run --rm -v ${PWD}:/project builder make DEBUG=VERBOSE
docker run --rm -v ${PWD}:/project builder make clean
docker run --rm -v ${PWD}:/project builder make DEBUG=1
build-binary:
runs-on: ubuntu-22.04
needs: clang-format
steps:
- uses: actions/checkout@v3
- name: create version.h
run: |
git_hash=$(git rev-parse --short "${{ github.event.pull_request.head.sha }}")
cat <<EOF > ./src/version.h
#pragma once
#define VERSION_EXTRA " (nightly-$git_hash)"
EOF
- name: build binary - name: build binary
run: | run: |
docker build . -t builder docker build . -t builder

76
src/ConfigHooks.cpp
View File

@ -15,36 +15,36 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/ ****************************************************************************/
#include "WUPSConfigItemPadMapping.h"
#include "utils/StringTools.h"
#include "utils/logger.h"
#include <controller_patcher/ControllerPatcher.hpp>
#include <wups.h> #include <wups.h>
#include <wups/config.h> #include <wups/config.h>
#include <wups/config/WUPSConfigItemBoolean.h> #include <wups/config/WUPSConfigItemBoolean.h>
#include <controller_patcher/ControllerPatcher.hpp>
#include "utils/logger.h"
#include "utils/StringTools.h"
#include "WUPSConfigItemPadMapping.h"
bool runNetworkClient = true; bool runNetworkClient = true;
void loadMapping(std::string& persistedValue, UController_Type type); void loadMapping(std::string &persistedValue, UController_Type type);
void ConfigLoad() { void ConfigLoad() {
WUPS_OpenStorage(); WUPS_OpenStorage();
bool rumble = 0; bool rumble = 0;
if(WUPS_GetBool(nullptr, "rumble", &rumble) == WUPS_STORAGE_ERROR_SUCCESS){ if (WUPS_GetBool(nullptr, "rumble", &rumble) == WUPS_STORAGE_ERROR_SUCCESS) {
ControllerPatcher::setRumbleActivated(rumble); ControllerPatcher::setRumbleActivated(rumble);
}else{ } else {
WUPS_StoreBool(nullptr, "rumble", ControllerPatcher::isRumbleActivated()); WUPS_StoreBool(nullptr, "rumble", ControllerPatcher::isRumbleActivated());
} }
if(WUPS_GetBool(nullptr, "networkclient", &runNetworkClient) != WUPS_STORAGE_ERROR_SUCCESS){ if (WUPS_GetBool(nullptr, "networkclient", &runNetworkClient) != WUPS_STORAGE_ERROR_SUCCESS) {
WUPS_StoreBool(nullptr, "networkclient", runNetworkClient); WUPS_StoreBool(nullptr, "networkclient", runNetworkClient);
} }
char buffer[512]; char buffer[512];
if(WUPS_GetString(nullptr, "gamepadmapping", buffer, sizeof(buffer)) == WUPS_STORAGE_ERROR_SUCCESS){ if (WUPS_GetString(nullptr, "gamepadmapping", buffer, sizeof(buffer)) == WUPS_STORAGE_ERROR_SUCCESS) {
std::string stringWrapper = buffer; std::string stringWrapper = buffer;
loadMapping(stringWrapper, UController_Type_Gamepad); loadMapping(stringWrapper, UController_Type_Gamepad);
} }
@ -52,36 +52,36 @@ void ConfigLoad() {
WUPS_CloseStorage(); WUPS_CloseStorage();
} }
void loadMapping(std::string &persistedValue, UController_Type controllerType){ void loadMapping(std::string &persistedValue, UController_Type controllerType) {
if(persistedValue.empty()) { if (persistedValue.empty()) {
// No device mapped. // No device mapped.
return; return;
} }
std::vector<std::string> result = StringTools::stringSplit(persistedValue, ","); std::vector<std::string> result = StringTools::stringSplit(persistedValue, ",");
if(result.size() != 4) { if (result.size() != 4) {
return; return;
} }
ControllerMappingPADInfo mappedPadInfo; ControllerMappingPADInfo mappedPadInfo;
mappedPadInfo.vidpid.vid = atoi(result.at(0).c_str()); mappedPadInfo.vidpid.vid = atoi(result.at(0).c_str());
mappedPadInfo.vidpid.pid = atoi(result.at(1).c_str()); mappedPadInfo.vidpid.pid = atoi(result.at(1).c_str());
mappedPadInfo.pad = atoi(result.at(2).c_str()); mappedPadInfo.pad = atoi(result.at(2).c_str());
mappedPadInfo.type = CM_Type_Controller; //atoi(result.at(3).c_str()); mappedPadInfo.type = CM_Type_Controller; //atoi(result.at(3).c_str());
ControllerPatcher::resetControllerMapping(controllerType); ControllerPatcher::resetControllerMapping(controllerType);
ControllerPatcher::addControllerMapping(controllerType,mappedPadInfo); ControllerPatcher::addControllerMapping(controllerType, mappedPadInfo);
} }
void rumbleChanged(ConfigItemBoolean * item, bool newValue) { void rumbleChanged(ConfigItemBoolean *item, bool newValue) {
DEBUG_FUNCTION_LINE("rumbleChanged %d ",newValue); DEBUG_FUNCTION_LINE("rumbleChanged %d ", newValue);
ControllerPatcher::setRumbleActivated(newValue); ControllerPatcher::setRumbleActivated(newValue);
WUPS_StoreInt(nullptr, "rumble", newValue); WUPS_StoreInt(nullptr, "rumble", newValue);
} }
void networkClientChanged(ConfigItemBoolean * item, bool newValue) { void networkClientChanged(ConfigItemBoolean *item, bool newValue) {
DEBUG_FUNCTION_LINE("Trigger network %d",newValue); DEBUG_FUNCTION_LINE("Trigger network %d", newValue);
ControllerPatcher::setNetworkControllerActivated(newValue); ControllerPatcher::setNetworkControllerActivated(newValue);
if(newValue) { if (newValue) {
ControllerPatcher::startNetworkServer(); ControllerPatcher::startNetworkServer();
} else { } else {
ControllerPatcher::stopNetworkServer(); ControllerPatcher::stopNetworkServer();
@ -89,9 +89,9 @@ void networkClientChanged(ConfigItemBoolean * item, bool newValue) {
WUPS_StoreInt(nullptr, "networkclient", newValue); WUPS_StoreInt(nullptr, "networkclient", newValue);
} }
void PadMappingUpdated(ConfigItemPadMapping * item) { void PadMappingUpdated(ConfigItemPadMapping *item) {
if(item->mappedPadInfo.active && item->mappedPadInfo.type == CM_Type_Controller){ if (item->mappedPadInfo.active && item->mappedPadInfo.type == CM_Type_Controller) {
auto res = StringTools::strfmt("%d,%d,%d,%d",item->mappedPadInfo.vidpid.vid,item->mappedPadInfo.vidpid.pid,item->mappedPadInfo.pad,item->mappedPadInfo.type); auto res = StringTools::strfmt("%d,%d,%d,%d", item->mappedPadInfo.vidpid.vid, item->mappedPadInfo.vidpid.pid, item->mappedPadInfo.pad, item->mappedPadInfo.type);
WUPS_StoreString(nullptr, item->configId, res.c_str()); WUPS_StoreString(nullptr, item->configId, res.c_str());
} else { } else {
WUPS_StoreString(nullptr, item->configId, ""); WUPS_StoreString(nullptr, item->configId, "");
@ -99,26 +99,26 @@ void PadMappingUpdated(ConfigItemPadMapping * item) {
} }
WUPS_CONFIG_CLOSED(){ WUPS_CONFIG_CLOSED() {
WUPS_CloseStorage(); WUPS_CloseStorage();
} }
#define CONFIG_AddCategoryByName(config, name, callback) \ #define CONFIG_AddCategoryByName(config, name, callback) \
if (WUPSConfig_AddCategoryByName(config, name, callback) < 0) { \ if (WUPSConfig_AddCategoryByName(config, name, callback) < 0) { \
WUPSConfig_Destroy(config); \ WUPSConfig_Destroy(config); \
return 0; \ return 0; \
} }
#define CONFIG_Boolean_AddToCategoryEx(category, config_id, display_name, default_value, callback, true_value, false_value) \
if (!WUPSConfigItemBoolean_AddToCategoryEx(category, config_id, display_name, default_value, callback, true_value, false_value)) { \
WUPSConfig_Destroy(config); \
return 0; \
}
#define CONFIG_PadMapping_AddToCategory(category, config_id, display_name, controller_type, callback) \ #define CONFIG_Boolean_AddToCategoryEx(category, config_id, display_name, default_value, callback, true_value, false_value) \
if (!WUPSConfigItemBoolean_AddToCategoryEx(category, config_id, display_name, default_value, callback, true_value, false_value)) { \
WUPSConfig_Destroy(config); \
return 0; \
}
#define CONFIG_PadMapping_AddToCategory(category, config_id, display_name, controller_type, callback) \
if (!WUPSConfigItemPadMapping_AddToCategory(category, config_id, display_name, controller_type, callback)) { \ if (!WUPSConfigItemPadMapping_AddToCategory(category, config_id, display_name, controller_type, callback)) { \
WUPSConfig_Destroy(config); \ WUPSConfig_Destroy(config); \
return 0; \ return 0; \
} }
@ -129,10 +129,10 @@ WUPS_GET_CONFIG() {
if (WUPSConfig_Create(&config, "HID to VPAD") < 0) { if (WUPSConfig_Create(&config, "HID to VPAD") < 0) {
return 0; return 0;
} }
WUPSConfigCategoryHandle catMapping; WUPSConfigCategoryHandle catMapping;
WUPSConfigCategoryHandle catOther; WUPSConfigCategoryHandle catOther;
CONFIG_AddCategoryByName(config, "Mapping", &catMapping); CONFIG_AddCategoryByName(config, "Mapping", &catMapping);
CONFIG_AddCategoryByName(config, "Other", &catOther); CONFIG_AddCategoryByName(config, "Other", &catOther);

165
src/FunctionPatches.cpp
View File

@ -26,100 +26,100 @@ DECL_FUNCTION(int32_t, VPADRead, VPADChan chan, VPADStatus *buffer, uint32_t buf
bool do_callback = (result > 0 && (buffer[0].hold & VPAD_BUTTON_TV)); bool do_callback = (result > 0 && (buffer[0].hold & VPAD_BUTTON_TV));
ControllerPatcher::handleCallbackData(do_callback); ControllerPatcher::handleCallbackData(do_callback);
if(ControllerPatcher::areControllersConnected() && buffer_size > 0) { if (ControllerPatcher::areControllersConnected() && buffer_size > 0) {
ControllerPatcher::setRumble(UController_Type_Gamepad,!!VPADBASEGetMotorOnRemainingCount(VPAD_CHAN_0)); ControllerPatcher::setRumble(UController_Type_Gamepad, !!VPADBASEGetMotorOnRemainingCount(VPAD_CHAN_0));
if(ControllerPatcher::setControllerDataFromHID(buffer) == CONTROLLER_PATCHER_ERROR_NONE) { if (ControllerPatcher::setControllerDataFromHID(buffer) == CONTROLLER_PATCHER_ERROR_NONE) {
if(buffer[0].hold & VPAD_BUTTON_HOME) { if (buffer[0].hold & VPAD_BUTTON_HOME) {
//You can open the home menu this way, but not close it. Need a proper way to close it using the same button... //You can open the home menu this way, but not close it. Need a proper way to close it using the same button...
//OSSendAppSwitchRequest(5,0,0); //Open the home menu! //OSSendAppSwitchRequest(5,0,0); //Open the home menu!
} }
if(error != nullptr) { if (error != nullptr) {
*error = VPAD_READ_SUCCESS; *error = VPAD_READ_SUCCESS;
} }
result = 1; // We want the WiiU to ignore everything else. result = 1; // We want the WiiU to ignore everything else.
} }
} }
if(ControllerPatcher::isButtonRemappingDone()) { if (ControllerPatcher::isButtonRemappingDone()) {
ControllerPatcher::buttonRemapping(buffer,result); ControllerPatcher::buttonRemapping(buffer, result);
//ControllerPatcher::printVPADButtons(buffer); //Leads to random crashes on app transitions. //ControllerPatcher::printVPADButtons(buffer); //Leads to random crashes on app transitions.
} }
return result; return result;
} }
DECL_FUNCTION(int32_t, WPADProbe, WPADChan chan, uint32_t * result ) { DECL_FUNCTION(int32_t, WPADProbe, WPADChan chan, uint32_t *result) {
if( (chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) || if ((chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) ||
(chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) || (chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) ||
(chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) || (chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) ||
(chan == WPAD_CHAN_3 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro4))) { (chan == WPAD_CHAN_3 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro4))) {
if(result != nullptr) { if (result != nullptr) {
*result = WPAD_EXT_PRO_CONTROLLER; *result = WPAD_EXT_PRO_CONTROLLER;
} }
return 0; return 0;
} }
return real_WPADProbe(chan,result); return real_WPADProbe(chan, result);
} }
DECL_FUNCTION(WPADConnectCallback,WPADSetConnectCallback,WPADChan chan, WPADConnectCallback callback ) { DECL_FUNCTION(WPADConnectCallback, WPADSetConnectCallback, WPADChan chan, WPADConnectCallback callback) {
//log_printf("WPADSetConnectCallback chan %d %08X",chan,callback); //log_printf("WPADSetConnectCallback chan %d %08X",chan,callback);
ControllerPatcher::setWPADConnectCallback(chan,callback); ControllerPatcher::setWPADConnectCallback(chan, callback);
if( (chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) || if ((chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) ||
(chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) || (chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) ||
(chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) || (chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) ||
(chan == WPAD_CHAN_3 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro4))) { (chan == WPAD_CHAN_3 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro4))) {
if(callback != nullptr) { if (callback != nullptr) {
callback(chan,0); callback(chan, 0);
} }
} }
return real_WPADSetConnectCallback(chan,callback); return real_WPADSetConnectCallback(chan, callback);
} }
DECL_FUNCTION(WPADExtensionCallback,WPADSetExtensionCallback,WPADChan chan, WPADExtensionCallback callback ) { DECL_FUNCTION(WPADExtensionCallback, WPADSetExtensionCallback, WPADChan chan, WPADExtensionCallback callback) {
//log_printf("WPADSetExtensionCallback chan %d %08X",chan,callback); //log_printf("WPADSetExtensionCallback chan %d %08X",chan,callback);
ControllerPatcher::setKPADExtensionCallback(chan,callback); ControllerPatcher::setKPADExtensionCallback(chan, callback);
if((chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) || if ((chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) ||
(chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) || (chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) ||
(chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) || (chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) ||
(chan == WPAD_CHAN_3 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro4))) { (chan == WPAD_CHAN_3 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro4))) {
if(callback != nullptr) { if (callback != nullptr) {
callback(chan,WPAD_EXT_PRO_CONTROLLER); callback(chan, WPAD_EXT_PRO_CONTROLLER);
} }
} }
return real_WPADSetExtensionCallback(chan,callback); return real_WPADSetExtensionCallback(chan, callback);
} }
DECL_FUNCTION(WPADConnectCallback,KPADSetConnectCallback,WPADChan chan, WPADConnectCallback callback ) { DECL_FUNCTION(WPADConnectCallback, KPADSetConnectCallback, WPADChan chan, WPADConnectCallback callback) {
//log_printf("KPADSetConnectCallback chan %d %08X",chan,callback); //log_printf("KPADSetConnectCallback chan %d %08X",chan,callback);
ControllerPatcher::setKPADConnectedCallback(chan,callback); ControllerPatcher::setKPADConnectedCallback(chan, callback);
if( (chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) || if ((chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) ||
(chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) || (chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) ||
(chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) || (chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) ||
(chan == WPAD_CHAN_3 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro4))) { (chan == WPAD_CHAN_3 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro4))) {
if(callback != nullptr) { if (callback != nullptr) {
callback(chan,0); callback(chan, 0);
} }
} }
return real_KPADSetConnectCallback(chan,callback); return real_KPADSetConnectCallback(chan, callback);
} }
DECL_FUNCTION(uint8_t, WPADGetBatteryLevel, WPADChan chan) { DECL_FUNCTION(uint8_t, WPADGetBatteryLevel, WPADChan chan) {
uint8_t result = real_WPADGetBatteryLevel(chan); uint8_t result = real_WPADGetBatteryLevel(chan);
if( (chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) || if ((chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) ||
(chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) || (chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) ||
(chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) || (chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) ||
(chan == WPAD_CHAN_3 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro4))) { (chan == WPAD_CHAN_3 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro4))) {
result = 4; // Full battery result = 4; // Full battery
} }
return result; return result;
@ -128,10 +128,10 @@ DECL_FUNCTION(uint8_t, WPADGetBatteryLevel, WPADChan chan) {
//In case a game relies on this... //In case a game relies on this...
DECL_FUNCTION(uint32_t, WPADGetDataFormat, WPADChan chan) { DECL_FUNCTION(uint32_t, WPADGetDataFormat, WPADChan chan) {
//log_printf("WPADGetDataFormat chan: %d result: %d",chan,result); //log_printf("WPADGetDataFormat chan: %d result: %d",chan,result);
if((chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) || if ((chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) ||
(chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) || (chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) ||
(chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) || (chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) ||
(chan == WPAD_CHAN_3 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro4))) { (chan == WPAD_CHAN_3 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro4))) {
return WPAD_FMT_PRO_CONTROLLER; return WPAD_FMT_PRO_CONTROLLER;
} }
return real_WPADGetDataFormat(chan); return real_WPADGetDataFormat(chan);
@ -139,49 +139,48 @@ DECL_FUNCTION(uint32_t, WPADGetDataFormat, WPADChan chan) {
DECL_FUNCTION(int32_t, WPADSetDataFormat, WPADChan chan, WPADDataFormat fmt) { DECL_FUNCTION(int32_t, WPADSetDataFormat, WPADChan chan, WPADDataFormat fmt) {
int32_t result = -1; int32_t result = -1;
if((chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) || if ((chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) ||
(chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) || (chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) ||
(chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) || (chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) ||
(chan == WPAD_CHAN_3 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro4))) { (chan == WPAD_CHAN_3 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro4))) {
real_WPADSetDataFormat(chan,WPAD_FMT_PRO_CONTROLLER); real_WPADSetDataFormat(chan, WPAD_FMT_PRO_CONTROLLER);
result = 0; result = 0;
} }
result = real_WPADSetDataFormat(chan,fmt); result = real_WPADSetDataFormat(chan, fmt);
return result; return result;
} }
DECL_FUNCTION(void,WPADRead,WPADChan chan, WPADStatusProController *data ) { DECL_FUNCTION(void, WPADRead, WPADChan chan, WPADStatusProController *data) {
if((chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) || if ((chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) ||
(chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) || (chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) ||
(chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) || (chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) ||
(chan == WPAD_CHAN_3 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro4))) { (chan == WPAD_CHAN_3 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro4))) {
ControllerPatcher::setProControllerDataFromHID((void*)data,chan,PRO_CONTROLLER_MODE_WPADReadData); ControllerPatcher::setProControllerDataFromHID((void *) data, chan, PRO_CONTROLLER_MODE_WPADReadData);
} else { } else {
real_WPADRead(chan,data); real_WPADRead(chan, data);
} }
} }
DECL_FUNCTION(void,WPADControlMotor, WPADChan chan, uint32_t status ) { DECL_FUNCTION(void, WPADControlMotor, WPADChan chan, uint32_t status) {
if(chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) { if (chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) {
ControllerPatcher::setRumble(UController_Type_Pro1,status); ControllerPatcher::setRumble(UController_Type_Pro1, status);
} else if(chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) { } else if (chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) {
ControllerPatcher::setRumble(UController_Type_Pro2,status); ControllerPatcher::setRumble(UController_Type_Pro2, status);
} else if(chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) { } else if (chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) {
ControllerPatcher::setRumble(UController_Type_Pro3,status); ControllerPatcher::setRumble(UController_Type_Pro3, status);
} else if(chan == WPAD_CHAN_3 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro4)) { } else if (chan == WPAD_CHAN_3 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro4)) {
ControllerPatcher::setRumble(UController_Type_Pro4,status); ControllerPatcher::setRumble(UController_Type_Pro4, status);
} }
real_WPADControlMotor(chan,status); real_WPADControlMotor(chan, status);
} }
WUPS_MUST_REPLACE(VPADRead, WUPS_LOADER_LIBRARY_VPAD, VPADRead); WUPS_MUST_REPLACE(VPADRead, WUPS_LOADER_LIBRARY_VPAD, VPADRead);
WUPS_MUST_REPLACE(WPADGetBatteryLevel, WUPS_LOADER_LIBRARY_PADSCORE, WPADGetBatteryLevel); WUPS_MUST_REPLACE(WPADGetBatteryLevel, WUPS_LOADER_LIBRARY_PADSCORE, WPADGetBatteryLevel);
WUPS_MUST_REPLACE(KPADSetConnectCallback, WUPS_LOADER_LIBRARY_PADSCORE, KPADSetConnectCallback); WUPS_MUST_REPLACE(KPADSetConnectCallback, WUPS_LOADER_LIBRARY_PADSCORE, KPADSetConnectCallback);
WUPS_MUST_REPLACE(WPADSetConnectCallback, WUPS_LOADER_LIBRARY_PADSCORE, WPADSetConnectCallback); WUPS_MUST_REPLACE(WPADSetConnectCallback, WUPS_LOADER_LIBRARY_PADSCORE, WPADSetConnectCallback);
WUPS_MUST_REPLACE(WPADSetExtensionCallback, WUPS_LOADER_LIBRARY_PADSCORE, WPADSetExtensionCallback); WUPS_MUST_REPLACE(WPADSetExtensionCallback, WUPS_LOADER_LIBRARY_PADSCORE, WPADSetExtensionCallback);
WUPS_MUST_REPLACE(WPADRead, WUPS_LOADER_LIBRARY_PADSCORE, WPADRead); WUPS_MUST_REPLACE(WPADRead, WUPS_LOADER_LIBRARY_PADSCORE, WPADRead);
WUPS_MUST_REPLACE(WPADGetDataFormat, WUPS_LOADER_LIBRARY_PADSCORE, WPADGetDataFormat); WUPS_MUST_REPLACE(WPADGetDataFormat, WUPS_LOADER_LIBRARY_PADSCORE, WPADGetDataFormat);
WUPS_MUST_REPLACE(WPADSetDataFormat, WUPS_LOADER_LIBRARY_PADSCORE, WPADSetDataFormat); WUPS_MUST_REPLACE(WPADSetDataFormat, WUPS_LOADER_LIBRARY_PADSCORE, WPADSetDataFormat);
WUPS_MUST_REPLACE(WPADControlMotor, WUPS_LOADER_LIBRARY_PADSCORE, WPADControlMotor); WUPS_MUST_REPLACE(WPADControlMotor, WUPS_LOADER_LIBRARY_PADSCORE, WPADControlMotor);
WUPS_MUST_REPLACE(WPADProbe, WUPS_LOADER_LIBRARY_PADSCORE, WPADProbe); WUPS_MUST_REPLACE(WPADProbe, WUPS_LOADER_LIBRARY_PADSCORE, WPADProbe);

97
src/WUPSConfigItemPadMapping.cpp
View File

@ -17,16 +17,16 @@
#include "WUPSConfigItemPadMapping.h" #include "WUPSConfigItemPadMapping.h"
#include <controller_patcher/ControllerPatcher.hpp> #include <controller_patcher/ControllerPatcher.hpp>
#include <vector> #include <padscore/wpad.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <utils/logger.h>
#include <vpad/input.h>
#include <padscore/wpad.h>
#include <utils/StringTools.h> #include <utils/StringTools.h>
#include <utils/logger.h>
#include <vector>
#include <vpad/input.h>
// At this point the VPADRead function is already patched. But we want to use the original function (note: this could be patched by a different plugin) // At this point the VPADRead function is already patched. But we want to use the original function (note: this could be patched by a different plugin)
typedef int32_t (*VPADReadFunction) (VPADChan chan, VPADStatus *buffer, uint32_t buffer_size, VPADReadError *error); typedef int32_t (*VPADReadFunction)(VPADChan chan, VPADStatus *buffer, uint32_t buffer_size, VPADReadError *error);
extern VPADReadFunction real_VPADRead; extern VPADReadFunction real_VPADRead;
bool WUPSConfigItemPadMapping_callCallback(void *context) { bool WUPSConfigItemPadMapping_callCallback(void *context) {
@ -40,15 +40,15 @@ bool WUPSConfigItemPadMapping_callCallback(void *context) {
void restoreDefault(void *context) { void restoreDefault(void *context) {
auto *item = (ConfigItemPadMapping *) context; auto *item = (ConfigItemPadMapping *) context;
memset(&item->mappedPadInfo,0,sizeof(item->mappedPadInfo)); memset(&item->mappedPadInfo, 0, sizeof(item->mappedPadInfo));
} }
bool updatePadInfo(ConfigItemPadMapping *item) { bool updatePadInfo(ConfigItemPadMapping *item) {
int32_t found = ControllerPatcher::getActiveMappingSlot(item->controllerType); int32_t found = ControllerPatcher::getActiveMappingSlot(item->controllerType);
if(found != -1) { if (found != -1) {
ControllerMappingPADInfo * info = ControllerPatcher::getControllerMappingInfo(item->controllerType,found); ControllerMappingPADInfo *info = ControllerPatcher::getControllerMappingInfo(item->controllerType, found);
if(info != nullptr) { if (info != nullptr) {
memcpy(&item->mappedPadInfo,info,sizeof(item->mappedPadInfo)); memcpy(&item->mappedPadInfo, info, sizeof(item->mappedPadInfo));
return true; return true;
} }
} else { } else {
@ -60,31 +60,31 @@ bool updatePadInfo(ConfigItemPadMapping *item) {
int32_t WUPSConfigItemPadMapping_getCurrentValueDisplay(void *context, char *out_buf, int32_t out_size) { int32_t WUPSConfigItemPadMapping_getCurrentValueDisplay(void *context, char *out_buf, int32_t out_size) {
auto *item = (ConfigItemPadMapping *) context; auto *item = (ConfigItemPadMapping *) context;
if(!updatePadInfo(item)) { if (!updatePadInfo(item)) {
snprintf(out_buf, out_size, "No Device"); snprintf(out_buf, out_size, "No Device");
return 0; return 0;
} }
std::string name; std::string name;
std::string isConnectedString = "attached"; std::string isConnectedString = "attached";
if(!ControllerPatcher::isControllerConnectedAndActive(item->controllerType)) { if (!ControllerPatcher::isControllerConnectedAndActive(item->controllerType)) {
isConnectedString = "detached"; isConnectedString = "detached";
} }
ControllerMappingPADInfo * info = &item->mappedPadInfo; ControllerMappingPADInfo *info = &item->mappedPadInfo;
if(info->type == CM_Type_Controller) { if (info->type == CM_Type_Controller) {
std::string titleString = ControllerPatcher::getIdentifierByVIDPID(info->vidpid.vid,info->vidpid.pid); std::string titleString = ControllerPatcher::getIdentifierByVIDPID(info->vidpid.vid, info->vidpid.pid);
std::vector<std::string> result = StringTools::stringSplit(titleString, "\n"); std::vector<std::string> result = StringTools::stringSplit(titleString, "\n");
if(result.size() == 1) { if (result.size() == 1) {
name = titleString; name = titleString;
} else if(result.size() == 2) { } else if (result.size() == 2) {
name = StringTools::strfmt("0x%04X / 0x%04X(%d) %s",info->vidpid.vid, info->vidpid.pid, info->pad, isConnectedString.c_str()); name = StringTools::strfmt("0x%04X / 0x%04X(%d) %s", info->vidpid.vid, info->vidpid.pid, info->pad, isConnectedString.c_str());
} }
} else if(info->type == CM_Type_RealController) { } else if (info->type == CM_Type_RealController) {
// currently this case can't happen. // currently this case can't happen.
name = "Real (Pro) Controller"; name = "Real (Pro) Controller";
} else if(info->type == CM_Type_Mouse || info->type == CM_Type_Keyboard) { } else if (info->type == CM_Type_Mouse || info->type == CM_Type_Keyboard) {
// currently this case can't happen. // currently this case can't happen.
name = "Mouse / Keyboard"; name = "Mouse / Keyboard";
} }
@ -96,51 +96,51 @@ int32_t WUPSConfigItemPadMapping_getCurrentValueDisplay(void *context, char *out
void checkForInput(ConfigItemPadMapping *item) { void checkForInput(ConfigItemPadMapping *item) {
int32_t inputsize = gHIDMaxDevices; int32_t inputsize = gHIDMaxDevices;
auto * hiddata = (InputData * ) malloc(sizeof(InputData)*inputsize); auto *hiddata = (InputData *) malloc(sizeof(InputData) * inputsize);
memset(hiddata,0,sizeof(InputData)*inputsize); memset(hiddata, 0, sizeof(InputData) * inputsize);
ControllerMappingPADInfo pad_result; ControllerMappingPADInfo pad_result;
memset(&pad_result,0,sizeof(ControllerMappingPADInfo)); memset(&pad_result, 0, sizeof(ControllerMappingPADInfo));
bool gotPress = false; bool gotPress = false;
VPADStatus vpad_data; VPADStatus vpad_data;
VPADReadError error; VPADReadError error;
while(!gotPress) { while (!gotPress) {
real_VPADRead(VPAD_CHAN_0, &vpad_data, 1, &error); real_VPADRead(VPAD_CHAN_0, &vpad_data, 1, &error);
if(error != VPAD_READ_SUCCESS) { if (error != VPAD_READ_SUCCESS) {
if(vpad_data.hold == VPAD_BUTTON_B || vpad_data.hold == VPAD_BUTTON_HOME) { if (vpad_data.hold == VPAD_BUTTON_B || vpad_data.hold == VPAD_BUTTON_HOME) {
break; break;
} }
} }
int32_t result = ControllerPatcher::gettingInputAllDevices(hiddata,inputsize); int32_t result = ControllerPatcher::gettingInputAllDevices(hiddata, inputsize);
if(result > 0) { if (result > 0) {
//log_printf("got %d results",result); //log_printf("got %d results",result);
for(int32_t i =0; i<result; i++) { for (int32_t i = 0; i < result; i++) {
for(int32_t j = 0; j<HID_MAX_PADS_COUNT; j++) { for (int32_t j = 0; j < HID_MAX_PADS_COUNT; j++) {
//log_printf("check pad %d. %08X",j,hiddata[i].button_data[j].btn_h); //log_printf("check pad %d. %08X",j,hiddata[i].button_data[j].btn_h);
if(hiddata[i].button_data[j].btn_h != 0) { if (hiddata[i].button_data[j].btn_h != 0) {
//log_printf("It pressed a buttons!",result); //log_printf("It pressed a buttons!",result);
pad_result.pad = j; pad_result.pad = j;
pad_result.vidpid.vid = hiddata[i].device_info.vidpid.vid; pad_result.vidpid.vid = hiddata[i].device_info.vidpid.vid;
pad_result.vidpid.pid = hiddata[i].device_info.vidpid.pid; pad_result.vidpid.pid = hiddata[i].device_info.vidpid.pid;
pad_result.active = 1; pad_result.active = 1;
pad_result.type = hiddata[i].type; pad_result.type = hiddata[i].type;
gotPress = true; gotPress = true;
DEBUG_FUNCTION_LINE("%04X %04X (PAD: %d) pressed a buttons %08X",hiddata[i].device_info.vidpid.vid,hiddata[i].device_info.vidpid.pid,j,hiddata[i].button_data[j].btn_h); DEBUG_FUNCTION_LINE("%04X %04X (PAD: %d) pressed a buttons %08X", hiddata[i].device_info.vidpid.vid, hiddata[i].device_info.vidpid.pid, j, hiddata[i].button_data[j].btn_h);
break; break;
} }
} }
if(gotPress) { if (gotPress) {
break; break;
} }
} }
} }
} }
if(gotPress) { if (gotPress) {
ControllerPatcher::addControllerMapping(item->controllerType,pad_result); ControllerPatcher::addControllerMapping(item->controllerType, pad_result);
updatePadInfo(item); updatePadInfo(item);
WUPSConfigItemPadMapping_callCallback(item); WUPSConfigItemPadMapping_callCallback(item);
} }
@ -150,7 +150,7 @@ void checkForInput(ConfigItemPadMapping *item) {
void WUPSConfigItemPadMapping_onButtonPressed(void *context, WUPSConfigButtons buttons) { void WUPSConfigItemPadMapping_onButtonPressed(void *context, WUPSConfigButtons buttons) {
auto *item = (ConfigItemPadMapping *) context; auto *item = (ConfigItemPadMapping *) context;
if(buttons & WUPS_CONFIG_BUTTON_A) { if (buttons & WUPS_CONFIG_BUTTON_A) {
// Lets remove the old mapping. // Lets remove the old mapping.
ControllerPatcher::resetControllerMapping(item->controllerType); ControllerPatcher::resetControllerMapping(item->controllerType);
@ -179,19 +179,18 @@ extern "C" bool WUPSConfigItemPadMapping_AddToCategory(WUPSConfigCategoryHandle
strncpy(item->configId, configID, sizeof(item->configId)); strncpy(item->configId, configID, sizeof(item->configId));
item->controllerType = controllerType; item->controllerType = controllerType;
item->callback = (void *) callback; item->callback = (void *) callback;
memset(&item->mappedPadInfo,0, sizeof(item->mappedPadInfo)); memset(&item->mappedPadInfo, 0, sizeof(item->mappedPadInfo));
WUPSConfigCallbacks_t callbacks = { WUPSConfigCallbacks_t callbacks = {
.getCurrentValueDisplay = &WUPSConfigItemPadMapping_getCurrentValueDisplay, .getCurrentValueDisplay = &WUPSConfigItemPadMapping_getCurrentValueDisplay,
.getCurrentValueSelectedDisplay = &WUPSConfigItemPadMapping_getCurrentValueDisplay, .getCurrentValueSelectedDisplay = &WUPSConfigItemPadMapping_getCurrentValueDisplay,
.onSelected = nullptr, .onSelected = nullptr,
.restoreDefault = &restoreDefault, .restoreDefault = &restoreDefault,
.isMovementAllowed = &WUPSConfigItemPadMapping_isMovementAllowed, .isMovementAllowed = &WUPSConfigItemPadMapping_isMovementAllowed,
.callCallback = nullptr, .callCallback = nullptr,
.onButtonPressed = &WUPSConfigItemPadMapping_onButtonPressed, .onButtonPressed = &WUPSConfigItemPadMapping_onButtonPressed,
.onDelete = &WUPSConfigItemPadMapping_onDelete .onDelete = &WUPSConfigItemPadMapping_onDelete};
};
if (WUPSConfigItem_Create(&item->handle, configID, displayName, callbacks, item) < 0) { if (WUPSConfigItem_Create(&item->handle, configID, displayName, callbacks, item) < 0) {
free(item); free(item);

4
src/WUPSConfigItemPadMapping.h
View File

@ -15,8 +15,8 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/ ****************************************************************************/
#include <wups.h>
#include <controller_patcher/ControllerPatcher.hpp> #include <controller_patcher/ControllerPatcher.hpp>
#include <wups.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -27,7 +27,7 @@ typedef struct ConfigItemPadMapping {
char configId[32]; char configId[32];
UController_Type controllerType; UController_Type controllerType;
ControllerMappingPADInfo mappedPadInfo; ControllerMappingPADInfo mappedPadInfo;
void* callback; void *callback;
} ConfigItemPadMapping; } ConfigItemPadMapping;
typedef void (*ConfigItemPadMappingChangedCallback)(ConfigItemPadMapping *); typedef void (*ConfigItemPadMappingChangedCallback)(ConfigItemPadMapping *);

14
src/main.cpp
View File

@ -17,8 +17,8 @@
#include <wups.h> #include <wups.h>
#include <cstring>
#include <controller_patcher/ControllerPatcher.hpp> #include <controller_patcher/ControllerPatcher.hpp>
#include <cstring>
#include <utils/logger.h> #include <utils/logger.h>
@ -31,10 +31,10 @@ WUPS_PLUGIN_LICENSE("GPL");
WUPS_USE_WUT_DEVOPTAB(); WUPS_USE_WUT_DEVOPTAB();
WUPS_USE_STORAGE("hid_to_vpad"); WUPS_USE_STORAGE("hid_to_vpad");
#define SD_PATH "fs:/vol/external01" #define SD_PATH "fs:/vol/external01"
#define WIIU_PATH "/wiiu" #define WIIU_PATH "/wiiu"
#define DEFAULT_HID_TO_VPAD_PATH SD_PATH WIIU_PATH "/apps/hidtovpad" #define DEFAULT_HID_TO_VPAD_PATH SD_PATH WIIU_PATH "/apps/hidtovpad"
#define DEFAULT_CONTROLLER_PATCHER_PATCH SD_PATH WIIU_PATH "/controller" #define DEFAULT_CONTROLLER_PATCHER_PATCH SD_PATH WIIU_PATH "/controller"
extern int32_t runNetworkClient; extern int32_t runNetworkClient;
@ -48,14 +48,14 @@ ON_APPLICATION_START() {
ConfigLoad(); ConfigLoad();
if (runNetworkClient){ if (runNetworkClient) {
DEBUG_FUNCTION_LINE("Starting HID to VPAD network server"); DEBUG_FUNCTION_LINE("Starting HID to VPAD network server");
ControllerPatcher::startNetworkServer(); ControllerPatcher::startNetworkServer();
} }
ControllerPatcher::disableWiiUEnergySetting(); ControllerPatcher::disableWiiUEnergySetting();
} }
INITIALIZE_PLUGIN(){ INITIALIZE_PLUGIN() {
WHBLogUdpInit(); WHBLogUdpInit();
} }

79
src/utils/StringTools.cpp
View File

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

71
src/utils/StringTools.h
View File

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

12
src/utils/logger.h
View File

@ -9,14 +9,16 @@ extern "C" {
#include <whb/log_udp.h> #include <whb/log_udp.h>
#define __FILENAME_X__ (strrchr(__FILE__, '\\') ? strrchr(__FILE__, '\\') + 1 : __FILE__) #define __FILENAME_X__ (strrchr(__FILE__, '\\') ? strrchr(__FILE__, '\\') + 1 : __FILE__)
#define __FILENAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILENAME_X__) #define __FILENAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILENAME_X__)
#define DEBUG_FUNCTION_LINE(FMT, ARGS...)do { \ #define DEBUG_FUNCTION_LINE(FMT, ARGS...) \
WHBLogPrintf("[%23s]%30s@L%04d: " FMT "",__FILENAME__,__FUNCTION__, __LINE__, ## ARGS); \ do { \
WHBLogPrintf("[%23s]%30s@L%04d: " FMT "", __FILENAME__, __FUNCTION__, __LINE__, ##ARGS); \
} while (0); } while (0);
#define DEBUG_FUNCTION_LINE_WRITE(FMT, ARGS...)do { \ #define DEBUG_FUNCTION_LINE_WRITE(FMT, ARGS...) \
WHBLogWritef("[%23s]%30s@L%04d: " FMT "",__FILENAME__,__FUNCTION__, __LINE__, ## ARGS); \ do { \
WHBLogWritef("[%23s]%30s@L%04d: " FMT "", __FILENAME__, __FUNCTION__, __LINE__, ##ARGS); \
} while (0); } while (0);
#ifdef __cplusplus #ifdef __cplusplus