### Basic Dump Workflow Example Source: https://context7.com/spuckwaffel/uedumper/llms.txt Demonstrates a typical workflow for using the EngineCore class to dump game data. This includes initializing memory, the engine core, caching FNames, generating packages, accessing data, and saving the project. ```cpp // Usage example: Basic dump workflow void exampleDumpWorkflow() { // 1. Initialize memory Memory::load("MyGame.exe"); // 2. Initialize engine core EngineCore engine; if (!EngineCore::initSuccess()) { printf("Engine init failed\n"); return; } // 3. Cache FNames int64_t finished = 0, total = 0; CopyStatus status = CS_idle; EngineCore::cacheFNames(finished, total, status); printf("Cached %lld FNames\n", finished); // 4. Generate packages finished = 0; total = 0; status = CS_idle; EngineCore::generatePackages(finished, total, status); // 5. Access generated data auto& packages = EngineCore::getPackages(); for (const auto& pkg : packages) { printf("Package: %s (%d classes, %d structs)\n", pkg.packageName.c_str(), (int)pkg.classes.size(), (int)pkg.structs.size()); } // 6. Save project int done = 0, totalProg = 0; EngineCore::saveToDisk(done, totalProg); } ``` -------------------------------- ### EngineCore Initialization and Data Caching Source: https://context7.com/spuckwaffel/uedumper/llms.txt Methods for initializing the engine core and caching FNames from the target process. ```APIDOC ## EngineCore::cacheFNames ### Description Caches FNames from the target process memory. ### Parameters - **finishedNames** (int64_t&) - Required - Reference to track progress of cached names. - **totalNames** (int64_t&) - Required - Reference to track total names to be cached. - **status** (CopyStatus&) - Required - Reference to the current copy status. ## EngineCore::generatePackages ### Description Generates SDK packages after FNames have been successfully cached. ### Parameters - **finishedPackages** (int64_t&) - Required - Reference to track progress of generated packages. - **totalPackages** (int64_t&) - Required - Reference to track total packages to be generated. - **status** (CopyStatus&) - Required - Reference to the current copy status. ``` -------------------------------- ### Configure Unreal Engine Version Settings Source: https://context7.com/spuckwaffel/uedumper/llms.txt Edit UEdefinitions.h to set the target engine version and enable specific features like FName encryption or blueprint fast-calls. Recompile the project after modifying these definitions. ```cpp // Engine/Userdefined/UEdefinitions.h // Supported UE versions #define UE_4_19 0 #define UE_4_20 1 #define UE_4_21 2 #define UE_4_22 3 #define UE_4_23 4 #define UE_4_24 5 #define UE_4_25 6 #define UE_4_26 7 #define UE_4_27 8 #define UE_5_00 9 #define UE_5_01 10 #define UE_5_02 11 #define UE_5_03 12 #define UE_5_04 13 // Set your target game's UE version #define UE_VERSION UE_4_27 // FName encryption settings #define USE_FNAME_ENCRYPTION FALSE // Set TRUE if game encrypts FNames // Case preserving name (enable if GNames fail) #define WITH_CASE_PRESERVING_NAME FALSE // UFunction settings - disable if function offsets show as 0 #define UE_BLUEPRINT_EVENTGRAPH_FASTCALLS TRUE // UStruct settings for UE 4.22+ #define USTRUCT_FAST_ISCHILDOF_IMPL TRUE // GObjects XOR encryption (e.g., 0x8375 for Back4Blood) #define GOBJECTS_XOR_ECRYPTION_KEY 0x0 // SDK generation - include static asserts for size validation #define WRITE_STATIC_ASSERT_TESTS TRUE ``` -------------------------------- ### Implement Custom Memory Access (driver.h) Source: https://context7.com/spuckwaffel/uedumper/llms.txt Provides low-level memory access routines using Windows API or custom driver IOCTLs. Requires implementation of init, loadData, _read, _write, and _getBaseAddress. ```cpp // Memory/driver.h // Global process handle HANDLE procHandle = nullptr; // Initialize driver/communication (called before loadData) inline void init() { // Custom driver initialization here } // Load target process data inline void loadData(std::string& processName, uint64_t& baseAddress, int& processID) { const auto name = std::wstring(processName.begin(), processName.end()); baseAddress = _getBaseAddress(name.c_str(), processID); attachToProcess(processID); } // Custom read function inline void _read(const void* address, void* buffer, const DWORD64 size) { // Default: Windows API size_t bytes_read = 0; ReadProcessMemory(procHandle, address, buffer, size, &bytes_read); // Alternative: Custom driver IOCTL // DRIVER_READ_REQUEST request = { address, buffer, size }; // DeviceIoControl(driverHandle, IOCTL_READ, &request, sizeof(request), NULL, 0, NULL, NULL); } // Custom write function inline void _write(void* address, const void* buffer, const DWORD64 size) { WriteProcessMemory(procHandle, address, buffer, size, nullptr); } // Get process base address uint64_t _getBaseAddress(const wchar_t* processName, int& pid) { uint64_t baseAddress = 0; // Find process by name HANDLE hProcess = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); PROCESSENTRY32 pe32 = { sizeof(PROCESSENTRY32) }; if (Process32First(hProcess, &pe32)) { while (Process32Next(hProcess, &pe32)) { if (wcscmp(pe32.szExeFile, processName) == 0) { pid = pe32.th32ProcessID; break; } } } CloseHandle(hProcess); // Get module base if (pid != 0) { HANDLE hModule = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid); MODULEENTRY32 me32 = { sizeof(MODULEENTRY32) }; if (Module32First(hModule, &me32)) { baseAddress = reinterpret_cast(me32.modBaseAddr); } CloseHandle(hModule); } return baseAddress; } ``` -------------------------------- ### Generate C++ SDK with Feature Flags Source: https://context7.com/spuckwaffel/uedumper/llms.txt Defines the SDKGeneration class and feature flags for customizing output. Use the STABLE preset for production-ready code. ```cpp // Engine/Generation/SDK.h class SDKGeneration { public: SDKGeneration(); // Print credits header to output file static void printCredits(std::ofstream& stream); // Generate a single package to stream static void generatePackage( std::ofstream& stream, const EngineStructs::Package& package, int featureFlags, std::unordered_map& originalPackageToMerged ); // Generate complete SDK static void Generate(int& progressDone, int& totalProgress, int featureFlags); }; // Feature flags for SDK generation namespace FeatureFlags { namespace SDK { static constexpr int FUNCTION_BODIES = 1 << 0; // Include function implementations static constexpr int FORWARD_DECLARATIONS = 1 << 1; // Add forward declarations static constexpr int ADD_INCLUDES = 1 << 2; // Add #include statements static constexpr int STRUCTS_BEFORE_CLASSES = 1 << 3; // Order structs before classes static constexpr int STATIC_ASSERTS_OBJECT_SIZE = 1 << 4; // Size validation asserts static constexpr int STATIC_ASSERTS_MEMBERS = 1 << 5; // Member offset asserts // Stable preset: size and member validation static constexpr int STABLE = STATIC_ASSERTS_OBJECT_SIZE | STATIC_ASSERTS_MEMBERS; // Experimental: all features enabled static constexpr int EXPERIMENTAL_INTERNAL = STABLE | FUNCTION_BODIES | FORWARD_DECLARATIONS | ADD_INCLUDES | STRUCTS_BEFORE_CLASSES; }} // Usage example: Generate SDK with feature flags void exampleSDKGeneration() { int done = 0, total = 0; // Generate with stable preset (recommended) SDKGeneration::Generate(done, total, FeatureFlags::SDK::STABLE); // Or with custom flags int customFlags = FeatureFlags::SDK::STATIC_ASSERTS_OBJECT_SIZE | FeatureFlags::SDK::FORWARD_DECLARATIONS; SDKGeneration::Generate(done, total, customFlags); } ``` -------------------------------- ### Generate Modular Development Kit (MDK) Source: https://context7.com/spuckwaffel/uedumper/llms.txt Provides the MDKGeneration interface for creating an alternative SDK structure. ```cpp // Engine/Generation/MDK.h class MDKGeneration { public: MDKGeneration(); // Generate complete MDK static void generate(int& progressDone, int& totalProgress); }; // Usage example void exampleMDKGeneration() { int done = 0, total = 0; MDKGeneration::generate(done, total); printf("MDK generation complete: %d/%d\n", done, total); } ``` -------------------------------- ### SDK Generation (SDK.h) Source: https://context7.com/spuckwaffel/uedumper/llms.txt Generates traditional C++ SDK header files from dumped packages. Supports various feature flags for customizing output format. ```APIDOC ## SDK Generation (SDK.h) ### Description Generate traditional C++ SDK header files from the dumped packages. Supports various feature flags for customizing output format. ### Class `SDKGeneration` ### Methods - `printCredits(std::ofstream& stream)`: Print credits header to output file. - `generatePackage(std::ofstream& stream, const EngineStructs::Package& package, int featureFlags, std::unordered_map& originalPackageToMerged)`: Generate a single package to stream. - `Generate(int& progressDone, int& totalProgress, int featureFlags)`: Generate complete SDK. ### Feature Flags for SDK Generation `namespace FeatureFlags::SDK` - `FUNCTION_BODIES` (1 << 0): Include function implementations. - `FORWARD_DECLARATIONS` (1 << 1): Add forward declarations. - `ADD_INCLUDES` (1 << 2): Add #include statements. - `STRUCTS_BEFORE_CLASSES` (1 << 3): Order structs before classes. - `STATIC_ASSERTS_OBJECT_SIZE` (1 << 4): Size validation asserts. - `STATIC_ASSERTS_MEMBERS` (1 << 5): Member offset asserts. - `STABLE`: Stable preset: size and member validation. - `EXPERIMENTAL_INTERNAL`: Experimental: all features enabled. ### Usage Example ```cpp void exampleSDKGeneration() { int done = 0, total = 0; // Generate with stable preset (recommended) SDKGeneration::Generate(done, total, FeatureFlags::SDK::STABLE); // Or with custom flags int customFlags = FeatureFlags::SDK::STATIC_ASSERTS_OBJECT_SIZE | FeatureFlags::SDK::FORWARD_DECLARATIONS; SDKGeneration::Generate(done, total, customFlags); } ``` ``` -------------------------------- ### Project Management and Struct Customization Source: https://context7.com/spuckwaffel/uedumper/llms.txt Methods for saving/loading projects and modifying struct definitions. ```APIDOC ## EngineCore::saveToDisk ### Description Saves the current project state to disk. ### Parameters - **progressDone** (int&) - Required - Reference to track progress completion. - **totalProgress** (int&) - Required - Reference to track total progress steps. ## EngineCore::overrideStruct ### Description Overrides an existing struct definition. Must be called before generatePackages. ### Parameters - **eStruct** (EngineStructs::Struct&) - Required - The struct definition to override. ``` -------------------------------- ### MDK Generation (MDK.h) Source: https://context7.com/spuckwaffel/uedumper/llms.txt Generates Modular Development Kit format, an alternative SDK structure optimized for certain use cases. ```APIDOC ## MDK Generation (MDK.h) ### Description Generate Modular Development Kit format, an alternative SDK structure optimized for certain use cases. ### Class `MDKGeneration` ### Methods - `generate(int& progressDone, int& totalProgress)`: Generate complete MDK. ### Usage Example ```cpp void exampleMDKGeneration() { int done = 0, total = 0; MDKGeneration::generate(done, total); printf("MDK generation complete: %d/%d\n", done, total); } ``` ``` -------------------------------- ### Custom Memory Read/Write (driver.h) Source: https://context7.com/spuckwaffel/uedumper/llms.txt Provides low-level functions for custom memory access, allowing integration with custom drivers for games with anti-cheat protection. It includes initialization, process loading, and read/write operations. ```APIDOC ## Custom Memory Read/Write (driver.h) ### Description Implement custom memory access routines for games with anti-cheat protection. The default implementation uses ReadProcessMemory/WriteProcessMemory. ### Functions - `init()`: Initializes the driver or communication channel. - `loadData(std::string& processName, uint64_t& baseAddress, int& processID)`: Loads target process data by name or PID, retrieving the base address. - `_read(const void* address, void* buffer, const DWORD64 size)`: Reads data from the target process memory. Can use Windows API or a custom driver IOCTL. - `_write(void* address, const void* buffer, const DWORD64 size)`: Writes data to the target process memory. Can use Windows API or a custom driver IOCTL. - `_getBaseAddress(const wchar_t* processName, int& pid)`: Retrieves the base address of a process by its name and its process ID. ``` -------------------------------- ### Configure Custom Data Types Source: https://context7.com/spuckwaffel/uedumper/llms.txt Maps primitive types to string representations and provides a helper to retrieve their sizes. ```cpp // Engine/Userdefined/Datatypes.h // Customize type names #define TYPE_BOOLEAN "bool" #define TYPE_UCHAR "unsigned char" #define TYPE_CHAR "char" #define TYPE_UI8 "uint8_t" #define TYPE_UI16 "uint16_t" #define TYPE_UI32 "uint32_t" #define TYPE_UI64 "uint64_t" #define TYPE_I8 "int8_t" #define TYPE_I16 "int16_t" #define TYPE_I32 "int32_t" #define TYPE_I64 "int64_t" #define TYPE_FLOAT "float" #define TYPE_DOUBLE "double" // Helper function to get type size inline int getSize(const std::string& dataType) { if (dataType == TYPE_BOOLEAN) return sizeof(bool); if (dataType == TYPE_CHAR || dataType == TYPE_UCHAR) return sizeof(char); if (dataType == TYPE_UI8 || dataType == TYPE_I8) return sizeof(int8_t); if (dataType == TYPE_UI16 || dataType == TYPE_I16) return sizeof(int16_t); if (dataType == TYPE_UI32 || dataType == TYPE_I32) return sizeof(int32_t); if (dataType == TYPE_UI64 || dataType == TYPE_I64) return sizeof(int64_t); if (dataType == TYPE_FLOAT) return sizeof(float); if (dataType == TYPE_DOUBLE) return sizeof(double); return -1; // Unknown type } ``` -------------------------------- ### Memory Class (Memory.h) Source: https://context7.com/spuckwaffel/uedumper/llms.txt A unified interface for memory operations, wrapping the driver.h functions with error handling and templated methods for convenience. ```APIDOC ## Memory Class (Memory.h) ### Description The Memory class provides a unified interface for all memory operations, wrapping the driver.h functions with error handling and templated convenience methods. ### Methods - `load(std::string processName)`: Initializes and attaches to the target process by its name. - `load(int processPID)`: Initializes and attaches to the target process by its Process ID. - `getBaseAddress()`: Returns the base address of the loaded process. - `getProcessID()`: Returns the Process ID of the loaded process. - `getStatus()`: Returns the current status of the Memory class (e.g., initialized, loaded). - `getTotalReads()`: Returns the total number of read operations performed. - `getTotalWrites()`: Returns the total number of write operations performed. - `read(const void* address, void* buffer, DWORD64 size)`: Generic function to read a specified number of bytes from a given address. - `read(uint64_t address)`: Templated function to read a value of type T from a given address. - `write(void* address, const void* buffer, DWORD64 size)`: Generic function to write a specified number of bytes to a given address. - `write(uint64_t address, T& data)`: Templated function to write a value of type T to a given address. - `patternScan(int flag, const char* pattern, const std::string& mask)`: Scans memory for a specific byte pattern and returns the address where it's found. ### Usage Example ```cpp // Initialize memory access Memory::LoadError result = Memory::load("MyGame.exe"); if (result != Memory::success) { printf("Failed to load process\n"); return; } uint64_t base = Memory::getBaseAddress(); printf("Base address: 0x%llX\n", base); // Read a 4-byte integer int32_t health = Memory::read(base + 0x1234); printf("Health: %d\n", health); // Read a structure struct FVector { float X, Y, Z; }; FVector position = Memory::read(base + 0x5678); printf("Position: %.2f, %.2f, %.2f\n", position.X, position.Y, position.Z); // Write a value int32_t newHealth = 100; Memory::write(base + 0x1234, newHealth); // Pattern scan for offset uint64_t found = Memory::patternScan( OFFSET_SIGNATURE_FOLLOW, "\x48\x8B\x05\x00\x00\x00\x00", "xxx????" ); printf("Found pattern at: 0x%llX\n", found); ``` ``` -------------------------------- ### Define Game-Specific Memory Offsets Source: https://context7.com/spuckwaffel/uedumper/llms.txt Use Offsets.h to define memory addresses or pattern signatures for GNames, GObjects, and GWorld. Offsets can be configured as direct addresses or relative to signatures. ```cpp // Engine/Userdefined/Offsets.h // Offset flags for different types enum OffsetFlags { OFFSET_LIVE_EDITOR = 1 << 0, // Display in live editor OFFSET_DS = 1 << 1, // Add to Dumpspace export OFFSET_ADDRESS = 1 << 2, // Direct address offset OFFSET_SINGNATURE_DIRECT = 1 << 3 | 1 << 5, // Signature start is offset OFFSET_SIGNATURE_FOLLOW = 1 << 3 | 1 << 4, // Offset at signature + RVA }; // Offset structure definition struct Offset { int flag; // Combination of OffsetFlags std::string name; // Unique identifier for the offset uint64_t offset; // Address offset (without base) const char* sig; // Signature bytes for pattern scanning std::string mask; // Pattern mask (x = compare, ? = wildcard) }; // Configure offsets for your game inline std::vector setOffsets() { std::vector offsets; // Required: GNames offset (using direct address) offsets.push_back({ OFFSET_ADDRESS | OFFSET_DS, "OFFSET_GNAMES", 0x5A12340 // Replace with your game's offset }); // Required: GObjects offset (using direct address) offsets.push_back({ OFFSET_ADDRESS | OFFSET_DS, "OFFSET_GOBJECTS", 0x5B56780 // Replace with your game's offset }); // Optional: GWorld for live editor (using signature) offsets.push_back({ OFFSET_SIGNATURE_FOLLOW | OFFSET_DS | OFFSET_LIVE_EDITOR, "OFFSET_GWORLD", 0, "\x48\x8B\x05\x00\x00\x00\x00\x48\x3B\xC3", "xxx????xxx" }); return offsets; } ``` -------------------------------- ### EngineCore Class Definition Source: https://context7.com/spuckwaffel/uedumper/llms.txt Defines the EngineCore class, which handles FName resolution, package generation, and struct management for SDK output. It requires Memory::load to be called before initialization. ```cpp // Engine/Core/Core.h class EngineCore { public: // Initialize engine (must call after Memory::load) EngineCore(); static bool initSuccess(); // Cache FNames from target process static void cacheFNames(int64_t& finishedNames, int64_t& totalNames, CopyStatus& status); // Generate packages after FName caching static void generatePackages(int64_t& finishedPackages, int64_t& totalPackages, CopyStatus& status); // Get generated packages static std::vector& getPackages(); // Convert FName to string static std::string FNameToString(FName name); // Lookup object info by name static const ObjectInfo* getInfoOfObject(const std::string& CName); // Get unknown/undefined types static const std::vector& getAllUnknownTypes(); // Offset management static uint64_t getOffsetAddress(const Offset& offset); static Offset getOffsetForName(const std::string& name); static std::vector getOffsets(); // Project save/load static void saveToDisk(int& progressDone, int& totalProgress); static bool loadProject(const std::string& filepath, int& progressDone, int& totalProgress); // Struct customization (call BEFORE generatePackages) static void overrideStruct(EngineStructs::Struct& eStruct); static void createStruct(const EngineStructs::Struct& eStruct); static void createEnum(const EngineStructs::Enum& eEnum); static void overrideStructMembers(const EngineStructs::Struct& eStruct); // Runtime struct modification (call AFTER generatePackages) static void runtimeOverrideStructMembers(EngineStructs::Struct* eStruct, const std::vector& members); // Generate struct definitions file static void generateStructDefinitionsFile(); static bool generateFNameFile(int& progressDone, int& totalProgress); }; ``` -------------------------------- ### Custom Type Names (Datatypes.h) Source: https://context7.com/spuckwaffel/uedumper/llms.txt Configure how primitive types are displayed throughout the editor and generated SDK. ```APIDOC ## Data Types Configuration ### Custom Type Names (Datatypes.h) ### Description Configure how primitive types are displayed throughout the editor and generated SDK. ### Type Definitions - `TYPE_BOOLEAN`: "bool" - `TYPE_UCHAR`: "unsigned char" - `TYPE_CHAR`: "char" - `TYPE_UI8`: "uint8_t" - `TYPE_UI16`: "uint16_t" - `TYPE_UI32`: "uint32_t" - `TYPE_UI64`: "uint64_t" - `TYPE_I8`: "int8_t" - `TYPE_I16`: "int16_t" - `TYPE_I32`: "int32_t" - `TYPE_I64`: "int64_t" - `TYPE_FLOAT`: "float" - `TYPE_DOUBLE`: "double" ### Helper Function `getSize(const std::string& dataType)`: Returns the size of a given data type. Returns -1 if the type is unknown. Example usage: ```cpp if (dataType == TYPE_BOOLEAN) return sizeof(bool); // ... other type checks ``` ``` -------------------------------- ### Memory Class Interface and Usage (Memory.h) Source: https://context7.com/spuckwaffel/uedumper/llms.txt Defines the Memory class for unified memory operations and demonstrates reading, writing, and pattern scanning in a target process. ```cpp // Memory/Memory.h class Memory { public: enum LoadError { noProcessID, noBaseAddress, success }; enum MemoryStatus { bad, inizilaized, loaded }; // Initialize and attach to target process static LoadError load(std::string processName); static LoadError load(int processPID); // Get process information static uint64_t getBaseAddress(); static int getProcessID(); static MemoryStatus getStatus(); static int getTotalReads(); static int getTotalWrites(); // Generic read operations static void read(const void* address, void* buffer, DWORD64 size); template static T read(uint64_t address); // Generic write operations static void write(void* address, const void* buffer, DWORD64 size); template static void write(uint64_t address, T& data); // Pattern scanning static uint64_t patternScan(int flag, const char* pattern, const std::string& mask); }; // Usage example: Reading game memory void exampleMemoryUsage() { // Initialize memory access Memory::LoadError result = Memory::load("MyGame.exe"); if (result != Memory::success) { printf("Failed to load process\n"); return; } uint64_t base = Memory::getBaseAddress(); printf("Base address: 0x%llX\n", base); // Read a 4-byte integer int32_t health = Memory::read(base + 0x1234); printf("Health: %d\n", health); // Read a structure struct FVector { float X, Y, Z; }; FVector position = Memory::read(base + 0x5678); printf("Position: %.2f, %.2f, %.2f\n", position.X, position.Y, position.Z); // Write a value int32_t newHealth = 100; Memory::write(base + 0x1234, newHealth); // Pattern scan for offset uint64_t found = Memory::patternScan( OFFSET_SIGNATURE_FOLLOW, "\x48\x8B\x05\x00\x00\x00\x00", "xxx????" ); printf("Found pattern at: 0x%llX\n", found); } ``` -------------------------------- ### Implement Custom FName Decryption Source: https://context7.com/spuckwaffel/uedumper/llms.txt Define a custom decryption function in FName_decryption.h to handle encrypted FNames. The function must modify the input buffer in-place. ```cpp // Engine/Core/FName_decryption.h // Global variables for decryption (mark as static) static uint64_t decryptionKey = 0; // Custom FName decryption function // inputBuf: encrypted name buffer (write decrypted result here) // namelength: length of the name static void fname_decrypt(char* inputBuf, int namelength) { // Example: XOR-based decryption char* v2 = inputBuf; int v4 = namelength; int v5 = 0; uint64_t result = 38i64; if (v4) { do { uint64_t v7 = v5 | result; ++v2; ++v5; BYTE v8 = ~(BYTE)v7; result = (unsigned int)(2 * v7); *(BYTE*)(v2 - 1) ^= v8; } while (v5 < v4); } // If using external buffer, copy back: // memcpy(inputBuf, decryptedBuffer, namelength); } ``` -------------------------------- ### Override and Define Engine Structs and Enums Source: https://context7.com/spuckwaffel/uedumper/llms.txt Use these functions to manually override existing engine structs, define custom structures, or register new enumerations. Ensure that struct sizes and member offsets match the actual engine memory layout. ```cpp // Engine/Userdefined/StructDefinitions.h // Type definition format: // {bool clickable, PropertyType propertyType, string typeName, vector subTypes} // Member definition format: // {fieldType type, string name, int offset, int size, bool missed, bool isBit, int bitOffset} inline void overrideStructs() { // Override UObject class EngineStructs::Struct uObject; uObject.fullName = "/Script/CoreUObject.Object"; uObject.cppName = "UObject"; uObject.size = 0x28; // Must match actual size uObject.maxSize = uObject.size; uObject.inherited = false; uObject.isClass = true; int offset = 0; uObject.definedMembers = std::vector{ // void** vtable - not clickable {{false, PropertyType::ObjectProperty, "uint64_t"}, "vtable", offset, 8}, // EObjectFlags - enum, clickable {{true, PropertyType::EnumProperty, "EObjectFlags"}, "ObjectFlags", offset += 8, 4}, // int InternalIndex - primitive, not clickable {{false, PropertyType::IntProperty, "int"}, "InternalIndex", offset += 4, 4}, // UClass* ClassPrivate - pointer to class, clickable {{true, PropertyType::ObjectProperty, "UClass"}, "ClassPrivate", offset += 4, 8}, // FName NamePrivate - struct, clickable {{true, PropertyType::NameProperty, "FName"}, "NamePrivate", offset += 8, 8}, // UObject* OuterPrivate - pointer to object, clickable {{true, PropertyType::ObjectProperty, "UObject"}, "OuterPrivate", offset += 8, 8} }; EngineCore::overrideStruct(uObject); } // Create custom structs not in engine inline void addStructs() { // Custom FVector struct for live editor visualization EngineStructs::Struct FVector; FVector.fullName = "/Custom/FVector"; FVector.cppName = "FVector"; FVector.size = 12; FVector.maxSize = 12; FVector.isClass = false; FVector.inherited = false; FVector.definedMembers = std::vector{ {{false, PropertyType::FloatProperty, "float"}, "X", 0, 4}, {{false, PropertyType::FloatProperty, "float"}, "Y", 4, 4}, {{false, PropertyType::FloatProperty, "float"}, "Z", 8, 4} }; EngineCore::createStruct(FVector); // Custom TArray template struct EngineStructs::Struct TArray; TArray.fullName = "/Custom/TArray"; TArray.cppName = "TArray"; TArray.size = 16; TArray.maxSize = 16; TArray.isClass = false; TArray.inherited = false; TArray.definedMembers = std::vector{ {{false, PropertyType::ObjectProperty, "T"}, "Data", 0, 8}, {{false, PropertyType::IntProperty, "int32_t"}, "Count", 8, 4}, {{false, PropertyType::IntProperty, "int32_t"}, "Max", 12, 4} }; EngineCore::createStruct(TArray); } // Create custom enums inline void addEnums() { EngineStructs::Enum EObjectFlags; EObjectFlags.fullName = "/Custom/EObjectFlags"; EObjectFlags.cppName = "EObjectFlags"; EObjectFlags.size = 4; EObjectFlags.type = "uint32_t"; EObjectFlags.members = std::vector>{ {"RF_NoFlags", 0x00000000}, {"RF_Public", 0x00000001}, {"RF_Standalone", 0x00000002}, {"RF_Transactional", 0x00000008}, {"RF_ClassDefaultObject", 0x00000010}, {"RF_Transient", 0x00004000} }; EngineCore::createEnum(EObjectFlags); } // Override unknown/missing members in existing structs inline void overrideUnknownMembers() { EngineStructs::Struct Engine; Engine.fullName = "/Script/Engine.Engine"; Engine.cppName = "UEngine"; Engine.definedMembers = std::vector{ // Fill unknown byte blocks with known types {{true, PropertyType::MulticastDelegateProperty, "FSimpleMulticastDelegate"}, "OnPostEngineInit", 0x28, 8}, // Offset 0x28 = sizeof(UObject) }; EngineCore::overrideStructMembers(Engine); } ``` -------------------------------- ### UEDumper Core Data Structures Source: https://context7.com/spuckwaffel/uedumper/llms.txt Defines the fundamental data structures for representing Unreal Engine types, including members, functions, structs, enums, and packages. These are essential for parsing and analyzing game memory. ```cpp // Engine/Core/EngineStructs.h namespace EngineStructs { // Member of a struct/class struct Member { fieldType type; // Type information std::string name; // Member name int offset; // Byte offset in struct int size; // Total size (size * arrayDim) int arrayDim; // Array dimension count bool missed; // True if unknown/padding member bool isBit; // True if bitfield member int bitOffset; // Bit position (0-7) bool userEdited; // True if user modified }; // Function definition struct Function { Struct* owningStruct; uintptr_t memoryAddress; fieldType returnType; std::vector> params; std::string fullName; std::string cppName; std::string functionFlags; uint64_t binaryOffset; }; // Struct or Class definition struct Struct { Package* owningPackage; bool isClass; uintptr_t memoryAddress; std::string fullName; // e.g., "/Script/Engine.Actor" std::string cppName; // e.g., "AActor" std::vector superNames; std::vector supers; bool inherited; int maxSize; int size; std::vector definedMembers; std::vector undefinedMembers; std::vector functions; int getInheritedSize() const; Member* getMemberForIndex(int i); }; // Enum definition struct Enum { uintptr_t memoryAddress; std::string fullName; std::string cppName; std::string type; int size; std::vector> members; }; // Package container struct Package { std::string packageName; int index; std::set dependencyPackages; std::vector structs; std::vector classes; std::vector enums; std::vector functions; }; } ``` ```cpp // Example: Working with dumped structures void exampleStructAccess() { auto& packages = EngineCore::getPackages(); for (const auto& pkg : packages) { printf("=== Package: %s ===\n", pkg.packageName.c_str()); // Iterate classes for (const auto& cls : pkg.classes) { printf("Class: %s (size: 0x%X)\n", cls.cppName.c_str(), cls.maxSize); // Print inheritance if (cls.inherited && !cls.superNames.empty()) { printf(" Inherits: %s\n", cls.superNames[0].c_str()); } // Print members for (const auto& member : cls.definedMembers) { printf(" +0x%04X %s %s", member.offset, member.type.stringify().c_str(), member.name.c_str()); if (member.isBit) printf(" : 1 (bit %d)", member.bitOffset); if (member.missed) printf(" [UNKNOWN]"); printf("\n"); } // Print functions for (const auto& func : cls.functions) { printf(" Function: %s @ 0x%llX\n", func.cppName.c_str(), func.binaryOffset); } } // Iterate enums for (const auto& e : pkg.enums) { printf("Enum: %s\n", e.cppName.c_str()); for (const auto& [name, value] : e.members) { printf(" %s = %d\n", name.c_str(), value); } } } } ``` === COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.