OmegaWare Framework
The Foundation of Everything
The OmegaWare Framework is our flagship project and the backbone of all our game modification tools. What started as a simple helper library has evolved into a comprehensive framework that streamlines the entire development process for game cheats and modifications.
The framework's main interface showcasing the modular design and user-friendly controls.
Why We Built This
After working on multiple game modification projects, we noticed we were constantly rewriting the same foundational code - memory manipulation, process injection, UI systems, and debugging tools. The OmegaWare Framework was born out of the need to standardize these components and create a reusable foundation.
Core Architecture
The framework is built around a modular architecture that separates concerns and allows for easy extension. The main directory structure includes:
- Features/ - Core feature implementations and examples
- Memory/ - Memory management, pattern scanning, and manipulation
- GUI/ - ImGui-based user interface system
- Hooks/ - Function hooking and interception
- Interfaces/ - Engine-specific interfaces (Unity, Unreal, etc.)
- Utils/ - Utility functions and helper classes
- Config/ - Configuration management
- Localization/ - Multi-language support
#pragma once
#include "pch.h"
class BaseFeature
{
public:
BaseFeature()
{
RegisterFeature(this);
};
/**
* Called upon menu creation. Create any and all
* menu elements for this feature here.
*/
virtual bool SetupMenu() { return true; };
/**
* Called once upon startup for hooking or variable
* initialization.
*/
virtual bool Setup() { return true; };
/**
* Called once upon shutdown to handle cleanup such as
* restoring hooks.
*/
virtual void Destroy() {};
/**
* Called at the start of every frame for input handling.
*/
virtual void HandleInput() {};
/**
* Called once every frame.
*/
virtual void Render() {};
/**
* Called 10 times per second in the main thread.
*/
virtual void Run() {};
/**
* Called every frame while the menu is open to update any
* menu elements.
*/
virtual void HandleMenu() {};
/**
* Returns the name of this feature for logging purposes.
*/
virtual std::string GetName() = 0;
private:
static void RegisterFeature(BaseFeature* pFeature)
{
Framework::g_vecFeatures.emplace_back(pFeature);
}
};This feature system provides a comprehensive lifecycle management approach with dedicated methods for different phases of execution - from initialization and menu setup to per-frame updates and cleanup. Each feature automatically registers itself with the framework upon construction.
Multi-Engine Support
// Engine Configuration
#define FRAMEWORK_UNREAL // Unreal Engine 4/5 support
// #define FRAMEWORK_UNITY // Unity Engine support
// #define FRAMEWORK_OTHER // Generic engine support
// Rendering Backend Configuration
#define FRAMEWORK_RENDER_DYNAMIC // Auto-detect rendering backend
// #define FRAMEWORK_RENDER_D3D11 // Force DirectX 11
// #define FRAMEWORK_RENDER_D3D12 // Force DirectX 12
// Framework Version
#define FRAMEWORK_VERSION "6.8.6"
// Architecture
#ifdef _WIN64
#define FRAMEWORK_X64
#endifThis configuration system allows the framework to adapt to different game engines and rendering backends automatically or through manual specification.
What Makes It Special
- Multi-Engine Support: Native support for Unity, Unreal Engine 4/5, and generic engines
- Dynamic Rendering: Auto-detection of DirectX 11/12 backends or manual configuration
- Xmake Build System: Modern build system with cross-platform support and easy dependency management
- Modular Architecture: Clean separation of concerns with dedicated directories for each component
- Safety First: Built-in exception handling and safe memory operations
- Localization Ready: Multi-language support built into the core framework
- Active Development: Currently at version 6.8.6 with regular updates and improvements
- Community Driven: Open source with contributions from team members like Good Evening
The framework serves as the foundation for all our game modification projects, providing a consistent API and development experience across different game engines and rendering backends. Its modular design allows developers to pick and choose components based on their specific needs while maintaining compatibility and performance.