3dmigoto Dx12 Site
The modding community’s relationship with DirectX 12 (DX12) and 3DMigoto is currently a work in progress. While 3DMigoto was originally built as a specialized wrapper for DirectX 11 (DX11), the industry’s shift toward DX12 has led to the development of new projects like geo-12. The Current State of 3DMigoto and DX12
As of now, the main branch of 3DMigoto is strictly a DX11 modding tool. It works by intercepting DX11 API calls to inject custom shaders, textures, and 3D models.
Incompatibility: Popular DX12-exclusive games, such as Cyberpunk 2077 or titles built on Unreal Engine 5, do not natively support standard 3DMigoto.
A "Spiritual Successor": Developers have acknowledged the need for DX12 support and have been working on geo-12, a work-in-progress port of geo-11 (which itself is a 3DMigoto fork) designed to handle DX12 rendering.
Porting Efforts: Some experimental versions have been ported to DX12, though these are often specialized for specific hardware or niche use cases like 3D Vision rather than general-purpose asset replacement. How to Use 3DMigoto for Modern Gaming
Since many newer games default to DX12, modders often use workarounds to make them compatible with the existing DX11 version of 3DMigoto. Description Forcing DX11 Mode
Many games can be forced to run in DX11 using launch parameters like -dx11 or -force-d3d11 in Steam or Epic Games Store properties. GIMI (Genshin Impact Model Importer)
A modified version of 3DMigoto specifically for Genshin Impact, which remains a DX11 game and the primary ecosystem for this tool. ReShade & Geo3D
For users seeking 3D stereoscopic effects in DX12 games (one of 3DMigoto's original purposes), Geo3D is a ReShade plugin that fills this gap. Key Features for Modders
Even without universal DX12 support, 3DMigoto remains the gold standard for DirectX 11 games due to its non-intrusive nature.
3Dmigoto not loading in Cyberpunk 2077 · Issue #137 - GitHub 3dmigoto dx12
Since 3DMigoto is primarily a DirectX 11 (DX11) framework and currently lacks native DirectX 12 (DX12) support, a paper on this topic would likely focus on the technical hurdles of porting it and the current state of "Geo12" alternatives.
Below is a proposed abstract and outline for a technical paper exploring this evolution.
Paper Title: Bridging the Generational Gap: The Technical Challenges of Porting 3DMigoto to DirectX 12 I. Abstract
3DMigoto has served as the cornerstone for shader injection and stereoscopic 3D modding in the DX11 era. However, as the gaming industry shifts toward low-level APIs like DirectX 12, the framework faces significant architectural roadblocks. This paper examines why 3DMigoto does not natively support DX12, the complexities introduced by DX12’s explicit resource management, and the current community efforts—such as "Geo11" and experimental DX12 wrappers—to maintain visual modding capabilities in modern titles. II. Introduction
The Legacy of 3DMigoto: Originally designed for NVIDIA 3D Vision, it evolved into a powerful tool for shader hacking and asset replacement.
The DX12 Shift: Modern titles like Cyberpunk 2077 and The Last of Us are strictly DX12, rendering traditional DX11 hooks obsolete.
Core Objective: To identify the technical barriers preventing a direct port and evaluate the feasibility of a "3DMigoto-DX12" framework. III. The Architectural Hurdle: DX11 vs. DX12
Implicit vs. Explicit Control: DX11 (Implicit) handles resource tracking and synchronization automatically. DX12 (Explicit) shifts this burden to the developer (or the mod framework), making "universal" injection significantly more complex.
Shader Interception: 3DMigoto relies on hooking the D3D11 device to intercept shaders. In DX12, the introduction of Pipeline State Objects (PSOs) requires a complete overhaul of how shaders are identified and replaced.
Command Queues and Asynchrony: Managing the asynchronous nature of DX12 without causing game-breaking race conditions or performance drops. IV. Current Workarounds and Substitutes Dump: You trigger a keybind in-game (often via Overlay)
Time for DX12 support? · Issue #141 · bo3b/3Dmigoto - GitHub
3. The Workflow: Dump, Edit, Inject
The workflow for DX12 modding remains similar to the classic method, though the tools under the hood are vastly different:
- Dump: You trigger a keybind in-game (often via Overlay). 3DMigoto intercepts the current frame and saves the raw VB (Vertex Buffer) and IB (Index Buffer) files.
- Edit: You import these raw files into Blender (using specialized plugins) to sculpt, reshape, or paint textures.
- Inject: You place the modified files into the game’s mod folder. 3DMigoto recognizes the hash of the original object and seamlessly swaps it for your custom creation.
What is 3DMigoto DX12?
It’s a wrapper/injection tool that hooks into a game’s DX12 rendering pipeline. Once active, it can:
- Dump shaders (Vertex, Pixel, Compute, etc.) to editable text files.
- Replace shaders or textures at runtime.
- Disable specific rendering features (e.g., bloom, depth of field, TAA).
- Extract 3D geometry for use in other software (Blender, etc.).
- Debug rendering issues or create visual enhancements/fixes.
Tools and references to consult
- Microsoft DX12 Debug Layers and GPU validation (for catching API and state errors).
- RenderDoc and PIX (captures, shader inspection, draw call analysis).
- DirectX Shader Compiler (DXC) and dxil-dis tools for DXIL inspection.
- Community repositories and forks: search for DX12 hooking examples and projects for up-to-date techniques (these evolve quickly).
How to Set Up 3DMigoto DX12 for Modern Games
Using the DX12 version is similar to the classic, but with new caveats. Here is a step-by-step guide for developers and advanced users.
Prerequisites:
- Windows 10/11 (Version 2004 or later)
- A game that uses DX12 exclusively (Not DX11 with a DX12 wrapper).
- Visual C++ Redistributable 2022
Step 1: Download the Correct Build
Do not use the classic 3DMigoto 1.3.x. You need the experimental DX12 branch. Look for releases tagged with dx12 or experimental on the official GitHub repositories (e.g., 3DMigoto-DX12 by current maintainers).
Step 2: Extract to Game Directory
Extract the d3d12.dll and the Mods folder into the same directory as the game's executable (.exe). Warning: Some anti-cheat systems (EAC, BattlEye) flag manual DX12 DLLs. Only use this for offline, single-player games.
Step 3: Configuration Editing
Open d3dx.ini in the Mods folder. You will notice new parameters:
allow_async = 1(Critical for performance in DX12)cache_psos = 1(Speeds up subsequent loads)hunting = 1(To capture shaders)
Step 4: The "Frame Analysis" Shift
In DX11, you pressed NumPad 0 to dump. In DX12, due to PSO caching, you may need to trigger dumps across multiple loading screens. Use the F8 key to dump all currently loaded PSOs.
4. Configuration (3dmigoto.ini)
Key settings for DX12:
[System] ; DX12 mode must be enabled dx12 = 1; Enable logging for debugging (disable when done) log_level = 3
[StealD3D12] ; Toggle overlay key (default = F1) toggle_key = VK_F1
; Dump shaders on startup (for modders) dump_shaders = 0
; Hunting mode – use F8 to find draw calls hunting = 0
- Key bindings (DX12 Lite common defaults):
F1– toggle mod on/offF8– hunting mode (cycle through draw calls)NumPad0– disable shaderNumPad1– disable pixel shaderNumPad2– disable vertex shader
These can change per release – check included
d3dx.ini.
The Future: Is Vulkan Next?
The community successfully ported the hooking technique to DX12, but the same logic is now being tested for Vulkan. While 3DMigoto DX12 is stable for titles up to 2024, the holy grail is a unified tool that handles DX12, Vulkan, and eventually DirectX 13 (DirectSR).
For now, 3DMigoto DX12 remains the only reliable way to perform per-shader manipulation on modern AAA titles. It bridges the gap between legacy modding comforts and the raw performance of modern APIs.
2. Descriptor Heap Interception (The "Shackle" Method)
DX12’s descriptor heaps are opaque tables. To replace a texture, 3DMigoto must modify the heap entry that the shader reads.
3DMigoto hooks ID3D12Device::CreateShaderResourceView and CopyDescriptors. It maintains a shadow mapping of: What is 3DMigoto DX12
- Original GPU descriptor handle → Original resource
- Replacement GPU descriptor handle → Replacement resource
When a draw call is about to execute, 3DMigoto walks the bound descriptor heap, finds any handles marked for replacement, and atomically overwrites the heap entry just before the draw. After the draw, it restores the original entry.
The Risk: This breaks if the game uses dynamic indexing (MyTextureArray[randomIndex]). 3DMigoto DX12 cannot safely replace textures accessed via computed indices.
How it works (technical summary)
- DLL injection: A proxy/driver DLL is loaded into a game's process and intercepts DX12 device/command-queue/command-list related calls.
- API interception: The tool wraps/overrides key Direct3D 12 interfaces and function pointers, letting it intercept draw calls, pipeline state objects (PSOs), root signatures, resource creation, and descriptor table updates.
- Shader interception: When pipeline state objects are created, 3Dmigoto inspects shader bytecode (DXIL) and can substitute alternate compiled shader blobs from disk.
- Render duplication: To produce stereoscopic output, the tool can execute additional draw calls or rebind render targets with modified projection/view matrices, producing a second view and compositing the results.
- Resource tracking: It monitors and maps resources like depth buffers and render targets so shader mods can read or write them reliably.