diff --git a/src/ConfigHooks.cpp b/src/ConfigHooks.cpp index 3833104..c5671de 100644 --- a/src/ConfigHooks.cpp +++ b/src/ConfigHooks.cpp @@ -19,21 +19,22 @@ #include "utils/StringTools.h" #include "utils/logger.h" #include +#include #include -#include #include bool runNetworkClient = true; -void loadMapping(std::string &persistedValue, UController_Type type); +void loadMapping(const std::string &persistedValue, UController_Type type); void ConfigLoad() { WUPS_OpenStorage(); - bool rumble = 0; + bool rumble = false; if (WUPS_GetBool(nullptr, "rumble", &rumble) == WUPS_STORAGE_ERROR_SUCCESS) { + DEBUG_FUNCTION_LINE("Set rumble to %d", rumble); ControllerPatcher::setRumbleActivated(rumble); } else { WUPS_StoreBool(nullptr, "rumble", ControllerPatcher::isRumbleActivated()); @@ -49,10 +50,27 @@ void ConfigLoad() { loadMapping(stringWrapper, UController_Type_Gamepad); } + if (WUPS_GetString(nullptr, "pro1", buffer, sizeof(buffer)) == WUPS_STORAGE_ERROR_SUCCESS) { + std::string stringWrapper = buffer; + loadMapping(stringWrapper, UController_Type_Pro1); + } + if (WUPS_GetString(nullptr, "pro2", buffer, sizeof(buffer)) == WUPS_STORAGE_ERROR_SUCCESS) { + std::string stringWrapper = buffer; + loadMapping(stringWrapper, UController_Type_Pro2); + } + if (WUPS_GetString(nullptr, "pro3", buffer, sizeof(buffer)) == WUPS_STORAGE_ERROR_SUCCESS) { + std::string stringWrapper = buffer; + loadMapping(stringWrapper, UController_Type_Pro3); + } + if (WUPS_GetString(nullptr, "pro4", buffer, sizeof(buffer)) == WUPS_STORAGE_ERROR_SUCCESS) { + std::string stringWrapper = buffer; + loadMapping(stringWrapper, UController_Type_Pro4); + } + WUPS_CloseStorage(); } -void loadMapping(std::string &persistedValue, UController_Type controllerType) { +void loadMapping(const std::string &persistedValue, UController_Type controllerType) { if (persistedValue.empty()) { // No device mapped. return; @@ -68,7 +86,6 @@ void loadMapping(std::string &persistedValue, UController_Type controllerType) { mappedPadInfo.pad = atoi(result.at(2).c_str()); mappedPadInfo.type = CM_Type_Controller; //atoi(result.at(3).c_str()); - ControllerPatcher::resetControllerMapping(controllerType); ControllerPatcher::addControllerMapping(controllerType, mappedPadInfo); } @@ -90,60 +107,51 @@ void networkClientChanged(ConfigItemBoolean *item, bool newValue) { } void PadMappingUpdated(ConfigItemPadMapping *item) { + ControllerPatcher::resetControllerMapping(item->controllerType); 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); WUPS_StoreString(nullptr, item->configId, res.c_str()); - } else { - WUPS_StoreString(nullptr, item->configId, ""); + loadMapping(res, item->controllerType); + return; } + WUPS_StoreString(nullptr, item->configId, ""); } - +bool gConfigMenuOpen = false; WUPS_CONFIG_CLOSED() { - WUPS_CloseStorage(); + gConfigMenuOpen = false; + // Save all changes + if (WUPS_CloseStorage() != WUPS_STORAGE_ERROR_SUCCESS) { + OSReport("Failed to close storage\n"); + } } -#define CONFIG_AddCategoryByName(config, name, callback) \ - if (WUPSConfig_AddCategoryByName(config, name, callback) < 0) { \ - WUPSConfig_Destroy(config); \ - return 0; \ +#define CONFIG_PadMapping_AddToCategory(__config__, category, config_id, display_name, controller_type, callback) \ + if (!WUPSConfigItemPadMapping_AddToCategory(category, config_id, display_name, controller_type, callback)) { \ + WUPSConfig_Destroy(__config__); \ + 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) \ - if (!WUPSConfigItemPadMapping_AddToCategory(category, config_id, display_name, controller_type, callback)) { \ - WUPSConfig_Destroy(config); \ - return 0; \ - } - - WUPS_GET_CONFIG() { WUPS_OpenStorage(); + gConfigMenuOpen = true; WUPSConfigHandle config; - if (WUPSConfig_Create(&config, "HID to VPAD") < 0) { - return 0; - } + WUPSConfig_CreateHandled(&config, "HID to VPAD"); WUPSConfigCategoryHandle catMapping; WUPSConfigCategoryHandle catOther; - CONFIG_AddCategoryByName(config, "Mapping", &catMapping); - CONFIG_AddCategoryByName(config, "Other", &catOther); + WUPSConfig_AddCategoryByNameHandled(config, "Mapping", &catMapping); + WUPSConfig_AddCategoryByNameHandled(config, "Other", &catOther); + WUPSConfigItemBoolean_AddToCategoryHandledEx(config, catOther, "rumble", "Rumble", ControllerPatcher::isRumbleActivated(), &rumbleChanged, "On", "Off"); + WUPSConfigItemBoolean_AddToCategoryHandledEx(config, catOther, "networkclient", "Network Client", runNetworkClient, &networkClientChanged, "On", "Off"); - CONFIG_Boolean_AddToCategoryEx(catOther, "rumble", "Rumble", ControllerPatcher::isRumbleActivated(), &rumbleChanged, "On", "Off"); - CONFIG_Boolean_AddToCategoryEx(catOther, "networkclient", "Network Client", runNetworkClient, &networkClientChanged, "On", "Off"); - - CONFIG_PadMapping_AddToCategory(catMapping, "gamepadmapping", "Gamepad", UController_Type_Gamepad, &PadMappingUpdated); - CONFIG_PadMapping_AddToCategory(catMapping, "gamepadmapping", "Pro Controller 1", UController_Type_Pro1, &PadMappingUpdated); - CONFIG_PadMapping_AddToCategory(catMapping, "gamepadmapping", "Pro Controller 2", UController_Type_Pro2, &PadMappingUpdated); - CONFIG_PadMapping_AddToCategory(catMapping, "gamepadmapping", "Pro Controller 3", UController_Type_Pro3, &PadMappingUpdated); - CONFIG_PadMapping_AddToCategory(catMapping, "gamepadmapping", "Pro Controller 4", UController_Type_Pro4, &PadMappingUpdated); + CONFIG_PadMapping_AddToCategory(config, catMapping, "gamepadmapping", "Gamepad", UController_Type_Gamepad, &PadMappingUpdated); + CONFIG_PadMapping_AddToCategory(config, catMapping, "pro1", "Pro Controller 1", UController_Type_Pro1, &PadMappingUpdated); + CONFIG_PadMapping_AddToCategory(config, catMapping, "pro2", "Pro Controller 2", UController_Type_Pro2, &PadMappingUpdated); + CONFIG_PadMapping_AddToCategory(config, catMapping, "pro3", "Pro Controller 3", UController_Type_Pro3, &PadMappingUpdated); + CONFIG_PadMapping_AddToCategory(config, catMapping, "pro4", "Pro Controller 4", UController_Type_Pro4, &PadMappingUpdated); return config; } diff --git a/src/FunctionPatches.cpp b/src/FunctionPatches.cpp index 3fb2a21..f3f0368 100644 --- a/src/FunctionPatches.cpp +++ b/src/FunctionPatches.cpp @@ -16,10 +16,18 @@ ****************************************************************************/ #include +#include "utils/logger.h" #include +#include +#include +#include +extern bool gConfigMenuOpen; DECL_FUNCTION(int32_t, VPADRead, VPADChan chan, VPADStatus *buffer, uint32_t buffer_size, VPADReadError *error) { int32_t result = real_VPADRead(chan, buffer, buffer_size, error); + if (gConfigMenuOpen) { + return result; + } //A keyboard only sends data when the state changes. We force it to call the sampling callback on each frame! ControllerPatcher::sampleKeyboardData(); @@ -51,7 +59,14 @@ DECL_FUNCTION(int32_t, VPADRead, VPADChan chan, VPADStatus *buffer, uint32_t buf return result; } +DECL_FUNCTION(void, WPADInit) { + real_WPADInit(); + ControllerPatcher::UpdateSamplingFunctionAddress(); +} DECL_FUNCTION(int32_t, WPADProbe, WPADChan chan, uint32_t *result) { + if (gConfigMenuOpen) { + return real_WPADProbe(chan, result); + } if ((chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) || (chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) || (chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) || @@ -66,7 +81,7 @@ DECL_FUNCTION(int32_t, WPADProbe, WPADChan chan, uint32_t *result) { } DECL_FUNCTION(WPADConnectCallback, WPADSetConnectCallback, WPADChan chan, WPADConnectCallback callback) { - //log_printf("WPADSetConnectCallback chan %d %08X",chan,callback); + DEBUG_FUNCTION_LINE("WPADSetConnectCallback chan %d %08X", chan, callback); ControllerPatcher::setWPADConnectCallback(chan, callback); @@ -75,14 +90,14 @@ DECL_FUNCTION(WPADConnectCallback, WPADSetConnectCallback, WPADChan chan, WPADCo (chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) || (chan == WPAD_CHAN_3 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro4))) { if (callback != nullptr) { - callback(chan, 0); + //callback(chan, 0); } } return real_WPADSetConnectCallback(chan, callback); } DECL_FUNCTION(WPADExtensionCallback, WPADSetExtensionCallback, WPADChan chan, WPADExtensionCallback callback) { - //log_printf("WPADSetExtensionCallback chan %d %08X",chan,callback); + DEBUG_FUNCTION_LINE("WPADSetExtensionCallback chan %d %08X", chan, callback); ControllerPatcher::setKPADExtensionCallback(chan, callback); @@ -91,14 +106,14 @@ DECL_FUNCTION(WPADExtensionCallback, WPADSetExtensionCallback, WPADChan chan, WP (chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) || (chan == WPAD_CHAN_3 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro4))) { if (callback != nullptr) { - callback(chan, WPAD_EXT_PRO_CONTROLLER); + //callback(chan, WPAD_EXT_PRO_CONTROLLER); } } return real_WPADSetExtensionCallback(chan, callback); } DECL_FUNCTION(WPADConnectCallback, KPADSetConnectCallback, WPADChan chan, WPADConnectCallback callback) { - //log_printf("KPADSetConnectCallback chan %d %08X",chan,callback); + DEBUG_FUNCTION_LINE("KPADSetConnectCallback chan %d %08X", chan, callback); ControllerPatcher::setKPADConnectedCallback(chan, callback); @@ -107,7 +122,7 @@ DECL_FUNCTION(WPADConnectCallback, KPADSetConnectCallback, WPADChan chan, WPADCo (chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) || (chan == WPAD_CHAN_3 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro4))) { if (callback != nullptr) { - callback(chan, 0); + //callback(chan, 0); } } return real_KPADSetConnectCallback(chan, callback); @@ -127,7 +142,6 @@ DECL_FUNCTION(uint8_t, WPADGetBatteryLevel, WPADChan chan) { //In case a game relies on this... DECL_FUNCTION(uint32_t, WPADGetDataFormat, WPADChan chan) { - //log_printf("WPADGetDataFormat chan: %d result: %d",chan,result); if ((chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) || (chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) || (chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) || @@ -151,6 +165,11 @@ DECL_FUNCTION(int32_t, WPADSetDataFormat, WPADChan chan, WPADDataFormat fmt) { } DECL_FUNCTION(void, WPADRead, WPADChan chan, WPADStatusProController *data) { + if (gConfigMenuOpen) { + real_WPADRead(chan, data); + return; + } + if ((chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) || (chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) || (chan == WPAD_CHAN_2 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro3)) || @@ -162,6 +181,10 @@ DECL_FUNCTION(void, WPADRead, WPADChan chan, WPADStatusProController *data) { } DECL_FUNCTION(void, WPADControlMotor, WPADChan chan, uint32_t status) { + if (gConfigMenuOpen) { + real_WPADControlMotor(chan, status); + return; + } if (chan == WPAD_CHAN_0 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro1)) { ControllerPatcher::setRumble(UController_Type_Pro1, status); } else if (chan == WPAD_CHAN_1 && ControllerPatcher::isControllerConnectedAndActive(UController_Type_Pro2)) { @@ -184,3 +207,4 @@ WUPS_MUST_REPLACE(WPADGetDataFormat, WUPS_LOADER_LIBRARY_PADSCORE, WPADGetDataFo WUPS_MUST_REPLACE(WPADSetDataFormat, WUPS_LOADER_LIBRARY_PADSCORE, WPADSetDataFormat); WUPS_MUST_REPLACE(WPADControlMotor, WUPS_LOADER_LIBRARY_PADSCORE, WPADControlMotor); WUPS_MUST_REPLACE(WPADProbe, WUPS_LOADER_LIBRARY_PADSCORE, WPADProbe); +WUPS_MUST_REPLACE(WPADInit, WUPS_LOADER_LIBRARY_PADSCORE, WPADInit); diff --git a/src/WUPSConfigItemPadMapping.cpp b/src/WUPSConfigItemPadMapping.cpp index 52be366..4908c3c 100644 --- a/src/WUPSConfigItemPadMapping.cpp +++ b/src/WUPSConfigItemPadMapping.cpp @@ -17,6 +17,7 @@ #include "WUPSConfigItemPadMapping.h" #include +#include #include #include #include @@ -58,57 +59,26 @@ bool updatePadInfo(ConfigItemPadMapping *item) { return false; } -int32_t WUPSConfigItemPadMapping_getCurrentValueDisplay(void *context, char *out_buf, int32_t out_size) { - auto *item = (ConfigItemPadMapping *) context; - if (!updatePadInfo(item)) { - snprintf(out_buf, out_size, "No Device"); - return 0; - } - std::string name; - std::string isConnectedString = "attached"; - - if (!ControllerPatcher::isControllerConnectedAndActive(item->controllerType)) { - isConnectedString = "detached"; - } - - ControllerMappingPADInfo *info = &item->mappedPadInfo; - - if (info->type == CM_Type_Controller) { - std::string titleString = ControllerPatcher::getIdentifierByVIDPID(info->vidpid.vid, info->vidpid.pid); - std::vector result = StringTools::stringSplit(titleString, "\n"); - if (result.size() == 1) { - name = titleString; - } 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()); - } - } else if (info->type == CM_Type_RealController) { - // currently this case can't happen. - name = "Real (Pro) Controller"; - } else if (info->type == CM_Type_Mouse || info->type == CM_Type_Keyboard) { - // currently this case can't happen. - name = "Mouse / Keyboard"; - } - - strncpy(out_buf, name.c_str(), out_size); - - return 0; -} void checkForInput(ConfigItemPadMapping *item) { int32_t inputsize = gHIDMaxDevices; auto *hiddata = (InputData *) malloc(sizeof(InputData) * inputsize); memset(hiddata, 0, sizeof(InputData) * inputsize); - ControllerMappingPADInfo pad_result; - memset(&pad_result, 0, sizeof(ControllerMappingPADInfo)); - bool gotPress = false; + ControllerMappingPADInfo pad_result = {}; + bool gotPress = false; - VPADStatus vpad_data; + VPADStatus vpad_data = {}; VPADReadError error; + bool unmap = false; while (!gotPress) { real_VPADRead(VPAD_CHAN_0, &vpad_data, 1, &error); if (error != VPAD_READ_SUCCESS) { + if (vpad_data.hold == VPAD_BUTTON_X || vpad_data.hold == VPAD_BUTTON_HOME) { + unmap = true; + break; + } if (vpad_data.hold == VPAD_BUTTON_B || vpad_data.hold == VPAD_BUTTON_HOME) { break; } @@ -116,12 +86,9 @@ void checkForInput(ConfigItemPadMapping *item) { int32_t result = ControllerPatcher::gettingInputAllDevices(hiddata, inputsize); if (result > 0) { - //log_printf("got %d results",result); for (int32_t i = 0; i < result; i++) { 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); if (hiddata[i].button_data[j].btn_h != 0) { - //log_printf("It pressed a buttons!",result); pad_result.pad = j; pad_result.vidpid.vid = hiddata[i].device_info.vidpid.vid; pad_result.vidpid.pid = hiddata[i].device_info.vidpid.pid; @@ -129,7 +96,7 @@ void checkForInput(ConfigItemPadMapping *item) { pad_result.type = hiddata[i].type; 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", pad_result.vidpid.vid, pad_result.vidpid.pid, pad_result.pad, hiddata[i].button_data[j].btn_h); break; } } @@ -140,21 +107,75 @@ void checkForInput(ConfigItemPadMapping *item) { } } if (gotPress) { + ControllerPatcher::resetControllerMapping(item->controllerType); ControllerPatcher::addControllerMapping(item->controllerType, pad_result); updatePadInfo(item); WUPSConfigItemPadMapping_callCallback(item); + } else if (unmap) { + ControllerPatcher::resetControllerMapping(item->controllerType); + updatePadInfo(item); + WUPSConfigItemPadMapping_callCallback(item); } free(hiddata); } +static std::string GetDeviceName(ConfigItemPadMapping *item) { + if (!updatePadInfo(item)) { + return "No Device"; + } + + std::string name; + std::string isConnectedString = "attached"; + + if (!ControllerPatcher::isControllerConnectedAndActive(item->controllerType)) { + isConnectedString = "detached"; + } + + ControllerMappingPADInfo *info = &item->mappedPadInfo; + + if (info->type == CM_Type_Controller) { + std::string titleString = ControllerPatcher::getIdentifierByVIDPID(info->vidpid.vid, info->vidpid.pid); + name = StringTools::strfmt("%s (%d) %s", titleString.c_str(), info->pad, isConnectedString.c_str()); + } else if (info->type == CM_Type_RealController) { + // currently this case can't happen. + name = "Real (Pro) Controller"; + } else if (info->type == CM_Type_Mouse || info->type == CM_Type_Keyboard) { + // currently this case can't happen. + name = "Mouse / Keyboard"; + } + return name; +} + +int32_t WUPSConfigItemPadMapping_getCurrentValueDisplaySelected(void *context, char *out_buf, int32_t out_size) { + auto *item = (ConfigItemPadMapping *) context; + if (item->state == CONFIG_ITEM_PAD_MAPPING_PREPARE_FOR_HOLD || item->state == CONFIG_ITEM_PAD_MAPPING_WAIT_FOR_HOLD) { + if (item->state == CONFIG_ITEM_PAD_MAPPING_PREPARE_FOR_HOLD) { + item->state = CONFIG_ITEM_PAD_MAPPING_WAIT_FOR_HOLD; + snprintf(out_buf, out_size, " (\ue001: Abort, \ue002 Reset)"); + return 0; + } else { + checkForInput(item); + item->state = CONFIG_ITEM_PAD_MAPPING_STATE_NONE; + } + } + snprintf(out_buf, out_size, "> %s", GetDeviceName(item).c_str()); + return 0; +} + +int32_t WUPSConfigItemPadMapping_getCurrentValueDisplay(void *context, char *out_buf, int32_t out_size) { + auto *item = (ConfigItemPadMapping *) context; + std::string name = GetDeviceName(item); + snprintf(out_buf, out_size, " %s", GetDeviceName(item).c_str()); + return 0; +} + void WUPSConfigItemPadMapping_onButtonPressed(void *context, WUPSConfigButtons buttons) { auto *item = (ConfigItemPadMapping *) context; - if (buttons & WUPS_CONFIG_BUTTON_A) { - // Lets remove the old mapping. - ControllerPatcher::resetControllerMapping(item->controllerType); - - checkForInput(item); + if (item->state == CONFIG_ITEM_PAD_MAPPING_STATE_NONE) { + if ((buttons & WUPS_CONFIG_BUTTON_A) == WUPS_CONFIG_BUTTON_A) { + item->state = CONFIG_ITEM_PAD_MAPPING_PREPARE_FOR_HOLD; + } } } @@ -162,33 +183,48 @@ bool WUPSConfigItemPadMapping_isMovementAllowed(void *context) { return true; } + +void WUPSConfigItemPadMapping_onSelected(void *context, bool isSelected) { +} + + void WUPSConfigItemPadMapping_onDelete(void *context) { auto *item = (ConfigItemPadMapping *) context; - + if (item->configId) { + free(item->configId); + } free(item); } + extern "C" bool WUPSConfigItemPadMapping_AddToCategory(WUPSConfigCategoryHandle cat, const char *configID, const char *displayName, UController_Type controllerType, ConfigItemPadMappingChangedCallback callback) { if (cat == 0 || displayName == nullptr) { return false; } auto *item = (ConfigItemPadMapping *) malloc(sizeof(ConfigItemPadMapping)); if (item == nullptr) { + OSReport("WUPSConfigItemPadMapping_AddToCategory: Failed to allocate memory for item data.\n"); return false; } - strncpy(item->configId, configID, sizeof(item->configId)); + if (configID != nullptr) { + item->configId = strdup(configID); + } else { + item->configId = nullptr; + } + item->controllerType = controllerType; item->callback = (void *) callback; + item->state = CONFIG_ITEM_PAD_MAPPING_STATE_NONE; memset(&item->mappedPadInfo, 0, sizeof(item->mappedPadInfo)); WUPSConfigCallbacks_t callbacks = { .getCurrentValueDisplay = &WUPSConfigItemPadMapping_getCurrentValueDisplay, - .getCurrentValueSelectedDisplay = &WUPSConfigItemPadMapping_getCurrentValueDisplay, - .onSelected = nullptr, + .getCurrentValueSelectedDisplay = &WUPSConfigItemPadMapping_getCurrentValueDisplaySelected, + .onSelected = &WUPSConfigItemPadMapping_onSelected, .restoreDefault = &restoreDefault, .isMovementAllowed = &WUPSConfigItemPadMapping_isMovementAllowed, - .callCallback = nullptr, + .callCallback = &WUPSConfigItemPadMapping_callCallback, .onButtonPressed = &WUPSConfigItemPadMapping_onButtonPressed, .onDelete = &WUPSConfigItemPadMapping_onDelete}; diff --git a/src/WUPSConfigItemPadMapping.h b/src/WUPSConfigItemPadMapping.h index b79c00d..ca86767 100644 --- a/src/WUPSConfigItemPadMapping.h +++ b/src/WUPSConfigItemPadMapping.h @@ -22,10 +22,18 @@ extern "C" { #endif + +typedef enum ConfigItemPadMappingState { + CONFIG_ITEM_PAD_MAPPING_STATE_NONE, + CONFIG_ITEM_PAD_MAPPING_PREPARE_FOR_HOLD, + CONFIG_ITEM_PAD_MAPPING_WAIT_FOR_HOLD, +} ConfigItemPadMappingState; + typedef struct ConfigItemPadMapping { + char *configId; WUPSConfigItemHandle handle; - char configId[32]; UController_Type controllerType; + ConfigItemPadMappingState state; ControllerMappingPADInfo mappedPadInfo; void *callback; } ConfigItemPadMapping; diff --git a/src/main.cpp b/src/main.cpp index ca736c1..afecef4 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -21,26 +21,25 @@ #include #include - -WUPS_PLUGIN_NAME("HID to VPAD lite"); +WUPS_PLUGIN_NAME("HID to VPAD"); WUPS_PLUGIN_DESCRIPTION("Enables HID devices as controllers on your Wii U"); -WUPS_PLUGIN_VERSION("v1.0"); +WUPS_PLUGIN_VERSION("0.1.1-alpha"); WUPS_PLUGIN_AUTHOR("Maschell"); WUPS_PLUGIN_LICENSE("GPL"); WUPS_USE_WUT_DEVOPTAB(); WUPS_USE_STORAGE("hid_to_vpad"); -#define SD_PATH "fs:/vol/external01" -#define WIIU_PATH "/wiiu" -#define DEFAULT_HID_TO_VPAD_PATH SD_PATH WIIU_PATH "/apps/hidtovpad" -#define DEFAULT_CONTROLLER_PATCHER_PATCH SD_PATH WIIU_PATH "/controller" - extern int32_t runNetworkClient; +#define SD_PATH "fs:/vol/external01" +#define WIIU_PATH "/wiiu" +#define DEFAULT_CONTROLLER_PATCHER_PATCH SD_PATH WIIU_PATH "/controller" + void ConfigLoad(); ON_APPLICATION_START() { WHBLogUdpInit(); + WHBLogCafeInit(); DEBUG_FUNCTION_LINE("Initializing the controller data"); ControllerPatcher::Init(DEFAULT_CONTROLLER_PATCHER_PATCH); @@ -60,7 +59,6 @@ INITIALIZE_PLUGIN() { } DEINITIALIZE_PLUGIN() { - //CursorDrawer::destroyInstance(); ControllerPatcher::DeInit(); ControllerPatcher::stopNetworkServer(); } diff --git a/src/utils/logger.h b/src/utils/logger.h index f699cd1..8bdf95d 100644 --- a/src/utils/logger.h +++ b/src/utils/logger.h @@ -7,6 +7,7 @@ extern "C" { #include #include #include +#include #define __FILENAME_X__ (strrchr(__FILE__, '\\') ? strrchr(__FILE__, '\\') + 1 : __FILE__) #define __FILENAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILENAME_X__)