praydog/REFramework

Features

• Runtime Engine Hooking Frameworks - Intercepting and modifying internal game engine functions and state at runtime through hooking and scripting APIs.
• Managed Object Field Readers - REFramework reads the data stored in a field of a managed object, supporting static fields and raw pointers.
• Game Object Debugging Toolkits - A toolkit for inspecting live game objects, visualizing motion chains, and editing behavior trees.
• Game Object Browsers - Browses live game objects, singletons, and their fields and methods through an interactive explorer.
• Runtime Manipulators - Provides runtime read/write access to game object fields and methods through the Type Database.
• Function Hooking - REFramework accesses and calls internal game engine methods and fields through the ObjectExplorer and SDK APIs.
• Engine Lifecycle Hooks - Provides per-frame update and draw event subscriptions for runtime game engine manipulation.
• VR Integration Frameworks - Adds stereoscopic 3D rendering, head tracking, and motion controller input mapping to games.
• Managed Resource Holders - Creates typed resource holders that automatically manage reference counts of wrapped game engine resources.
• AngelScript and Lua Game Scripting - Provides an embedded Lua scripting engine for writing game logic and manipulating engine state at runtime.
• Runtime Scripting Interfaces - An interpreted scripting interface for controlling engine behavior and game state without compilation.
• Managed Heap Object Reflection - Reflects on the managed heap to create, read, and modify game objects and value types.
• Native Game Function Invocations - REFramework invokes a native method on a game object by its type definition and name.
• JIT-Compiled Script Runtimes - Runs modding scripts using C# with JIT compilation for faster execution and true multi-threading.
• Typed Proxies - Auto-generates C# interfaces from the game's type database for compile-time safe access to engine types.
• Direct Native Method Mapping - REFramework maps game type methods to C# methods with typed arguments and return values for compile-time safety.
• Dynamic Method Invokers - REFramework calls a method on a game type by name or reference and reads its return value from a union struct that overlays all primitive types.
• C# Plugin Architectures - Loads and executes modding code in C# and Lua with JIT compilation and interpreted execution.
• Managed Object Instantiation - REFramework instantiates a managed object, string, array, delegate, resource, or user data from a type name.
• Hook Synchronization Primitives - Uses locks and thread-local storage to protect shared state when hooked methods execute on multiple threads.
• Dynamic Function Interception - Hooks into game engine methods at runtime to intercept, inspect, and modify function calls.
• Thread-Safe Function Interception - Hooks functions in a non-blocking manner so multiple threads can execute the same hook simultaneously.
• Method Lookups by Name - REFramework invokes methods on a managed engine object by name, supporting overloaded functions through full prototype strings.
• Post-Execution Interceptors - Runs custom code after game methods return to inspect or modify return values.
• Pre-Execution Interceptors - Runs custom code before game methods execute to inspect or modify arguments and optionally skip the original.
• Game Resource Reference Counts - Manually manages reference counts of game engine resources to control their lifetime.
• Game Function Invocations - REFramework invokes a method on a game object by its definition, passing arguments and receiving the return value.
• Managed Method Invocations - REFramework invokes a managed method on a game object by its name and returns the method's result.
• ImGui Extensions - Provides an ImGui-based window system for creating titled, configurable windows within the game overlay.
• In-Game Overlay Builders - Building custom in-game user interfaces with windows, widgets, and node editors using the ImGui library.
• In-Game Overlay Systems - A custom UI system built on ImGui for creating overlays, menus, and node editors within games.
• Pre and Post Hook Combinations - Attaches both pre and post hooks to the same game method, capturing context between phases.
• Immediate Mode UI Frameworks - Renders a debug and modding UI overlay using ImGui with widgets for inspection and editing.
• Managed Object Field Accessors - REFramework accesses and modifies fields of a managed engine object using dot notation with automatic reference counting.
• Visual Editors - Provides a visual editor for modifying behavior trees and finite state machines in games.
• Transform Position Setters - REFramework sets the world position of a transform, optionally skipping dirty marking when the scene is locked.
• Hot-Reloaded Plugin Development - Compiles and reloads C# plugins from source files without restarting the application.
• Motion Chain Visualization - Displays active chain objects and their collision data to aid in modding chain files.
• Enum Definitions - Generates real C# enums from game type definitions, replacing magic integers with named constants.
• Garbage Collection Inhibitors - REFramework marks managed objects as global so the .NET garbage collector does not reclaim them while the game still holds references.
• Game Engine Native Plugins - Loads DLL plugins that hook into the framework's rendering, input, and game code callbacks.
• Keyboard State Queries - REFramework checks whether a specified key is down, pressed, or released during the current frame.
• Style Stacks - REFramework pushes or pops style colors and variables onto a stack to temporarily alter widget appearance.
• Cross-Phase Hook Storage - Provides temporary storage containers that persist between pre and post hooks, automatically cleaned up.
• Custom VR Motion Controls - Provides an in-game menu for mapping controller inputs to actions, complementing runtime bindings.
• Singleton Accessors - Provides typed proxy access to singleton game objects for direct manipulation.
• Component Manipulators - REFramework adds or removes components on game objects at runtime to alter their behavior dynamically.
• Value Type Field Setters - REFramework assigns a value to a named field on a local value type object, but does not affect in-game state until the object is passed to a function that consumes it.
• VR Input Handling - Maps physical VR controller inputs to in-game actions through the VR runtime's binding system.
• 3D World Overlays - Provides 3D world-space overlay rendering for debugging and visualizing game objects and collisions.
• Type Definition Caches - Stores resolved type definitions to speed up repeated calls and field accesses.
• Hot Path Caches - Stores resolved method and field definitions in static fields to avoid repeated string-based lookups.
• Plugin Assembly Distributions - Loads DLL assemblies from a designated folder for distributing production-ready mods.
• Object Lifetime Management - Manually controls reference counts and garbage collection for game resources and managed objects.
• Runtime Type Inspection - Reflects on any RE Engine type to list methods, fields, and properties at runtime.
• Runtime Object Casts - Provides typed proxy casting for live game objects via .As() method.
• Hook Synchronization Locks - Ships thread-safe hook synchronization using locks to protect shared state during concurrent method interception.
• Transform Rotation Setters - REFramework sets the world rotation of a transform using a quaternion.
• SDK Metadata Exports - Exports the full type database to JSON and C++ headers for offline reference and tooling.
• Native Plugin Development - Loads DLL plugins that access the full SDK to perform tasks beyond scripting capabilities.
• Virtual Machine Reference Flushing - Manually clears the RE Engine VM's local reference frame on custom threads to prevent heap corruption.
• Call Counting Hooks - Attaches to any method to count calls and optionally skip the original function for debugging.
• Per-Object Virtual Method Hooks - REFramework intercepts virtual method calls on a specific object instance rather than globally for all objects.
• Node-Based UI Editors - Provides a node-based graph editor using ImNodes for editing behavior trees and state machines within games.

Istoric stele