section = std::make_unique

( hInstance, name ); 458 | if ( !section->SectionLocated() ) 459 | { 460 | return std::make_unique( hInstance ); 461 | } 462 | return section; 463 | } 464 | }; 465 | 466 | #endif 467 | 468 | #endif 469 | 470 | #endif -------------------------------------------------------------------------------- /Source/ThirdParty/ModUtils/ModuleList.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | // Stores a list of loaded modules with their names, WITHOUT extension 8 | class ModuleList 9 | { 10 | public: 11 | struct LazyEnumerate_t {}; 12 | static constexpr LazyEnumerate_t LazyEnumerate {}; 13 | 14 | ModuleList() 15 | { 16 | Enumerate(); 17 | } 18 | 19 | explicit ModuleList( LazyEnumerate_t ) 20 | { 21 | } 22 | 23 | // Initializes module list 24 | // Needs to be called before any calls to Get or GetAll 25 | void Enumerate() 26 | { 27 | // Cannot enumerate twice without cleaing 28 | assert( m_moduleList.size() == 0 ); 29 | 30 | constexpr size_t INITIAL_SIZE = sizeof(HMODULE) * 256; 31 | HMODULE* modules = static_cast(malloc( INITIAL_SIZE )); 32 | if ( modules != nullptr ) 33 | { 34 | typedef BOOL (WINAPI * Func)(HANDLE hProcess, HMODULE *lphModule, DWORD cb, LPDWORD lpcbNeeded); 35 | 36 | HMODULE hLib = LoadLibrary( TEXT("kernel32") ); 37 | assert( hLib != nullptr ); // If this fails then everything is probably broken anyway 38 | 39 | Func pEnumProcessModules = reinterpret_cast(GetProcAddress( hLib, "K32EnumProcessModules" )); 40 | if ( pEnumProcessModules == nullptr ) 41 | { 42 | // Try psapi 43 | FreeLibrary( hLib ); 44 | hLib = LoadLibrary( TEXT("psapi") ); 45 | if ( hLib != nullptr ) 46 | { 47 | pEnumProcessModules = reinterpret_cast(GetProcAddress( hLib, "EnumProcessModules" )); 48 | } 49 | } 50 | 51 | if ( pEnumProcessModules != nullptr ) 52 | { 53 | const HANDLE currentProcess = GetCurrentProcess(); 54 | DWORD cbNeeded = 0; 55 | if ( pEnumProcessModules( currentProcess, modules, INITIAL_SIZE, &cbNeeded ) != 0 ) 56 | { 57 | if ( cbNeeded > INITIAL_SIZE ) 58 | { 59 | HMODULE* newModules = static_cast(realloc( modules, cbNeeded )); 60 | if ( newModules != nullptr ) 61 | { 62 | modules = newModules; 63 | 64 | if ( pEnumProcessModules( currentProcess, modules, cbNeeded, &cbNeeded ) != 0 ) 65 | { 66 | EnumerateInternal( modules, cbNeeded / sizeof(HMODULE) ); 67 | } 68 | } 69 | else 70 | { 71 | EnumerateInternal( modules, INITIAL_SIZE / sizeof(HMODULE) ); 72 | } 73 | } 74 | else 75 | { 76 | EnumerateInternal( modules, cbNeeded / sizeof(HMODULE) ); 77 | } 78 | } 79 | } 80 | 81 | if ( hLib != nullptr ) 82 | { 83 | FreeLibrary( hLib ); 84 | } 85 | 86 | free( modules ); 87 | } 88 | } 89 | 90 | // Recreates module list 91 | void ReEnumerate() 92 | { 93 | Clear(); 94 | Enumerate(); 95 | } 96 | 97 | // Clears module list 98 | void Clear() 99 | { 100 | m_moduleList.clear(); 101 | } 102 | 103 | // Gets handle of a loaded module with given name, NULL otherwise 104 | HMODULE Get( const wchar_t* moduleName ) const 105 | { 106 | // If vector is empty then we're trying to call it without calling Enumerate first 107 | assert( m_moduleList.size() != 0 ); 108 | 109 | auto it = std::find_if( m_moduleList.begin(), m_moduleList.end(), [&]( const auto& e ) { 110 | return _wcsicmp( moduleName, e.second.c_str() ) == 0; 111 | } ); 112 | return it != m_moduleList.end() ? it->first : nullptr; 113 | } 114 | 115 | // Gets handles to all loaded modules with given name 116 | std::vector GetAll( const wchar_t* moduleName ) const 117 | { 118 | // If vector is empty then we're trying to call it without calling Enumerate first 119 | assert( m_moduleList.size() != 0 ); 120 | 121 | std::vector results; 122 | for ( auto& e : m_moduleList ) 123 | { 124 | if ( _wcsicmp( moduleName, e.second.c_str() ) == 0 ) 125 | { 126 | results.push_back( e.first ); 127 | } 128 | } 129 | 130 | return results; 131 | } 132 | 133 | // Gets handle of a loaded module with given prefix, NULL otherwise 134 | HMODULE GetByPrefix( const wchar_t* modulePrefix ) const 135 | { 136 | // If vector is empty then we're trying to call it without calling Enumerate first 137 | assert( m_moduleList.size() != 0 ); 138 | 139 | const size_t len = wcslen( modulePrefix ); 140 | auto it = std::find_if( m_moduleList.begin(), m_moduleList.end(), [&]( const auto& e ) { 141 | return _wcsnicmp( modulePrefix, e.second.c_str(), len ) == 0; 142 | } ); 143 | return it != m_moduleList.end() ? it->first : nullptr; 144 | } 145 | 146 | // Gets handles to all loaded modules with given prefix 147 | std::vector GetAllByPrefix( const wchar_t* modulePrefix ) const 148 | { 149 | // If vector is empty then we're trying to call it without calling Enumerate first 150 | assert( m_moduleList.size() != 0 ); 151 | 152 | const size_t len = wcslen( modulePrefix ); 153 | std::vector results; 154 | for ( auto& e : m_moduleList ) 155 | { 156 | if ( _wcsnicmp( modulePrefix, e.second.c_str(), len ) == 0 ) 157 | { 158 | results.push_back( e.first ); 159 | } 160 | } 161 | 162 | return results; 163 | } 164 | 165 | private: 166 | void EnumerateInternal( HMODULE* modules, size_t numModules ) 167 | { 168 | size_t moduleNameLength = MAX_PATH; 169 | wchar_t* moduleName = static_cast( malloc( moduleNameLength * sizeof(moduleName[0]) ) ); 170 | if ( moduleName != nullptr ) 171 | { 172 | m_moduleList.reserve( numModules ); 173 | for ( size_t i = 0; i < numModules; i++ ) 174 | { 175 | // Obtain module name, with resizing if necessary 176 | DWORD size; 177 | while ( size = GetModuleFileNameW( *modules, moduleName, moduleNameLength ), size == moduleNameLength ) 178 | { 179 | wchar_t* newName = static_cast( realloc( moduleName, 2 * moduleNameLength * sizeof(moduleName[0]) ) ); 180 | if ( newName != nullptr ) 181 | { 182 | moduleName = newName; 183 | moduleNameLength *= 2; 184 | } 185 | else 186 | { 187 | size = 0; 188 | break; 189 | } 190 | } 191 | 192 | if ( size != 0 ) 193 | { 194 | const wchar_t* nameBegin = wcsrchr( moduleName, '\\' ) + 1; 195 | const wchar_t* dotPos = wcsrchr( nameBegin, '.' ); 196 | if ( dotPos != nullptr ) 197 | { 198 | m_moduleList.emplace_back( std::piecewise_construct, std::forward_as_tuple(*modules), std::forward_as_tuple(nameBegin, dotPos) ); 199 | } 200 | else 201 | { 202 | m_moduleList.emplace_back( *modules, nameBegin ); 203 | } 204 | } 205 | modules++; 206 | } 207 | 208 | free( moduleName ); 209 | } 210 | } 211 | 212 | std::vector< std::pair > m_moduleList; 213 | }; -------------------------------------------------------------------------------- /Source/ThirdParty/ModUtils/Patterns.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of the CitizenFX project - http://citizen.re/ 3 | * 4 | * See LICENSE and MENTIONS in the root of the source tree for information 5 | * regarding licensing. 6 | */ 7 | 8 | #include "Patterns.h" 9 | 10 | #define WIN32_LEAN_AND_MEAN 11 | #define NOMINMAX 12 | #include 13 | #include 14 | 15 | #if PATTERNS_USE_HINTS 16 | #include 17 | #endif 18 | 19 | 20 | #if PATTERNS_USE_HINTS 21 | 22 | // from boost someplace 23 | template 24 | struct basic_fnv_1 25 | { 26 | std::uint64_t operator()(std::string_view text) const 27 | { 28 | std::uint64_t hash = OffsetBasis; 29 | for (auto it : text) 30 | { 31 | hash *= FnvPrime; 32 | hash ^= it; 33 | } 34 | 35 | return hash; 36 | } 37 | }; 38 | 39 | static constexpr std::uint64_t fnv_prime = 1099511628211u; 40 | static constexpr std::uint64_t fnv_offset_basis = 14695981039346656037u; 41 | 42 | typedef basic_fnv_1 fnv_1; 43 | 44 | #endif 45 | 46 | namespace hook 47 | { 48 | 49 | ptrdiff_t details::get_process_base() 50 | { 51 | return ptrdiff_t(GetModuleHandle(nullptr)); 52 | } 53 | 54 | 55 | #if PATTERNS_USE_HINTS 56 | static auto& getHints() 57 | { 58 | static std::multimap hints; 59 | return hints; 60 | } 61 | #endif 62 | 63 | static void TransformPattern(std::string_view pattern, std::basic_string& data, std::basic_string& mask) 64 | { 65 | uint8_t tempDigit = 0; 66 | bool tempFlag = false; 67 | 68 | auto tol = [] (char ch) -> uint8_t 69 | { 70 | if (ch >= 'A' && ch <= 'F') return uint8_t(ch - 'A' + 10); 71 | if (ch >= 'a' && ch <= 'f') return uint8_t(ch - 'a' + 10); 72 | return uint8_t(ch - '0'); 73 | }; 74 | 75 | for (auto ch : pattern) 76 | { 77 | if (ch == ' ') 78 | { 79 | continue; 80 | } 81 | else if (ch == '?') 82 | { 83 | data.push_back(0); 84 | mask.push_back(0); 85 | } 86 | else if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f')) 87 | { 88 | uint8_t thisDigit = tol(ch); 89 | 90 | if (!tempFlag) 91 | { 92 | tempDigit = thisDigit << 4; 93 | tempFlag = true; 94 | } 95 | else 96 | { 97 | tempDigit |= thisDigit; 98 | tempFlag = false; 99 | 100 | data.push_back(tempDigit); 101 | mask.push_back(0xFF); 102 | } 103 | } 104 | } 105 | } 106 | 107 | class executable_meta 108 | { 109 | private: 110 | uintptr_t m_begin; 111 | uintptr_t m_end; 112 | 113 | template 114 | TReturn* getRVA(TOffset rva) 115 | { 116 | return (TReturn*)(m_begin + rva); 117 | } 118 | 119 | public: 120 | explicit executable_meta(uintptr_t module) 121 | : m_begin(module) 122 | { 123 | PIMAGE_DOS_HEADER dosHeader = getRVA(0); 124 | PIMAGE_NT_HEADERS ntHeader = getRVA(dosHeader->e_lfanew); 125 | 126 | m_end = m_begin + ntHeader->OptionalHeader.SizeOfImage; 127 | } 128 | 129 | executable_meta(uintptr_t begin, uintptr_t end) 130 | : m_begin(begin), m_end(end) 131 | { 132 | } 133 | 134 | inline uintptr_t begin() const { return m_begin; } 135 | inline uintptr_t end() const { return m_end; } 136 | }; 137 | 138 | namespace details 139 | { 140 | 141 | void basic_pattern_impl::Initialize(std::string_view pattern) 142 | { 143 | // get the hash for the base pattern 144 | #if PATTERNS_USE_HINTS 145 | m_hash = fnv_1()(pattern); 146 | #endif 147 | 148 | // transform the base pattern from IDA format to canonical format 149 | TransformPattern(pattern, m_bytes, m_mask); 150 | 151 | #if PATTERNS_USE_HINTS 152 | // if there's hints, try those first 153 | #if PATTERNS_CAN_SERIALIZE_HINTS 154 | if (m_rangeStart == reinterpret_cast(GetModuleHandle(nullptr))) 155 | #endif 156 | { 157 | auto range = getHints().equal_range(m_hash); 158 | 159 | if (range.first != range.second) 160 | { 161 | std::for_each(range.first, range.second, [&] (const auto& hint) 162 | { 163 | ConsiderHint(hint.second); 164 | }); 165 | 166 | // if the hints succeeded, we don't need to do anything more 167 | if (!m_matches.empty()) 168 | { 169 | m_matched = true; 170 | return; 171 | } 172 | } 173 | } 174 | #endif 175 | } 176 | 177 | void basic_pattern_impl::EnsureMatches(uint32_t maxCount) 178 | { 179 | if (m_matched) 180 | { 181 | return; 182 | } 183 | 184 | // scan the executable for code 185 | executable_meta executable = m_rangeStart != 0 && m_rangeEnd != 0 ? executable_meta(m_rangeStart, m_rangeEnd) : executable_meta(m_rangeStart); 186 | 187 | auto matchSuccess = [&] (uintptr_t address) 188 | { 189 | #if PATTERNS_USE_HINTS 190 | getHints().emplace(m_hash, address); 191 | #else 192 | (void)address; 193 | #endif 194 | 195 | return (m_matches.size() == maxCount); 196 | }; 197 | 198 | const uint8_t* pattern = m_bytes.data(); 199 | const uint8_t* mask = m_mask.data(); 200 | const size_t maskSize = m_mask.size(); 201 | const size_t lastWild = m_mask.find_last_not_of(uint8_t(0xFF)); 202 | 203 | ptrdiff_t Last[256]; 204 | 205 | std::fill(std::begin(Last), std::end(Last), lastWild == std::string::npos ? -1 : static_cast(lastWild) ); 206 | 207 | for ( ptrdiff_t i = 0; i < static_cast(maskSize); ++i ) 208 | { 209 | if ( Last[ pattern[i] ] < i ) 210 | { 211 | Last[ pattern[i] ] = i; 212 | } 213 | } 214 | 215 | for (uintptr_t i = executable.begin(), end = executable.end() - maskSize; i <= end;) 216 | { 217 | uint8_t* ptr = reinterpret_cast(i); 218 | ptrdiff_t j = maskSize - 1; 219 | 220 | while((j >= 0) && pattern[j] == (ptr[j] & mask[j])) j--; 221 | 222 | if(j < 0) 223 | { 224 | m_matches.emplace_back(ptr); 225 | 226 | if (matchSuccess(i)) 227 | { 228 | break; 229 | } 230 | i++; 231 | } 232 | else i += std::max(ptrdiff_t(1), j - Last[ ptr[j] ]); 233 | } 234 | 235 | m_matched = true; 236 | } 237 | 238 | bool basic_pattern_impl::ConsiderHint(uintptr_t offset) 239 | { 240 | uint8_t* ptr = reinterpret_cast(offset); 241 | 242 | #if PATTERNS_CAN_SERIALIZE_HINTS 243 | const uint8_t* pattern = m_bytes.data(); 244 | const uint8_t* mask = m_mask.data(); 245 | 246 | for (size_t i = 0, j = m_mask.size(); i < j; i++) 247 | { 248 | if (pattern[i] != (ptr[i] & mask[i])) 249 | { 250 | return false; 251 | } 252 | } 253 | #endif 254 | 255 | m_matches.emplace_back(ptr); 256 | 257 | return true; 258 | } 259 | 260 | #if PATTERNS_USE_HINTS && PATTERNS_CAN_SERIALIZE_HINTS 261 | void basic_pattern_impl::hint(uint64_t hash, uintptr_t address) 262 | { 263 | auto& hints = getHints(); 264 | 265 | auto range = hints.equal_range(hash); 266 | 267 | for (auto it = range.first; it != range.second; ++it) 268 | { 269 | if (it->second == address) 270 | { 271 | return; 272 | } 273 | } 274 | 275 | hints.emplace(hash, address); 276 | } 277 | #endif 278 | 279 | } 280 | } -------------------------------------------------------------------------------- /Source/ThirdParty/ModUtils/Patterns.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of the CitizenFX project - http://citizen.re/ 3 | * 4 | * See LICENSE and MENTIONS in the root of the source tree for information 5 | * regarding licensing. 6 | */ 7 | 8 | #pragma once 9 | 10 | #include 11 | #include 12 | #include 13 | 14 | #if defined(_CPPUNWIND) && !defined(PATTERNS_SUPPRESS_EXCEPTIONS) 15 | #define PATTERNS_ENABLE_EXCEPTIONS 16 | #endif 17 | 18 | namespace hook 19 | { 20 | struct assert_err_policy 21 | { 22 | static void count([[maybe_unused]] bool countMatches) { assert(countMatches); } 23 | }; 24 | 25 | #ifdef PATTERNS_ENABLE_EXCEPTIONS 26 | class txn_exception 27 | { 28 | // Deliberately empty for now 29 | }; 30 | 31 | #define TXN_CATCH() catch (const hook::txn_exception&) {} 32 | 33 | struct exception_err_policy 34 | { 35 | static void count(bool countMatches) { if (!countMatches) { throw txn_exception{}; } } 36 | }; 37 | #else 38 | struct exception_err_policy 39 | { 40 | }; 41 | #endif 42 | 43 | class pattern_match 44 | { 45 | private: 46 | void* m_pointer; 47 | 48 | public: 49 | inline pattern_match(void* pointer) 50 | : m_pointer(pointer) 51 | { 52 | } 53 | 54 | template 55 | T* get(ptrdiff_t offset = 0) const 56 | { 57 | char* ptr = reinterpret_cast(m_pointer); 58 | return reinterpret_cast(ptr + offset); 59 | } 60 | }; 61 | 62 | namespace details 63 | { 64 | ptrdiff_t get_process_base(); 65 | 66 | class basic_pattern_impl 67 | { 68 | protected: 69 | std::basic_string m_bytes; 70 | std::basic_string m_mask; 71 | 72 | #if PATTERNS_USE_HINTS 73 | uint64_t m_hash = 0; 74 | #endif 75 | 76 | std::vector m_matches; 77 | 78 | bool m_matched = false; 79 | 80 | uintptr_t m_rangeStart; 81 | uintptr_t m_rangeEnd; 82 | 83 | protected: 84 | void Initialize(std::string_view pattern); 85 | 86 | bool ConsiderHint(uintptr_t offset); 87 | 88 | void EnsureMatches(uint32_t maxCount); 89 | 90 | inline pattern_match _get_internal(size_t index) const 91 | { 92 | return m_matches[index]; 93 | } 94 | 95 | private: 96 | explicit basic_pattern_impl(uintptr_t begin, uintptr_t end = 0) 97 | : m_rangeStart(begin), m_rangeEnd(end) 98 | { 99 | } 100 | 101 | public: 102 | explicit basic_pattern_impl(std::string_view pattern) 103 | : basic_pattern_impl(get_process_base()) 104 | { 105 | Initialize(std::move(pattern)); 106 | } 107 | 108 | inline basic_pattern_impl(void* module, std::string_view pattern) 109 | : basic_pattern_impl(reinterpret_cast(module)) 110 | { 111 | Initialize(std::move(pattern)); 112 | } 113 | 114 | inline basic_pattern_impl(uintptr_t begin, uintptr_t end, std::string_view pattern) 115 | : basic_pattern_impl(begin, end) 116 | { 117 | Initialize(std::move(pattern)); 118 | } 119 | 120 | // Pretransformed patterns 121 | inline basic_pattern_impl(std::basic_string_view bytes, std::basic_string_view mask) 122 | : basic_pattern_impl(get_process_base()) 123 | { 124 | assert( bytes.length() == mask.length() ); 125 | m_bytes = std::move(bytes); 126 | m_mask = std::move(mask); 127 | } 128 | 129 | protected: 130 | #if PATTERNS_USE_HINTS && PATTERNS_CAN_SERIALIZE_HINTS 131 | // define a hint 132 | static void hint(uint64_t hash, uintptr_t address); 133 | #endif 134 | }; 135 | } 136 | 137 | template 138 | class basic_pattern : details::basic_pattern_impl 139 | { 140 | public: 141 | using details::basic_pattern_impl::basic_pattern_impl; 142 | 143 | inline basic_pattern&& count(uint32_t expected) 144 | { 145 | EnsureMatches(expected); 146 | err_policy::count(m_matches.size() == expected); 147 | return std::forward(*this); 148 | } 149 | 150 | inline basic_pattern&& count_hint(uint32_t expected) 151 | { 152 | EnsureMatches(expected); 153 | return std::forward(*this); 154 | } 155 | 156 | inline basic_pattern&& clear() 157 | { 158 | m_matches.clear(); 159 | m_matched = false; 160 | return std::forward(*this); 161 | } 162 | 163 | inline size_t size() 164 | { 165 | EnsureMatches(UINT32_MAX); 166 | return m_matches.size(); 167 | } 168 | 169 | inline bool empty() 170 | { 171 | return size() == 0; 172 | } 173 | 174 | inline pattern_match get(size_t index) 175 | { 176 | EnsureMatches(UINT32_MAX); 177 | return _get_internal(index); 178 | } 179 | 180 | inline pattern_match get_one() 181 | { 182 | return std::forward(*this).count(1)._get_internal(0); 183 | } 184 | 185 | template 186 | inline auto get_first(ptrdiff_t offset = 0) 187 | { 188 | return get_one().get(offset); 189 | } 190 | 191 | template 192 | inline Pred for_each_result(Pred&& pred) 193 | { 194 | EnsureMatches(UINT32_MAX); 195 | for ( auto it : m_matches ) 196 | { 197 | std::forward(pred)(it); 198 | } 199 | return std::forward(pred); 200 | } 201 | 202 | public: 203 | #if PATTERNS_USE_HINTS && PATTERNS_CAN_SERIALIZE_HINTS 204 | // define a hint 205 | static void hint(uint64_t hash, uintptr_t address) 206 | { 207 | details::basic_pattern_impl::hint(hash, address); 208 | } 209 | #endif 210 | }; 211 | 212 | using pattern = basic_pattern; 213 | 214 | inline auto make_module_pattern(void* module, std::string_view bytes) 215 | { 216 | return pattern(module, std::move(bytes)); 217 | } 218 | 219 | inline auto make_range_pattern(uintptr_t begin, uintptr_t end, std::string_view bytes) 220 | { 221 | return pattern(begin, end, std::move(bytes)); 222 | } 223 | 224 | template 225 | inline auto get_pattern(std::string_view pattern_string, ptrdiff_t offset = 0) 226 | { 227 | return pattern(std::move(pattern_string)).get_first(offset); 228 | } 229 | 230 | namespace txn 231 | { 232 | using pattern = hook::basic_pattern; 233 | 234 | inline auto make_module_pattern(void* module, std::string_view bytes) 235 | { 236 | return pattern(module, std::move(bytes)); 237 | } 238 | 239 | inline auto make_range_pattern(uintptr_t begin, uintptr_t end, std::string_view bytes) 240 | { 241 | return pattern(begin, end, std::move(bytes)); 242 | } 243 | 244 | template 245 | inline auto get_pattern(std::string_view pattern_string, ptrdiff_t offset = 0) 246 | { 247 | return pattern(std::move(pattern_string)).get_first(offset); 248 | } 249 | } 250 | } -------------------------------------------------------------------------------- /Source/ThirdParty/ModUtils/README.md: -------------------------------------------------------------------------------- 1 | # ModUtils 2 | Modding utils used in most of my projects. Mostly for internal use, but feel free to make use of those! 3 | -------------------------------------------------------------------------------- /Source/ThirdParty/ModUtils/Trampoline.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // Trampolines are useless on x86 arch 4 | #ifdef _WIN64 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | // Trampoline class for big (>2GB) jumps 12 | // Never needed in 32-bit processes so in those cases this does nothing but forwards to Memory functions 13 | // NOTE: Each Trampoline class allocates a page of executable memory for trampolines and does NOT free it when going out of scope 14 | class Trampoline 15 | { 16 | public: 17 | template 18 | static Trampoline* MakeTrampoline( T addr ) 19 | { 20 | return MakeTrampoline( uintptr_t(addr) ); 21 | } 22 | 23 | template 24 | LPVOID Jump( Func func ) 25 | { 26 | LPVOID addr; 27 | memcpy( &addr, std::addressof(func), sizeof(addr) ); 28 | return CreateCodeTrampoline( addr ); 29 | } 30 | 31 | template 32 | auto* Pointer( size_t align = alignof(T) ) 33 | { 34 | return static_cast< std::remove_const_t* >(GetNewSpace( sizeof(T), align )); 35 | } 36 | 37 | template 38 | auto& Reference( size_t align = alignof(T) ) 39 | { 40 | return *Pointer( align ); 41 | } 42 | 43 | std::byte* RawSpace( size_t size, size_t align = 1 ) 44 | { 45 | return static_cast< std::byte* >(GetNewSpace( size, align )); 46 | } 47 | 48 | 49 | private: 50 | static Trampoline* MakeTrampoline( uintptr_t addr ) 51 | { 52 | Trampoline* current = ms_first; 53 | while ( current != nullptr ) 54 | { 55 | if ( current->FeasibleForAddresss( addr ) ) return current; 56 | 57 | current = current->m_next; 58 | } 59 | 60 | SYSTEM_INFO systemInfo; 61 | GetSystemInfo( &systemInfo ); 62 | 63 | void* space = FindAndAllocateMem(addr, systemInfo.dwAllocationGranularity); 64 | void* usableSpace = reinterpret_cast(space) + sizeof(Trampoline); 65 | return new( space ) Trampoline( usableSpace, systemInfo.dwAllocationGranularity - sizeof(Trampoline) ); 66 | } 67 | 68 | 69 | Trampoline( const Trampoline& ) = delete; 70 | Trampoline& operator=( const Trampoline& ) = delete; 71 | 72 | explicit Trampoline( void* memory, size_t size ) 73 | : m_next( std::exchange( ms_first, this ) ), m_pageMemory( memory ), m_spaceLeft( size ) 74 | { 75 | } 76 | 77 | static constexpr size_t SINGLE_TRAMPOLINE_SIZE = 12; 78 | bool FeasibleForAddresss( uintptr_t addr ) const 79 | { 80 | return IsAddressFeasible( (uintptr_t)m_pageMemory, addr ) && m_spaceLeft >= SINGLE_TRAMPOLINE_SIZE; 81 | } 82 | 83 | LPVOID CreateCodeTrampoline( LPVOID addr ) 84 | { 85 | uint8_t* trampolineSpace = static_cast(GetNewSpace( SINGLE_TRAMPOLINE_SIZE, 1 )); 86 | 87 | // Create trampoline code 88 | const uint8_t prologue[] = { 0x48, 0xB8 }; 89 | const uint8_t epilogue[] = { 0xFF, 0xE0 }; 90 | 91 | memcpy( trampolineSpace, prologue, sizeof(prologue) ); 92 | memcpy( trampolineSpace + 2, &addr, sizeof(addr) ); 93 | memcpy( trampolineSpace + 10, epilogue, sizeof(epilogue) ); 94 | 95 | return trampolineSpace; 96 | } 97 | 98 | LPVOID GetNewSpace( size_t size, size_t alignment ) 99 | { 100 | void* space = std::align( alignment, size, m_pageMemory, m_spaceLeft ); 101 | if ( space != nullptr ) 102 | { 103 | m_pageMemory = static_cast(m_pageMemory) + size; 104 | m_spaceLeft -= size; 105 | } 106 | else 107 | { 108 | assert( !"Out of trampoline space!" ); 109 | } 110 | return space; 111 | } 112 | 113 | static LPVOID FindAndAllocateMem( const uintptr_t addr, DWORD size ) 114 | { 115 | uintptr_t curAddr = addr; 116 | // Find the first unallocated page after 'addr' and try to allocate a page for trampolines there 117 | while ( true ) 118 | { 119 | MEMORY_BASIC_INFORMATION MemoryInf; 120 | if ( VirtualQuery( (LPCVOID)curAddr, &MemoryInf, sizeof(MemoryInf) ) == 0 ) break; 121 | if ( MemoryInf.State == MEM_FREE && MemoryInf.RegionSize >= size ) 122 | { 123 | // Align up to allocation granularity 124 | uintptr_t alignedAddr = uintptr_t(MemoryInf.BaseAddress); 125 | alignedAddr = (alignedAddr + size - 1) & ~uintptr_t(size - 1); 126 | 127 | if ( !IsAddressFeasible( alignedAddr, addr ) ) break; 128 | 129 | LPVOID mem = VirtualAlloc( (LPVOID)alignedAddr, size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE ); 130 | if ( mem != nullptr ) 131 | { 132 | return mem; 133 | } 134 | } 135 | curAddr += MemoryInf.RegionSize; 136 | } 137 | return nullptr; 138 | } 139 | 140 | static bool IsAddressFeasible( uintptr_t trampolineOffset, uintptr_t addr ) 141 | { 142 | const ptrdiff_t diff = trampolineOffset - addr; 143 | return diff >= INT32_MIN && diff <= INT32_MAX; 144 | } 145 | 146 | Trampoline* m_next = nullptr; 147 | void* m_pageMemory = nullptr; 148 | size_t m_spaceLeft = 0; 149 | 150 | static inline Trampoline* ms_first = nullptr; 151 | }; 152 | 153 | 154 | #endif -------------------------------------------------------------------------------- /Source/ThirdParty/inireader/IniReader.h: -------------------------------------------------------------------------------- 1 | #ifndef INIREADER_H 2 | #define INIREADER_H 3 | #include "ini_parser.hpp" 4 | #include 5 | #include 6 | #include 7 | 8 | /* 9 | * String comparision functions, with case sensitive option 10 | */ 11 | 12 | using std::strcmp; 13 | 14 | inline int strcmp(const char* str1, const char* str2, bool csensitive) 15 | { 16 | return (csensitive ? ::strcmp(str1, str2) : ::_stricmp(str1, str2)); 17 | } 18 | 19 | inline int strcmp(const char* str1, const char* str2, size_t num, bool csensitive) 20 | { 21 | return (csensitive ? ::strncmp(str1, str2, num) : ::_strnicmp(str1, str2, num)); 22 | } 23 | 24 | inline int compare(const std::string& str1, const std::string& str2, bool case_sensitive) 25 | { 26 | if (str1.length() == str2.length()) 27 | return strcmp(str1.c_str(), str2.c_str(), case_sensitive); 28 | return (str1.length() < str2.length() ? -1 : 1); 29 | } 30 | 31 | inline int compare(const std::string& str1, const std::string& str2, size_t num, bool case_sensitive) 32 | { 33 | if (str1.length() == str2.length()) 34 | return strcmp(str1.c_str(), str2.c_str(), num, case_sensitive); 35 | return (str1.length() < str2.length() ? -1 : 1); 36 | } 37 | 38 | inline int compare(const char* str1, const char* str2, bool case_sensitive) 39 | { 40 | return strcmp(str1, str2, case_sensitive); 41 | } 42 | 43 | inline int compare(const char* str1, const char* str2, size_t num, bool case_sensitive) 44 | { 45 | return strcmp(str1, str2, num, case_sensitive); 46 | } 47 | 48 | inline bool starts_with(const char* str, const char* prefix, bool case_sensitive) 49 | { 50 | while (*prefix) 51 | { 52 | bool equal; 53 | if (case_sensitive) 54 | equal = (*str++ == *prefix++); 55 | else 56 | equal = (::tolower(*str++) == ::tolower(*prefix++)); 57 | 58 | if (!equal) return false; 59 | } 60 | return true; 61 | } 62 | 63 | inline bool ends_with(const char* str, const char* prefix, bool case_sensitive) 64 | { 65 | auto str2 = &str[strlen(str) - 1]; 66 | auto prefix2 = &prefix[strlen(prefix) - 1]; 67 | 68 | while (prefix2 >= prefix) 69 | { 70 | bool equal; 71 | if (case_sensitive) 72 | equal = (*str2-- == *prefix2--); 73 | else 74 | equal = (::tolower(*str2--) == ::tolower(*prefix2--)); 75 | 76 | if (!equal) return false; 77 | } 78 | return true; 79 | } 80 | 81 | class CIniReader 82 | { 83 | private: 84 | std::string m_szFileName; 85 | 86 | public: 87 | linb::ini data; 88 | 89 | CIniReader() 90 | { 91 | SetIniPath(""); 92 | } 93 | 94 | CIniReader(std::string_view szFileName) 95 | { 96 | SetIniPath(szFileName); 97 | } 98 | 99 | CIniReader(std::stringstream& ini_mem) 100 | { 101 | data.load_file(ini_mem); 102 | } 103 | 104 | bool operator==(CIniReader& ir) 105 | { 106 | if (data.size() != ir.data.size()) 107 | return false; 108 | 109 | for (auto& section : data) 110 | { 111 | for (auto& key : data.at(section.first)) 112 | { 113 | if (key.second != ir.data.at(section.first)[key.first]) 114 | return false; 115 | } 116 | } 117 | return true; 118 | } 119 | 120 | bool operator!=(CIniReader& ir) 121 | { 122 | return !(*this == ir); 123 | } 124 | 125 | bool CompareBySections(CIniReader& ir) 126 | { 127 | if (data.size() != ir.data.size()) 128 | return false; 129 | 130 | for (auto& section : data) 131 | { 132 | if (ir.data.find(section.first) == ir.data.end()) 133 | return false; 134 | 135 | if (section.second.size() != ir.data.find(section.first)->second.size()) 136 | return false; 137 | 138 | if (section.first != ir.data.find(section.first)->first) 139 | return false; 140 | } 141 | return true; 142 | } 143 | 144 | bool CompareByValues(CIniReader& ir) 145 | { 146 | return *this == ir; 147 | } 148 | 149 | const std::string& GetIniPath() 150 | { 151 | return m_szFileName; 152 | } 153 | 154 | void SetIniPath() 155 | { 156 | SetIniPath(""); 157 | } 158 | 159 | void SetIniPath(std::string_view szFileName) 160 | { 161 | char buffer[MAX_PATH]; 162 | HMODULE hm = NULL; 163 | GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, (LPCSTR)&ends_with, &hm); 164 | GetModuleFileNameA(hm, buffer, sizeof(buffer)); 165 | std::string modulePath = buffer; 166 | 167 | if (szFileName.find(':') != std::string_view::npos) 168 | { 169 | m_szFileName = szFileName; 170 | } 171 | else if (szFileName.length() == 0) 172 | { 173 | m_szFileName = modulePath.substr(0, modulePath.find_last_of('.')) + ".ini"; 174 | } 175 | else 176 | { 177 | m_szFileName = modulePath.substr(0, modulePath.rfind('\\') + 1) + szFileName.data(); 178 | } 179 | 180 | data.load_file(m_szFileName); 181 | } 182 | 183 | int ReadInteger(std::string_view szSection, std::string_view szKey, int iDefaultValue) 184 | { 185 | auto str = data.get(szSection.data(), szKey.data(), std::to_string(iDefaultValue)); 186 | return std::stoi(str, nullptr, starts_with(str.c_str(), "0x", false) ? 16 : 10); 187 | } 188 | 189 | float ReadFloat(std::string_view szSection, std::string_view szKey, float fltDefaultValue) 190 | { 191 | return (float)atof(data.get(szSection.data(), szKey.data(), std::to_string(fltDefaultValue)).c_str()); 192 | } 193 | 194 | bool ReadBoolean(std::string_view szSection, std::string_view szKey, bool bolDefaultValue) 195 | { 196 | auto val = data.get(szSection.data(), szKey.data(), ""); 197 | if (!val.empty()) 198 | { 199 | if (val.size() == 1) 200 | return val.front() != '0'; 201 | else 202 | return compare(val, "false", false); 203 | } 204 | return bolDefaultValue; 205 | } 206 | 207 | std::string ReadString(std::string_view szSection, std::string_view szKey, std::string_view szDefaultValue) 208 | { 209 | auto s = data.get(szSection.data(), szKey.data(), szDefaultValue.data()); 210 | 211 | if (!s.empty()) 212 | { 213 | if (s.at(0) == '\"' || s.at(0) == '\'') 214 | s.erase(0, 1); 215 | 216 | if (s.at(s.size() - 1) == '\"' || s.at(s.size() - 1) == '\'') 217 | s.erase(s.size() - 1); 218 | } 219 | 220 | return s; 221 | } 222 | 223 | void WriteInteger(std::string_view szSection, std::string_view szKey, int iValue, bool useparser = false) 224 | { 225 | if (useparser) 226 | { 227 | data.set(szSection.data(), szKey.data(), std::to_string(iValue)); 228 | data.write_file(m_szFileName); 229 | } 230 | else 231 | { 232 | char szValue[255]; 233 | _snprintf_s(szValue, 255, "%s%d", " ", iValue); 234 | WritePrivateProfileStringA(szSection.data(), szKey.data(), szValue, m_szFileName.c_str()); 235 | } 236 | } 237 | 238 | void WriteFloat(std::string_view szSection, std::string_view szKey, float fltValue, bool useparser = false) 239 | { 240 | if (useparser) 241 | { 242 | data.set(szSection.data(), szKey.data(), std::to_string(fltValue)); 243 | data.write_file(m_szFileName); 244 | } 245 | else 246 | { 247 | char szValue[255]; 248 | _snprintf_s(szValue, 255, "%s%f", " ", fltValue); 249 | WritePrivateProfileStringA(szSection.data(), szKey.data(), szValue, m_szFileName.c_str()); 250 | } 251 | } 252 | 253 | void WriteBoolean(std::string_view szSection, std::string_view szKey, bool bolValue, bool useparser = false) 254 | { 255 | if (useparser) 256 | { 257 | data.set(szSection.data(), szKey.data(), std::to_string(bolValue)); 258 | data.write_file(m_szFileName); 259 | } 260 | else 261 | { 262 | char szValue[255]; 263 | _snprintf_s(szValue, 255, "%s%s", " ", bolValue ? "True" : "False"); 264 | WritePrivateProfileStringA(szSection.data(), szKey.data(), szValue, m_szFileName.c_str()); 265 | } 266 | } 267 | 268 | void WriteString(std::string_view szSection, std::string_view szKey, std::string_view szValue, bool useparser = false) 269 | { 270 | if (useparser) 271 | { 272 | data.set(szSection.data(), szKey.data(), szValue.data()); 273 | data.write_file(m_szFileName); 274 | } 275 | else 276 | { 277 | WritePrivateProfileStringA(szSection.data(), szKey.data(), szValue.data(), m_szFileName.c_str()); 278 | } 279 | } 280 | }; 281 | 282 | #endif //INIREADER_H 283 | -------------------------------------------------------------------------------- /Source/ThirdParty/inireader/ini_parser.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2013-2015 Denilson das Mercês Amorim 3 | * Copyright (c) 2017 ThirteenAG 4 | * 5 | * This software is provided 'as-is', without any express or implied 6 | * warranty. In no event will the authors be held liable for any damages 7 | * arising from the use of this software. 8 | * 9 | * Permission is granted to anyone to use this software for any purpose, 10 | * including commercial applications, and to alter it and redistribute it 11 | * freely, subject to the following restrictions: 12 | * 13 | * 1. The origin of this software must not be misrepresented; you must not 14 | * claim that you wrote the original software. If you use this software 15 | * in a product, an acknowledgment in the product documentation would be 16 | * appreciated but is not required. 17 | * 18 | * 2. Altered source versions must be plainly marked as such, and must not be 19 | * misrepresented as being the original software. 20 | * 21 | * 3. This notice may not be removed or altered from any source 22 | * distribution. 23 | * 24 | */ 25 | #ifndef LINB_INI_PARSER_HPP 26 | #define LINB_INI_PARSER_HPP 27 | 28 | /* 29 | * STL-like INI Container 30 | */ 31 | 32 | #include // for std::string 33 | #include // for std::map 34 | #include // for std::FILE 35 | #include // for std::find_if 36 | #include // for std::function 37 | #include // for std::vector 38 | #include 39 | #include 40 | 41 | namespace linb 42 | { 43 | template< 44 | class CharT = char, /* Not compatible with other type here, since we're using C streams */ 45 | class StringType = std::basic_string, 46 | class KeyContainer = std::map, 47 | class SectionContainer = std::map 48 | > class basic_ini 49 | { 50 | public: 51 | typedef CharT char_type; 52 | typedef StringType string_type; 53 | typedef KeyContainer key_container; 54 | typedef SectionContainer section_container; 55 | 56 | // Typedef container values types 57 | typedef typename section_container::value_type value_type; 58 | typedef typename section_container::key_type key_type; 59 | typedef typename section_container::mapped_type mapped_type; 60 | 61 | // Typedef common types 62 | typedef typename section_container::size_type size_type; 63 | typedef typename section_container::difference_type difference_type; 64 | 65 | // Typedef iterators 66 | typedef typename section_container::iterator iterator; 67 | typedef typename section_container::const_iterator const_iterator; 68 | typedef typename section_container::reverse_iterator reverse_iterator; 69 | typedef typename section_container::const_reverse_iterator const_reverse_iterator; 70 | 71 | // typedef References and pointers 72 | typedef typename section_container::reference reference; 73 | typedef typename section_container::const_reference const_reference; 74 | typedef typename section_container::pointer pointer; 75 | typedef typename section_container::const_pointer const_pointer; 76 | 77 | private: 78 | section_container data; 79 | 80 | public: 81 | 82 | basic_ini() 83 | { } 84 | 85 | basic_ini(const char_type* filename) 86 | { 87 | this->read_file(filename); 88 | } 89 | 90 | /* Iterator methods */ 91 | iterator begin() 92 | { 93 | return data.begin(); 94 | } 95 | const_iterator begin() const 96 | { 97 | return data.begin(); 98 | } 99 | iterator end() 100 | { 101 | return data.end(); 102 | } 103 | const_iterator end() const 104 | { 105 | return data.end(); 106 | } 107 | const_iterator cbegin() const 108 | { 109 | return data.cbegin(); 110 | } 111 | const_iterator cend() const 112 | { 113 | return data.cend(); 114 | } 115 | 116 | /* Reverse iterator methods */ 117 | reverse_iterator rbegin() 118 | { 119 | return data.rbegin(); 120 | } 121 | const_reverse_iterator rbegin() const 122 | { 123 | return data.rbegin(); 124 | } 125 | reverse_iterator rend() 126 | { 127 | return data.rend(); 128 | } 129 | const_reverse_iterator rend() const 130 | { 131 | return data.rend(); 132 | } 133 | const_reverse_iterator crbegin() const 134 | { 135 | return data.crbegin(); 136 | } 137 | const_reverse_iterator crend() const 138 | { 139 | return data.crend(); 140 | } 141 | 142 | /* Acessing index methods */ 143 | mapped_type& operator[](const string_type& sect) 144 | { 145 | return data[sect]; 146 | } 147 | mapped_type& operator[](string_type&& sect) 148 | { 149 | return data[std::forward(sect)]; 150 | } 151 | mapped_type& at(const string_type& sect) 152 | { 153 | return data.at(sect); 154 | } 155 | const mapped_type& at(const string_type& sect) const 156 | { 157 | return data.at(sect); 158 | } 159 | 160 | /* Capacity information */ 161 | bool empty() const 162 | { 163 | return data.empty(); 164 | } 165 | size_type size() const 166 | { 167 | return data.size(); 168 | } 169 | size_type max_size() const 170 | { 171 | return data.max_size(); 172 | } 173 | 174 | /* Modifiers */ 175 | void clear() 176 | { 177 | return data.clear(); 178 | } 179 | 180 | /* Lookup */ 181 | size_type count(const string_type& sect) 182 | { 183 | return data.count(sect); 184 | } 185 | iterator find(const string_type& sect, bool case_sensitive = false) 186 | { 187 | if (!case_sensitive) 188 | return std::find_if(data.begin(), data.end(), 189 | [§](auto& s) { return std::equal(s.first.begin(), s.first.end(), sect.begin(), sect.end(), 190 | [](char a, char b) {return tolower(a) == tolower(b); }); 191 | }); 192 | else 193 | return data.find(sect); 194 | } 195 | 196 | /* Gets a value from the specified section & key, default_value is returned if the sect & key doesn't exist */ 197 | string_type get(const string_type& sect, const key_type& key, const string_type& default_value) 198 | { 199 | auto it = this->find(sect); 200 | if (it != this->end()) 201 | { 202 | auto itv = it->second.find(key); 203 | if (itv != it->second.end()) 204 | return itv->second; 205 | } 206 | return default_value; 207 | } 208 | 209 | /* Sets the value of a value in the ini */ 210 | void set(const string_type& sect, const key_type& key, const string_type& value) 211 | { 212 | (*this)[sect][key] = value; // no emplace since overwrite! 213 | } 214 | 215 | /* Too lazy to continue this container... If you need more methods, just add it */ 216 | 217 | 218 | bool read_file(std::stringstream& ini_mem) 219 | { 220 | if (ini_mem.rdbuf()->in_avail()) 221 | { 222 | key_container* keys = nullptr; 223 | string_type line; 224 | string_type key; 225 | string_type value; 226 | string_type null_string; 227 | size_type pos; 228 | 229 | // Trims an string 230 | auto trim = [](string_type& s, bool trimLeft, bool trimRight) -> string_type& 231 | { 232 | if (s.size()) 233 | { 234 | // Ignore UTF-8 BOM 235 | while (s.size() >= 3 && s[0] == (char)(0xEF) && s[1] == (char)(0xBB) && s[2] == (char)(0xBF)) 236 | s.erase(s.begin(), s.begin() + 3); 237 | 238 | if (trimLeft) 239 | s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not_fn(std::function(::isspace)))); 240 | if (trimRight) 241 | s.erase(std::find_if(s.rbegin(), s.rend(), std::not_fn(std::function(::isspace))).base(), s.end()); 242 | } 243 | return s; 244 | }; 245 | 246 | // Start parsing 247 | while (std::getline(ini_mem, line)) 248 | { 249 | // Find comment and remove anything after it from the line 250 | if ((pos = line.find_first_of(';')) != line.npos) 251 | line.erase(pos); 252 | 253 | if ((pos = line.rfind(" //")) != line.npos) 254 | line.erase(pos); 255 | 256 | // Trim the string, and if it gets empty, skip this line 257 | if (trim(line, true, true).empty()) 258 | continue; 259 | 260 | // Find section name 261 | if (line.front() == '[' && line.back() == ']') 262 | { 263 | pos = line.length() - 1; //line.find_first_of(']'); 264 | if (pos != line.npos) 265 | { 266 | trim(key.assign(line, 1, pos - 1), true, true); 267 | keys = &data[std::move(key)]; // Create section 268 | } 269 | else 270 | keys = nullptr; 271 | } 272 | else 273 | { 274 | // Find key and value positions 275 | pos = line.find_first_of('='); 276 | if (pos == line.npos) 277 | { 278 | // There's only the key 279 | key = line; // No need for trim, line is already trimmed 280 | value.clear(); 281 | } 282 | else 283 | { 284 | // There's the key and the value 285 | trim(key.assign(line, 0, pos), false, true); // trim the right 286 | trim(value.assign(line, pos + 1, line.npos), true, false); // trim the left 287 | } 288 | 289 | // Put the key/value into the current keys object, or into the section "" if no section has been found 290 | #if __cplusplus >= 201103L || _MSC_VER >= 1800 291 | (keys ? *keys : data[null_string]).emplace(std::move(key), std::move(value)); 292 | #else 293 | (keys ? *keys : data[null_string])[key] = value; 294 | key.clear(); value.clear(); 295 | #endif 296 | } 297 | } 298 | 299 | return true; 300 | } 301 | return false; 302 | } 303 | 304 | bool read_file(const char_type* filename) 305 | { 306 | std::ifstream file(filename, std::ios::in); 307 | if (file.is_open()) 308 | { 309 | std::stringstream ss; 310 | ss << file.rdbuf(); 311 | file.close(); 312 | return read_file(ss); 313 | } 314 | return false; 315 | } 316 | 317 | /* 318 | * Dumps the content of this container into an ini file 319 | */ 320 | bool write_file(const char_type* filename) 321 | { 322 | FILE* f; 323 | errno_t err; 324 | if ((err = fopen_s(&f, filename, "w")) == 0) 325 | { 326 | bool first = true; 327 | for (auto& sec : this->data) 328 | { 329 | fprintf(f, first ? "[%s]\n" : "\n[%s]\n", sec.first.c_str()); 330 | first = false; 331 | for (auto& kv : sec.second) 332 | { 333 | if (kv.second.empty()) 334 | fprintf(f, "%s\n", kv.first.c_str()); 335 | else 336 | fprintf(f, "%s = %s\n", kv.first.c_str(), kv.second.c_str()); 337 | } 338 | } 339 | fclose(f); 340 | return true; 341 | } 342 | return false; 343 | } 344 | 345 | 346 | /* 347 | */ 348 | bool load_file(const char_type* filename) 349 | { 350 | return read_file(filename); 351 | } 352 | 353 | bool load_file(const StringType& filename) 354 | { 355 | return load_file(filename.c_str()); 356 | } 357 | 358 | bool load_file(std::stringstream& filename) 359 | { 360 | return read_file(filename); 361 | } 362 | 363 | bool write_file(const StringType& filename) 364 | { 365 | return write_file(filename.c_str()); 366 | } 367 | }; 368 | 369 | 370 | /* Use default basic_ini 371 | * 372 | * Limitations: 373 | * * Not unicode aware 374 | * * Case sensitive 375 | * * Sections must have unique keys 376 | */ 377 | typedef basic_ini<> ini; 378 | } 379 | 380 | #endif 381 | 382 | -------------------------------------------------------------------------------- /Source/config.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // Config.ini variables 4 | bool useCustomFPSCap; 5 | bool useCustomFOV; 6 | int tMaxFPS; 7 | bool ignoreUpdates; 8 | int customFOV; 9 | int motionBlurQuality; 10 | int anisotropicFiltering; 11 | int resolutionScale; -------------------------------------------------------------------------------- /Source/dllmain.cpp: -------------------------------------------------------------------------------- 1 | // dllmain.cpp: This is where the magic happens! 2 | 3 | /** 4 | EDFix (C) 2020 Bryce Q. 5 | 6 | EDFix is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | EDFix is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with this program. If not, see . 18 | **/ 19 | 20 | #define _CRT_SECURE_NO_WARNINGS 21 | #define _USE_MATH_DEFINES 22 | 23 | #include "../Source/pch.h" 24 | #include "wtypes.h" 25 | #include 26 | #include 27 | #include 28 | #include 29 | #include 30 | #include 31 | #include "../Source/ThirdParty/inireader/IniReader.h" 32 | #include "../Source/ThirdParty/ModUtils/MemoryMgr.h" 33 | #include "config.h" 34 | #include "offsets.h" 35 | 36 | using namespace std; 37 | 38 | // Resolution and Aspect Ratio variables 39 | int hRes; 40 | int vRes; 41 | float aspectRatio; 42 | bool preserveYAxis; 43 | 44 | // FOV variables 45 | float originalFOV = 0.008726646192; // Declares the original 16:9 vertical FOV. 46 | float combatFOV; 47 | float explorationFOV; 48 | float FOVOffset; 49 | 50 | // Misc variables 51 | bool check = true; // do not change to false or else resolution checks won't run. 52 | 53 | // Process HMODULE variable 54 | HMODULE baseModule = GetModuleHandle(NULL); 55 | 56 | void readConfig() 57 | { 58 | cout.flush(); 59 | //freopen(FILE**)stdout, "CONOUT$", "w", stdout); // Allows us to add outputs to the ASI Loader Console Window. 60 | cout.clear(); 61 | cin.clear(); 62 | CIniReader config("config.ini"); 63 | // Aspect Ratio Values 64 | preserveYAxis = config.ReadBoolean("AspectRatio", "PreserveYAxis", false); 65 | // FOV Config Values 66 | useCustomFOV = config.ReadBoolean("FieldOfView", "useCustomFOV", false); 67 | explorationFOV = config.ReadInteger("FieldOfView", "explorationFOV", 70); 68 | combatFOV = config.ReadInteger("FieldOfView", "combatFOV", 60); 69 | // Framerate/VSync Config Values 70 | useCustomFPSCap = config.ReadBoolean("Experimental", "forceFPSCap", true); 71 | tMaxFPS = config.ReadInteger("Experimental", "maxFPS", 1000); 72 | } 73 | 74 | void fovOffsetCalc() 75 | { 76 | // Declare the vertical and horizontal resolution variables. 77 | hRes = *(int*)((intptr_t)baseModule + hResPointer); // Grabs Horizontal Resolution integer. 78 | vRes = *(int*)((intptr_t)baseModule + vResPointer); // Grabs Vertical Resolution integer. 79 | 80 | // Convert the int values to floats, so then we can determine the aspect ratio. 81 | aspectRatio = (float)hRes / (float)vRes; 82 | 83 | if (!preserveYAxis) 84 | { 85 | // If the aspect ratio is less than or equal to 16:9, use the standard Vert- offset, so 16:10 and 4:3 resolutions will look okay. 86 | if (aspectRatio <= (16.0f / 9.0f)) 87 | { 88 | FOVOffset = originalFOV; 89 | } 90 | // If the aspect ratio is greater than 16:9, then adjust the FOV offset based on the current screen resolution, as you don't want Vert- behavior in 21:9/32:9/48:9/etc. 91 | else if (aspectRatio > (16.0f / 9.0f)) 92 | { 93 | // If useCustomFOV is set to "0", then calculate the vertical FOV using the new aspect ratio, the old aspect ratio, and the original FOV. 94 | FOVOffset = std::round((2.0f * atan(((aspectRatio) / (16.0f / 9.0f)) * tan((originalFOV * 10000.0f) / 2.0f * ((float)M_PI / 180.0f)))) * (180.0f / (float)M_PI) * 100.0f) / 100.0f / 10000.0f; 95 | } 96 | } 97 | else 98 | { 99 | FOVOffset = std::round((2.0f * atan(((aspectRatio) / (16.0f / 9.0f)) * tan((originalFOV * 10000.0f) / 2.0f * ((float)M_PI / 180.0f)))) * (180.0f / (float)M_PI) * 100.0f) / 100.0f / 10000.0f; 100 | } 101 | 102 | // Writes FOV offset to Memory. 103 | *(float*)((intptr_t)baseModule + fovOffsetPointer) = FOVOffset; 104 | } 105 | 106 | void fovCalc() 107 | { 108 | // Instead of modifying the FOV offset, we are just going to modify the FOV offset directly. 109 | if (useCustomFOV) 110 | { 111 | 112 | } 113 | else 114 | { 115 | // Adjust Combat and Exploration FOV here. This will need to be patched in once I can fix the fucking awful typecast crashes. 116 | //if (*(float*)(*(((intptr_t*)((intptr_t*)(((intptr_t)baseModule + 0x04C89838))) + 0x250)) + 0x270) = 70.0f) 117 | //{ 118 | //*(float*)(*(((intptr_t*)((intptr_t*)(((intptr_t)baseModule + 0x04C89838))) + 0x250)) + 0x270) = (float)110; 119 | //} 120 | //if (*(float*)(*(((intptr_t*)((intptr_t*)(((intptr_t)baseModule + 0x04C89838))) + 0x250)) + 0x290) = 80.0f) 121 | //{ 122 | //*(float*)(*(((intptr_t*)((intptr_t*)(((intptr_t)baseModule + 0x04C89838))) + 0x250)) + 0x290) = (float)160; 123 | //} 124 | } 125 | } 126 | 127 | void uncapFPS() //Uncaps the framerate. 128 | { 129 | //Writes the new t.MaxFPS cap to memory, alongside pointer. 130 | *(float*)(*((intptr_t*)((intptr_t)baseModule + fpsCapPointer)) + 0x0) = (float)tMaxFPS; 131 | } 132 | 133 | void pillarboxRemoval() // Adjusts pillarboxes based on the current aspect ratio. Probably requires exiting to the main menu to apply the static ones. 134 | { 135 | // Writes pillarbox removal into memory ("F6 41 30 01" to "F6 41 30 00"). Seemingly, instead of 2C, the byte is 30. 136 | memcpy((LPVOID)((intptr_t)baseModule + 0x233B155), "\xF6\x41\x30\x00", 4); 137 | } 138 | 139 | void resolutionCheck() 140 | { 141 | if (aspectRatio != (*(int*)((intptr_t)baseModule + 0x455A4F0) / *(int*)((intptr_t)baseModule + 0x455A4F4))) 142 | { 143 | fovOffsetCalc(); 144 | } 145 | } 146 | 147 | void framerateCheck() 148 | { 149 | if (tMaxFPS != *(float*)(*((intptr_t*)((intptr_t)baseModule + 0x04C40A58)) + 0x0)) 150 | { 151 | uncapFPS(); 152 | } 153 | } 154 | 155 | void StartPatch() 156 | { 157 | // Reads the "config.ini" config file for values that we are going to want to modify. 158 | readConfig(); 159 | 160 | // Unprotects the main module handle. 161 | ScopedUnprotect::FullModule UnProtect(baseModule); 162 | 163 | Sleep(5000); // Sleeps the thread for five seconds before applying the memory values. 164 | 165 | fovOffsetCalc(); // Calculates the new vertical FOV. 166 | 167 | fovCalc(); 168 | 169 | pillarboxRemoval(); // Removes the in-game pillarboxing. 170 | 171 | // checks if CustomFPS cap is enabled before choosing which processes to loop, and if to uncap the framerate. This is done to save on CPU resources. 172 | if (useCustomFPSCap == true) 173 | { 174 | uncapFPS(); //Uncaps the framerate. 175 | float sleepinMs = ((1 / (float)tMaxFPS) * 1000); // Takes the max framerate cap and uses that for the sleep value for now, until I can get a Waitable Timer implemented. 176 | // Runs resolution and framerate check in a loop. 177 | while (check != false) 178 | { 179 | Sleep(sleepinMs); 180 | resolutionCheck(); 181 | framerateCheck(); 182 | } 183 | } 184 | else 185 | { 186 | // Runs resolution check in a loop. 187 | while (check != false) 188 | { 189 | float sleepinMs = ((1 / *(float*)(*((intptr_t*)((intptr_t)baseModule + 0x04C40A58)) + 0x0)) * 1000); 190 | Sleep(sleepinMs); 191 | resolutionCheck(); 192 | } 193 | } 194 | } 195 | 196 | BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) 197 | { 198 | if (ul_reason_for_call == DLL_PROCESS_ATTACH) // This code runs when the DLL file has been attached to the game process. 199 | { 200 | HANDLE patchThread; // Creates a handle to the patch thread, so it can be closed easier 201 | patchThread = (HANDLE)_beginthreadex(NULL, 0, (unsigned(__stdcall*)(void*))StartPatch, NULL, 0, 0); // Calls the StartPatch function in a new thread on start. 202 | // CloseHandle(patchThread); // Closes the StartPatch thread handle. 203 | } 204 | return TRUE; 205 | } 206 | -------------------------------------------------------------------------------- /Source/framework.h: -------------------------------------------------------------------------------- 1 | /** 2 | EDFix (C) 2020 Bryce Q. 3 | 4 | EDFix is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | 9 | EDFix is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with this program. If not, see . 16 | **/ 17 | #pragma once 18 | 19 | #include "targetver.h" 20 | #define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers 21 | // Windows Header Files 22 | #include 23 | // C RunTime Header Files 24 | #include 25 | #include 26 | #include 27 | #include -------------------------------------------------------------------------------- /Source/offsets.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // Resolution Offsets 4 | int hResPointer = 0x455A4F0; 5 | int vResPointer = 0x455A4F4; 6 | 7 | int fpsCapPointer = 0x04C40A58; 8 | 9 | int fovOffsetPointer = 0x3F80C8C; -------------------------------------------------------------------------------- /Source/pch.cpp: -------------------------------------------------------------------------------- 1 | // pch.cpp: source file corresponding to the pre-compiled header 2 | 3 | /** 4 | EDFix (C) 2020 Bryce Q. 5 | 6 | EDFix is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | EDFix is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with this program. If not, see . 18 | **/ 19 | 20 | #include "../Source/pch.h" 21 | 22 | // When you are using pre-compiled headers, this source file is necessary for compilation to succeed. 23 | -------------------------------------------------------------------------------- /Source/pch.h: -------------------------------------------------------------------------------- 1 | // pch.h: This is a precompiled header file. 2 | // Files listed below are compiled only once, improving build performance for future builds. 3 | // This also affects IntelliSense performance, including code completion and many code browsing features. 4 | // However, files listed here are ALL re-compiled if any one of them is updated between builds. 5 | // Do not add files here that you will be updating frequently as this negates the performance advantage. 6 | 7 | /** 8 | EDFix (C) 2020 Bryce Q. 9 | 10 | EDFix is free software: you can redistribute it and/or modify 11 | it under the terms of the GNU General Public License as published by 12 | the Free Software Foundation, either version 3 of the License, or 13 | (at your option) any later version. 14 | 15 | EDFix is distributed in the hope that it will be useful, 16 | but WITHOUT ANY WARRANTY; without even the implied warranty of 17 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 | GNU General Public License for more details. 19 | 20 | You should have received a copy of the GNU General Public License 21 | along with this program. If not, see . 22 | **/ 23 | 24 | #ifndef PCH_H 25 | #define PCH_H 26 | 27 | // add headers that you want to pre-compile here 28 | #include "../Source/framework.h" 29 | 30 | #endif //PCH_H 31 | -------------------------------------------------------------------------------- /Source/targetver.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // // Including SDKDDKVer.h defines the highest available Windows platform. 4 | // If you wish to build your application for a previous Windows platform, include WinSDKVer.h and 5 | // set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h. 6 | #include 7 | -------------------------------------------------------------------------------- /Tales of Arise.CT: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 109 6 | "Resolution Stuff" 7 | 8 | 9 | 1 10 | 11 | 12 | 255 13 | "Disable Pillarboxes" 14 | 15 | Auto Assembler Script 16 | [ENABLE] 17 | //code from here to '[DISABLE]' will be used to enable the cheat 18 | alloc(newmem,2048,"Tales of Arise.exe"+233B155) 19 | label(returnhere) 20 | label(originalcode) 21 | label(exit) 22 | 23 | newmem: //this is allocated memory, you have read,write,execute access 24 | //place your code here 25 | test byte ptr [rcx+30],00 26 | 27 | originalcode: 28 | //test byte ptr [rcx+30],01 29 | movaps [r11-38],xmm7 30 | 31 | exit: 32 | jmp returnhere 33 | 34 | "Tales of Arise.exe"+233B155: 35 | jmp newmem 36 | nop 4 37 | returnhere: 38 | 39 | [DISABLE] 40 | //code from here till the end of the code will be used to disable the cheat 41 | dealloc(newmem) 42 | "Tales of Arise.exe"+233B155: 43 | test byte ptr [rcx+30],01 44 | movaps [r11-38],xmm7 45 | //Alt: db F6 41 30 01 41 0F 29 7B C8 46 | 47 | 48 | 49 | 111 50 | "Vert- FOV Offset (Use "0.01165633369" for 21:9, or "0.01609274559" for 32:9)" 51 | 52 | 0 53 | Float 54 |

"Tales of Arise.exe"+3F80C8C

55 | 56 | 57 | 58 | 59 | 110 60 | "FOV" 61 | 62 | 63 | 1 64 | 65 | 66 | 206 67 | "FOV Exploration (70 degrees by default)" 68 | 69 | Float 70 |

"Tales of Arise.exe"+04C89838

71 | 72 | 250 73 | 270 74 | 75 | 76 | 77 | 254 78 | "FOV Combat (60 degrees by default)" 79 | 80 | Float 81 |

"Tales of Arise.exe"+04C89838

82 | 83 | 250 84 | 290 85 | 86 | 87 | 88 | 89 | 90 | 112 91 | "Framerate" 92 | 93 | 94 | 1 95 | 96 | 97 | 2 98 | "t.MaxFPS (Keep locked to prevent game from adjusting FPS cap during cutscenes)" 99 | 100 | Float 101 |

"Tales of Arise.exe"+04C40A58

102 | 103 | 0 104 | 105 | 106 | 107 | 204 108 | "Disable Framerate Cap During Cutscenes (Will probably affect FPS cap during gameplay, only toggle when game has loaded)" 109 | 110 | Auto Assembler Script 111 | [ENABLE] 112 | //code from here to '[DISABLE]' will be used to enable the cheat 113 | alloc(newmem,2048,"Tales of Arise.exe"+124E8D5) 114 | label(returnhere) 115 | label(originalcode) 116 | label(exit) 117 | 118 | newmem: //this is allocated memory, you have read,write,execute access 119 | //place your code here 120 | nop 121 | 122 | originalcode: 123 | //movss [rdi+38],xmm1 124 | 125 | exit: 126 | jmp returnhere 127 | 128 | "Tales of Arise.exe"+124E8D5: 129 | jmp newmem 130 | returnhere: 131 | 132 | 133 | 134 | 135 | [DISABLE] 136 | //code from here till the end of the code will be used to disable the cheat 137 | dealloc(newmem) 138 | "Tales of Arise.exe"+124E8D5: 139 | movss [rdi+38],xmm1 140 | //Alt: db F3 0F 11 4F 38 141 | 142 | 143 | 144 | 145 | 146 | 203 147 | "Only used for referencing current resolution" 148 | 149 | 1 150 | 151 | 152 | 201 153 | "Horizontal Resolution" 154 | 155 | 4 Bytes 156 |

"Tales of Arise.exe"+455A4F0

157 | 158 | 159 | 202 160 | "Vertical Resolution" 161 | 162 | 4 Bytes 163 |

"Tales of Arise.exe"+455A4F4

164 | 165 | 166 | 167 | 168 | 169 | 170 | -------------------------------------------------------------------------------- /appveyor.yml: -------------------------------------------------------------------------------- 1 | version: 1.0.{build} 2 | image: Visual Studio 2019 3 | configuration: Release 4 | before_build: 5 | - cmd: git submodule -q update --init --recursive 6 | build: 7 | project: AriseFix.sln 8 | verbosity: minimal 9 | before_package: 10 | - ps: "$releases = \"https://github.com/ThirteenAG/Ultimate-ASI-Loader/releases\"\n$name = \"Ultimate-ASI-Loader_x64.zip\"\n \n$latestRelease = Invoke-WebRequest $releases/latest -Headers @{\"Accept\"=\"application/json\"}\n$json = $latestRelease.Content | ConvertFrom-Json\n$latestVersion = $json.tag_name\n$url = \"$releases/download/$latestVersion/$name\"\nStart-FileDownload $url -FileName 'C:\\Ultimate-ASI-Loader_x64.zip'\n7z e c:\\Ultimate-ASI-Loader_x64.zip -oc:\\projects\\AriseFix\\Binaries\\Win64\ncd \"Binaries\\Win64\"\nRename-Item -Path \"dinput8.dll\" -NewName \"dsound.dll\"" 11 | after_build: 12 | - cmd: >- 13 | cd c:\projects\AriseFix\Binaries\Win64\plugins 14 | 15 | del *.bat 16 | artifacts: 17 | - path: Binaries\Win64 18 | name: AriseFix_Win64_Build-$(configuration)-v$(appveyor_build_version) --------------------------------------------------------------------------------