diff --git a/Makefile b/Makefile index fb9a117..45dcc40 100644 --- a/Makefile +++ b/Makefile @@ -51,6 +51,7 @@ SOURCES := src \ src/patcher \ src/resources \ src/sounds \ + src/settings \ src/system \ src/utils \ src/video \ diff --git a/meta/meta.xml b/meta/meta.xml index 4360675..bf5a3a9 100644 --- a/meta/meta.xml +++ b/meta/meta.xml @@ -2,10 +2,10 @@ HID to VPAD Maschell - v0.9h + v0.9i tool https://gbatemp.net/threads/hid-to-vpad.424127/ - 20170410173100 + 20170427194500 USB HID to gamepad input Emulate input using various USB HID devices. diff --git a/src/Application.cpp b/src/Application.cpp index 4027cc3..e8ef1be 100644 --- a/src/Application.cpp +++ b/src/Application.cpp @@ -24,6 +24,7 @@ #include "resources/Resources.h" #include "sounds/SoundHandler.hpp" #include "utils/logger.h" +#include "settings/CSettings.h" Application *Application::applicationInstance = NULL; bool Application::exitApplication = false; @@ -41,11 +42,13 @@ Application::Application() controller[3] = new WPadController(GuiTrigger::CHANNEL_4); controller[4] = new WPadController(GuiTrigger::CHANNEL_5); + CSettings::instance()->Load(); + //! create bgMusic bgMusic = new GuiSound(Resources::GetFile("bgMusic.mp3"), Resources::GetFileSize("bgMusic.mp3")); - //std::string languagePath = "sd:/wiiu/apps/hidtovpad/languages/english.lang"; - //gettextLoadLanguage(languagePath.c_str()); + //! load language + loadLanguageFromConfig(); exitApplication = false; } @@ -215,3 +218,10 @@ void Application::executeThread(void){ delete fontSystem; delete video; } + +void Application::loadLanguageFromConfig(){ + if(!CSettings::getValueAsString(CSettings::AppLanguage).empty()){ + std::string languagePath = "sd:/wiiu/apps/hidtovpad/languages/" + CSettings::getValueAsString(CSettings::AppLanguage) + ".lang"; + gettextLoadLanguage(languagePath.c_str()); + } +} diff --git a/src/Application.h b/src/Application.h index a93483f..8e1dd57 100644 --- a/src/Application.h +++ b/src/Application.h @@ -60,6 +60,7 @@ public: } private: Application(); + virtual ~Application(); static Application *applicationInstance; @@ -67,6 +68,8 @@ private: void executeThread(void); + void loadLanguageFromConfig(); + GuiSound *bgMusic; CVideo *video; MainWindow *mainWindow; diff --git a/src/controller_patcher b/src/controller_patcher index 83b0641..5c7be02 160000 --- a/src/controller_patcher +++ b/src/controller_patcher @@ -1 +1 @@ -Subproject commit 83b064108ecf49bf775ac636183c5f89672ae1f9 +Subproject commit 5c7be021d07e7d482accabbe686e3ff5927dde6b diff --git a/src/patcher/hid_controller_function_patcher.cpp b/src/patcher/hid_controller_function_patcher.cpp index 335fafa..9a8cc17 100644 --- a/src/patcher/hid_controller_function_patcher.cpp +++ b/src/patcher/hid_controller_function_patcher.cpp @@ -43,7 +43,7 @@ DECL(void, GX2CopyColorBufferToScanBuffer, const GX2ColorBuffer *colorBuffer, s3 } DECL(void, __PPCExit, void){ - if(HID_DEBUG) log_printf("__PPCExit\n"); + if(HID_DEBUG){ log_printf("__PPCExit\n"); } CursorDrawer::destroyInstance(); ControllerPatcher::destroyConfigHelper(); @@ -67,11 +67,11 @@ DECL(s32, VPADRead, s32 chan, VPADData *buffer, u32 buffer_size, s32 *error) { if(result > 0 && (buffer[0].btns_h & VPAD_BUTTON_TV) && gCallbackCooldown == 0){ gCallbackCooldown = 0xFF; - if(HID_DEBUG) log_printf("my_VPADRead(line %d): Pressed the TV button. Maybe we can call the callbacks.!\n",__LINE__); + if(HID_DEBUG){ log_printf("my_VPADRead(line %d): Pressed the TV button. Maybe we can call the callbacks.!\n",__LINE__); } - if(HID_DEBUG) log_printf("my_VPADRead(line %d): gExtensionCallback = %08X %08X %08X %08X\n",__LINE__,gExtensionCallback[0],gExtensionCallback[1],gExtensionCallback[2],gExtensionCallback[3]); - if(HID_DEBUG) log_printf("my_VPADRead(line %d): gWPADConnectCallback = %08X %08X %08X %08X\n",__LINE__,gWPADConnectCallback[0],gWPADConnectCallback[1],gWPADConnectCallback[2],gWPADConnectCallback[3]); - if(HID_DEBUG) log_printf("my_VPADRead(line %d): gKPADConnectCallback = %08X %08X %08X %08X\n",__LINE__,gKPADConnectCallback[0],gKPADConnectCallback[1],gKPADConnectCallback[2],gKPADConnectCallback[3]); + if(HID_DEBUG){ log_printf("my_VPADRead(line %d): gExtensionCallback = %08X %08X %08X %08X\n",__LINE__,gExtensionCallback[0],gExtensionCallback[1],gExtensionCallback[2],gExtensionCallback[3]); } + if(HID_DEBUG){ log_printf("my_VPADRead(line %d): gWPADConnectCallback = %08X %08X %08X %08X\n",__LINE__,gWPADConnectCallback[0],gWPADConnectCallback[1],gWPADConnectCallback[2],gWPADConnectCallback[3]); } + if(HID_DEBUG){ log_printf("my_VPADRead(line %d): gKPADConnectCallback = %08X %08X %08X %08X\n",__LINE__,gKPADConnectCallback[0],gKPADConnectCallback[1],gKPADConnectCallback[2],gKPADConnectCallback[3]); } for(s32 i = 0;i<4;i++){ bool doCall = false; diff --git a/src/settings/CSettings.cpp b/src/settings/CSettings.cpp new file mode 100644 index 0000000..93f2c64 --- /dev/null +++ b/src/settings/CSettings.cpp @@ -0,0 +1,243 @@ +/**************************************************************************** + * Copyright (C) 2015 Dimok + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + ****************************************************************************/ +#include +#include +#include + +#include "common/common.h" +#include "CSettings.h" +#include "SettingsEnums.h" +#include "fs/CFile.hpp" +#include "fs/fs_utils.h" +#include "utils/StringTools.h" +#include "language/gettext.h" + +#define VERSION_LINE "# HID to VPAD - Main settings file v" +#define VALID_VERSION 1 + +CSettings *CSettings::settingsInstance = NULL; + +CSettings::CSettings(){ + bChanged = false; + memset(&nullValue, 0, sizeof(nullValue)); + nullValue.strValue = new std::string(); + + configPath = SD_PATH WIIU_PATH "/apps/hidtovpad"; + this->SetDefault(); +} + +CSettings::~CSettings(){ + for(u32 i = 0; i < settingsValues.size(); i++) + { + if(settingsValues[i].dataType == TypeString) + delete settingsValues[i].strValue; + } + delete nullValue.strValue; +} + +void CSettings::SetDefault() +{ + for(u32 i = 0; i < settingsValues.size(); i++) + { + if(settingsValues[i].dataType == TypeString) + delete settingsValues[i].strValue; + } + + settingsNames.resize(MAX_VALUE); + settingsValues.resize(MAX_VALUE); + + settingsNames[AppLanguage] = "AppLanguage"; + settingsValues[AppLanguage].dataType = TypeString; + settingsValues[AppLanguage].strValue = new std::string(); + + settingsNames[RumbleActivated] = "RumbleActivated"; + settingsValues[RumbleActivated].dataType = TypeU8; + settingsValues[RumbleActivated].ucValue = SETTING_ON; +} + +bool CSettings::Load(){ + //! Reset default path variables to the right device + SetDefault(); + + std::string filepath = configPath; + filepath += "/hidtovpad.cfg"; + + CFile file(filepath, CFile::ReadOnly); + if (!file.isOpen()) + return false; + + std::string strBuffer; + strBuffer.resize(file.size()); + file.read((u8 *) &strBuffer[0], strBuffer.size()); + file.close(); + + //! remove all windows crap signs + size_t position; + while(1) + { + position = strBuffer.find('\r'); + if(position == std::string::npos) + break; + + strBuffer.erase(position, 1); + } + + std::vector lines = stringSplit(strBuffer, "\n"); + + + if(lines.empty() || !ValidVersion(lines[0])) + return false; + + for(u32 i = 0; i < lines.size(); ++i) + { + std::vector valueSplit = stringSplit(lines[i], "="); + if(valueSplit.size() != 2) + continue; + + while((valueSplit[0].size() > 0) && valueSplit[0][0] == ' ') + valueSplit[0].erase(0, 1); + + while((valueSplit[1].size() > 0) && valueSplit[1][ valueSplit[1].size() - 1 ] == ' ') + valueSplit[1].resize(valueSplit[1].size() - 1); + + for(u32 n = 0; n < settingsNames.size(); n++) + { + if(!settingsNames[n]) + continue; + + if(valueSplit[0] == settingsNames[n]) + { + switch(settingsValues[n].dataType) + { + case TypeBool: + settingsValues[n].bValue = atoi(valueSplit[1].c_str()); + break; + case TypeS8: + settingsValues[n].cValue = atoi(valueSplit[1].c_str()); + break; + case TypeU8: + settingsValues[n].ucValue = atoi(valueSplit[1].c_str()); + break; + case TypeS16: + settingsValues[n].sValue = atoi(valueSplit[1].c_str()); + break; + case TypeU16: + settingsValues[n].usValue = atoi(valueSplit[1].c_str()); + break; + case TypeS32: + settingsValues[n].iValue = atoi(valueSplit[1].c_str()); + break; + case TypeU32: + settingsValues[n].uiValue = strtoul(valueSplit[1].c_str(), 0, 10); + break; + case TypeF32: + settingsValues[n].fValue = atof(valueSplit[1].c_str()); + break; + case TypeString: + if(settingsValues[n].strValue == NULL) + settingsValues[n].strValue = new std::string(); + + *settingsValues[n].strValue = valueSplit[1]; + break; + default: + break; + } + } + } + } + + return true; +} + +bool CSettings::ValidVersion(const std::string & versionString){ + int version = 0; + + if(versionString.find(VERSION_LINE) != 0) + return false; + + version = atoi(versionString.c_str() + strlen(VERSION_LINE)); + + return version == VALID_VERSION; +} + +bool CSettings::Reset(){ + this->SetDefault(); + bChanged = true; + + if (this->Save()) + return true; + + return false; +} + +bool CSettings::Save(){ + if(!bChanged) + return true; + + CreateSubfolder(configPath.c_str()); + + std::string filepath = configPath; + filepath += "/hidtovpad.cfg"; + + CFile file(filepath, CFile::WriteOnly); + if (!file.isOpen()) + return false; + + file.fwrite("%s%i\n", VERSION_LINE, VALID_VERSION); + + for(u32 i = 0; i < settingsValues.size(); i++) + { + switch(settingsValues[i].dataType) + { + case TypeBool: + file.fwrite("%s=%i\n", settingsNames[i], settingsValues[i].bValue); + break; + case TypeS8: + file.fwrite("%s=%i\n", settingsNames[i], settingsValues[i].cValue); + break; + case TypeU8: + file.fwrite("%s=%i\n", settingsNames[i], settingsValues[i].ucValue); + break; + case TypeS16: + file.fwrite("%s=%i\n", settingsNames[i], settingsValues[i].sValue); + break; + case TypeU16: + file.fwrite("%s=%i\n", settingsNames[i], settingsValues[i].usValue); + break; + case TypeS32: + file.fwrite("%s=%i\n", settingsNames[i], settingsValues[i].iValue); + break; + case TypeU32: + file.fwrite("%s=%u\n", settingsNames[i], settingsValues[i].uiValue); + break; + case TypeF32: + file.fwrite("%s=%f\n", settingsNames[i], settingsValues[i].fValue); + break; + case TypeString: + if(settingsValues[i].strValue != NULL) + file.fwrite("%s=%s\n", settingsNames[i], settingsValues[i].strValue->c_str()); + break; + default: + break; + } + } + + file.close(); + bChanged = false; + + return true; +} diff --git a/src/settings/CSettings.h b/src/settings/CSettings.h new file mode 100644 index 0000000..784f8f9 --- /dev/null +++ b/src/settings/CSettings.h @@ -0,0 +1,255 @@ +/**************************************************************************** + * Copyright (C) 2015 Dimok + * + * Modified by Maschell, 2017 for HID to VPAD + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + ****************************************************************************/ +#ifndef _CSETTINGS_H_ +#define _CSETTINGS_H_ + +#include +#include +#include +#include +#include "SettingsEnums.h" + +class CSettings +{ +public: + static CSettings *instance() { + if(!settingsInstance) + settingsInstance = new CSettings(); + + return settingsInstance; + } + + static void destroyInstance() { + if(settingsInstance){ + delete settingsInstance; + settingsInstance = NULL; + } + } + + //!Set Default Settings + void SetDefault(); + //!Load Settings + bool Load(); + //!Save Settings + bool Save(); + //!Reset Settings + bool Reset(); + + enum DataTypes{ + TypeNone, + TypeBool, + TypeS8, + TypeU8, + TypeS16, + TypeU16, + TypeS32, + TypeU32, + TypeF32, + TypeString + }; + + + enum SettingsIdx{ + INVALID = -1, + AppLanguage, + RumbleActivated, + MAX_VALUE + }; + + static const u8 & getDataType(int idx) + { + if(idx > INVALID && idx < MAX_VALUE) + return instance()->settingsValues[idx].dataType; + + return instance()->nullValue.dataType; + } + + static const bool & getValueAsBool(int idx) + { + if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeBool) + return instance()->settingsValues[idx].bValue; + + return instance()->nullValue.bValue; + } + static const s8 & getValueAsS8(int idx) + { + if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeS8) + return instance()->settingsValues[idx].cValue; + + return instance()->nullValue.cValue; + } + static const u8 & getValueAsU8(int idx) + { + if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeU8) + return instance()->settingsValues[idx].ucValue; + + return instance()->nullValue.ucValue; + } + static const s16 & getValueAsS16(int idx) + { + if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeS16) + return instance()->settingsValues[idx].sValue; + + return instance()->nullValue.sValue; + } + static const u16 & getValueAsU16(int idx) + { + if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeU16) + return instance()->settingsValues[idx].usValue; + + return instance()->nullValue.usValue; + } + static const s32 & getValueAsS32(int idx) + { + if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeS32) + return instance()->settingsValues[idx].iValue; + + return instance()->nullValue.iValue; + } + static const u32 & getValueAsU32(int idx) + { + if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeU32) + return instance()->settingsValues[idx].uiValue; + + return instance()->nullValue.uiValue; + } + static const f32 & getValueAsF32(int idx) + { + if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeF32) + return instance()->settingsValues[idx].fValue; + + return instance()->nullValue.fValue; + } + static const std::string & getValueAsString(int idx) + { + if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeString && instance()->settingsValues[idx].strValue) + return *(instance()->settingsValues[idx].strValue); + + return *(instance()->nullValue.strValue); + } + + static void setValueAsBool(int idx, const bool & val) + { + if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeBool) + { + instance()->settingsValues[idx].bValue = val; + instance()->bChanged = true; + } + } + static void setValueAsS8(int idx, const s8 & val) + { + if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeS8) + { + instance()->settingsValues[idx].cValue = val; + instance()->bChanged = true; + } + } + static void setValueAsU8(int idx, const u8 & val) + { + if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeU8) + { + instance()->settingsValues[idx].ucValue = val; + instance()->bChanged = true; + } + } + static void setValueAsS16(int idx, const s16 & val) + { + if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeS16) + { + instance()->settingsValues[idx].sValue = val; + instance()->bChanged = true; + } + } + static void setValueAsU16(int idx, const u16 & val) + { + if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeU16) + { + instance()->settingsValues[idx].usValue = val; + instance()->bChanged = true; + } + } + static void setValueAsS32(int idx, const s32 & val) + { + if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeS32) + { + instance()->settingsValues[idx].iValue = val; + instance()->bChanged = true; + } + } + static void setValueAsU32(int idx, const u32 & val) + { + if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeU32) + { + instance()->settingsValues[idx].uiValue = val; + instance()->bChanged = true; + } + } + static void setValueAsF32(int idx, const f32 & val) + { + if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeF32) + { + instance()->settingsValues[idx].fValue = val; + instance()->bChanged = true; + } + } + static void setValueAsString(int idx, const std::string & val) + { + if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeString && instance()->settingsValues[idx].strValue) + { + *(instance()->settingsValues[idx].strValue) = val; + instance()->bChanged = true; + } + } +protected: + //!Constructor + CSettings(); + //!Destructor + ~CSettings(); + + bool ValidVersion(const std::string & versionString); + + static CSettings *settingsInstance; + + typedef struct + { + u8 dataType; + + union + { + bool bValue; + s8 cValue; + u8 ucValue; + s16 sValue; + u16 usValue; + s32 iValue; + u32 uiValue; + f32 fValue; + std::string *strValue; + }; + } SettingValue; + + SettingValue nullValue; + std::string configPath; + std::vector settingsValues; + std::vector settingsNames; + + bool bChanged; +}; + +#endif diff --git a/src/settings/SettingsDefs.h b/src/settings/SettingsDefs.h new file mode 100644 index 0000000..f254c75 --- /dev/null +++ b/src/settings/SettingsDefs.h @@ -0,0 +1,37 @@ +/**************************************************************************** + * Copyright (C) 2015 Dimok + * + * Modified by Maschell, 2017 for HID to VPAD + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + ****************************************************************************/ +#ifndef __SETTINGS_DEFS_ +#define __SETTINGS_DEFS_ + +typedef struct +{ + int value; + const char *name; +} ValueString; + +typedef struct +{ + const char *name; + const ValueString *valueStrings; + int type; + int index; +} SettingType; + + +#endif // __SETTINGS_DEFS_ diff --git a/src/settings/SettingsEnums.h b/src/settings/SettingsEnums.h new file mode 100644 index 0000000..2b45a1f --- /dev/null +++ b/src/settings/SettingsEnums.h @@ -0,0 +1,9 @@ +#ifndef SETTINGS_ENUMS_H_ +#define SETTINGS_ENUMS_H_ + +enum eOnOff{ + SETTING_OFF, + SETTING_ON +}; + +#endif // SETTINGS_ENUMS_H_ diff --git a/src/utils/function_patcher.cpp b/src/utils/function_patcher.cpp index 17554bf..e6bbf0e 100644 --- a/src/utils/function_patcher.cpp +++ b/src/utils/function_patcher.cpp @@ -74,7 +74,7 @@ void PatchInvidualMethodHooks(hooks_magic_t method_hooks[],s32 hook_information_ continue; } - if(DEBUG_LOG_DYN)log_printf("%s is located at %08X!\n", method_hooks[i].functionName,real_addr); + if(DEBUG_LOG_DYN){ log_printf("%s is located at %08X!\n", method_hooks[i].functionName,real_addr); } physical = (u32)OSEffectiveToPhysical((void*)real_addr); if(!physical){ @@ -83,7 +83,7 @@ void PatchInvidualMethodHooks(hooks_magic_t method_hooks[],s32 hook_information_ continue; } - if(DEBUG_LOG_DYN)log_printf("%s physical is located at %08X!\n", method_hooks[i].functionName,physical); + if(DEBUG_LOG_DYN){ log_printf("%s physical is located at %08X!\n", method_hooks[i].functionName,physical); } *(volatile u32 *)(call_addr) = (u32)(space) - CODE_RW_BASE_OFFSET; @@ -96,8 +96,8 @@ void PatchInvidualMethodHooks(hooks_magic_t method_hooks[],s32 hook_information_ // fill the restore instruction section method_hooks[i].realAddr = real_addr; method_hooks[i].restoreInstruction = *(space-1); - if(DEBUG_LOG_DYN)log_printf("method_hooks[i].realAddr = %08X!\n", method_hooks[i].realAddr); - if(DEBUG_LOG_DYN)log_printf("method_hooks[i].restoreInstruction = %08X!\n",method_hooks[i].restoreInstruction) ; + if(DEBUG_LOG_DYN){ log_printf("method_hooks[i].realAddr = %08X!\n", method_hooks[i].realAddr); } + if(DEBUG_LOG_DYN){ log_printf("method_hooks[i].restoreInstruction = %08X!\n",method_hooks[i].restoreInstruction) ; } } else{ log_printf("Error. Can't save %s for restoring!\n", method_hooks[i].functionName); @@ -175,9 +175,9 @@ void RestoreInvidualInstructions(hooks_magic_t method_hooks[],s32 hook_informati else { physical = (u32)OSEffectiveToPhysical((void*)method_hooks[i].realAddr); //When its an static function, we need to use the old location - if(DEBUG_LOG_DYN)log_printf("Restoring %08X to %08X\n",(u32)method_hooks[i].restoreInstruction,physical); + if(DEBUG_LOG_DYN){ log_printf("Restoring %08X to %08X\n",(u32)method_hooks[i].restoreInstruction,physical); } SC0x25_KernelCopyData(physical,(u32)&method_hooks[i].restoreInstruction , 4); - if(DEBUG_LOG_DYN)log_printf("ICInvalidateRange %08X\n",(void*)method_hooks[i].realAddr); + if(DEBUG_LOG_DYN){ log_printf("ICInvalidateRange %08X\n",(void*)method_hooks[i].realAddr); } ICInvalidateRange((void*)method_hooks[i].realAddr, 4); log_printf("done\n"); } @@ -219,72 +219,72 @@ u32 GetAddressOfFunction(const char * functionName,u32 library){ u32 rpl_handle = 0; if(library == LIB_CORE_INIT){ - if(DEBUG_LOG_DYN)log_printf("FindExport of %s! From LIB_CORE_INIT\n", functionName); + if(DEBUG_LOG_DYN){ log_printf("FindExport of %s! From LIB_CORE_INIT\n", functionName); } if(coreinit_handle == 0){log_print("LIB_CORE_INIT not aquired\n"); return 0;} rpl_handle = coreinit_handle; } else if(library == LIB_NSYSNET){ - if(DEBUG_LOG_DYN)log_printf("FindExport of %s! From LIB_NSYSNET\n", functionName); + if(DEBUG_LOG_DYN){ log_printf("FindExport of %s! From LIB_NSYSNET\n", functionName); } if(nsysnet_handle == 0){log_print("LIB_NSYSNET not aquired\n"); return 0;} rpl_handle = nsysnet_handle; } else if(library == LIB_GX2){ - if(DEBUG_LOG_DYN)log_printf("FindExport of %s! From LIB_GX2\n", functionName); + if(DEBUG_LOG_DYN){ log_printf("FindExport of %s! From LIB_GX2\n", functionName); } if(gx2_handle == 0){log_print("LIB_GX2 not aquired\n"); return 0;} rpl_handle = gx2_handle; } else if(library == LIB_AOC){ - if(DEBUG_LOG_DYN)log_printf("FindExport of %s! From LIB_AOC\n", functionName); + if(DEBUG_LOG_DYN){ log_printf("FindExport of %s! From LIB_AOC\n", functionName); } if(aoc_handle == 0){log_print("LIB_AOC not aquired\n"); return 0;} rpl_handle = aoc_handle; } else if(library == LIB_AX){ - if(DEBUG_LOG_DYN)log_printf("FindExport of %s! From LIB_AX\n", functionName); + if(DEBUG_LOG_DYN){ log_printf("FindExport of %s! From LIB_AX\n", functionName); } if(sound_handle == 0){log_print("LIB_AX not aquired\n"); return 0;} rpl_handle = sound_handle; } else if(library == LIB_FS){ - if(DEBUG_LOG_DYN)log_printf("FindExport of %s! From LIB_FS\n", functionName); + if(DEBUG_LOG_DYN){ log_printf("FindExport of %s! From LIB_FS\n", functionName); } if(coreinit_handle == 0){log_print("LIB_FS not aquired\n"); return 0;} rpl_handle = coreinit_handle; } else if(library == LIB_OS){ - if(DEBUG_LOG_DYN)log_printf("FindExport of %s! From LIB_OS\n", functionName); + if(DEBUG_LOG_DYN){ log_printf("FindExport of %s! From LIB_OS\n", functionName); } if(coreinit_handle == 0){log_print("LIB_OS not aquired\n"); return 0;} rpl_handle = coreinit_handle; } else if(library == LIB_PADSCORE){ - if(DEBUG_LOG_DYN)log_printf("FindExport of %s! From LIB_PADSCORE\n", functionName); + if(DEBUG_LOG_DYN){ log_printf("FindExport of %s! From LIB_PADSCORE\n", functionName); } if(padscore_handle == 0){log_print("LIB_PADSCORE not aquired\n"); return 0;} rpl_handle = padscore_handle; } else if(library == LIB_SOCKET){ - if(DEBUG_LOG_DYN)log_printf("FindExport of %s! From LIB_SOCKET\n", functionName); + if(DEBUG_LOG_DYN){ log_printf("FindExport of %s! From LIB_SOCKET\n", functionName); } if(nsysnet_handle == 0){log_print("LIB_SOCKET not aquired\n"); return 0;} rpl_handle = nsysnet_handle; } else if(library == LIB_SYS){ - if(DEBUG_LOG_DYN)log_printf("FindExport of %s! From LIB_SYS\n", functionName); + if(DEBUG_LOG_DYN){ log_printf("FindExport of %s! From LIB_SYS\n", functionName); } if(sysapp_handle == 0){log_print("LIB_SYS not aquired\n"); return 0;} rpl_handle = sysapp_handle; } else if(library == LIB_VPAD){ - if(DEBUG_LOG_DYN)log_printf("FindExport of %s! From LIB_VPAD\n", functionName); + if(DEBUG_LOG_DYN){ log_printf("FindExport of %s! From LIB_VPAD\n", functionName); } if(vpad_handle == 0){log_print("LIB_VPAD not aquired\n"); return 0;} rpl_handle = vpad_handle; } else if(library == LIB_NN_ACP){ - if(DEBUG_LOG_DYN)log_printf("FindExport of %s! From LIB_NN_ACP\n", functionName); + if(DEBUG_LOG_DYN){ log_printf("FindExport of %s! From LIB_NN_ACP\n", functionName); } if(acp_handle == 0){log_print("LIB_NN_ACP not aquired\n"); return 0;} rpl_handle = acp_handle; } else if(library == LIB_SYSHID){ - if(DEBUG_LOG_DYN)log_printf("FindExport of %s! From LIB_SYSHID\n", functionName); + if(DEBUG_LOG_DYN){ log_printf("FindExport of %s! From LIB_SYSHID\n", functionName); } if(syshid_handle == 0){log_print("LIB_SYSHID not aquired\n"); return 0;} rpl_handle = syshid_handle; } else if(library == LIB_VPADBASE){ - if(DEBUG_LOG_DYN)log_printf("FindExport of %s! From LIB_VPADBASE\n", functionName); + if(DEBUG_LOG_DYN){ log_printf("FindExport of %s! From LIB_VPADBASE\n", functionName); } if(vpadbase_handle == 0){log_print("LIB_VPADBASE not aquired\n"); return 0;} rpl_handle = vpadbase_handle; }