Video backends

Graphics rendering architecture supporting Vulkan, Direct3D, OpenGL, Metal, and Software rendering

Dolphin translates GameCube/Wii graphics commands to modern graphics APIs through multiple video backends.

Available Backends

Location: Source/Core/VideoBackends/

Vulkan

Cross-platform, best performance

Platforms: Windows, Linux, Android

Direct3D 12

Modern Windows API

Platforms: Windows 10+

Direct3D 11

Legacy Windows support

Platforms: Windows 7+

OpenGL

Wide compatibility

Platforms: Windows, Linux, macOS

Metal

Apple native API

Platforms: macOS 11+, iOS

Software

CPU-based reference renderer

Platforms: All (debugging only)

Backend Selection

Choose backend in configuration:

[Core]
GFXBackend = Vulkan  # or D3D12, D3D11, OGL, Metal, Software, Null

Command line:

dolphin-emu --video_backend=Vulkan --exec=game.iso

Graphics Pipeline

All backends implement the same pipeline:

1. Command Processing

   Read graphics FIFO from GPU memory

   Location: VideoCommon/CommandProcessor.cpp

   • Process draw commands from CPU
   • Parse vertex data and state changes
   • Handle display lists
2. Geometry Processing

   Transform and setup vertices

   Location: VideoCommon/VertexManagerBase.cpp

   • Run vertex shaders (XF emulation)
   • Apply projection matrices
   • Clip and cull primitives
3. Texture Decoding

   Convert GC/Wii texture formats

   Location: VideoCommon/TextureCacheBase.cpp

   • Decode native formats (RGBA8, RGB565, I4, IA8, etc.)
   • Hash textures for cache lookup
   • Apply arbitrary mipmaps
4. Shader Generation

   Generate pixel shaders for TEV

   Location: VideoCommon/PixelShaderGen.cpp

   • Emulate Texture Environment (TEV) unit
   • Combine up to 16 stages
   • Output GLSL/HLSL/MSL shader code
5. Rasterization

   Draw to render target

   • Execute shaders via backend API
   • Apply blending and Z-testing
   • Output to EFB (Embedded FrameBuffer)
6. Post-Processing

   Apply enhancements and effects

   • Resolve MSAA
   • Apply post-process shaders
   • Copy EFB to XFB or texture

Vulkan Backend

Location: VideoBackends/Vulkan/

Recommended backend with best features:

Features

• Async shader compilation (minimal stutter)
• Pipeline caching (fast startup)
• Optimal descriptor management
• Efficient multithreading
• Exclusive fullscreen

Requirements

• Vulkan 1.1+ drivers
• VK_EXT_memory_budget for VRAM tracking
• VK_KHR_push_descriptor for performance

Pipeline State

Vulkan backend caches pipeline state objects:

// Simplified pipeline creation
VkPipelineCache pipeline_cache;
VkPipeline CreatePipeline(const RasterizationState& rs,
                          const DepthState& ds,
                          const BlendingState& bs,
                          VkPipelineLayout layout,
                          VkShaderModule vs,
                          VkShaderModule ps);

Pipelines are pre-compiled and cached to disk.

Direct3D 12 Backend

Location: VideoBackends/D3D12/

Modern Windows backend:

Features

• Explicit multithreading
• GPU timeline synchronization
• Descriptor heap management
• Root signature optimization

Requirements

• Windows 10 version 1903+
• D3D12 feature level 11_0+
• DirectX 12 capable GPU

Direct3D 11 Backend

Location: VideoBackends/D3D/

Legacy Windows support:

Features

• Broad hardware compatibility
• Mature and stable
• Good performance on older GPUs

Limitations

• Single-threaded API
• Potential shader stutter
• No async compilation

OpenGL Backend

Location: VideoBackends/OGL/

Cross-platform fallback:

Features

• Works on most systems
• Desktop OpenGL 3.3+ or OpenGL ES 3.0+
• DSA (Direct State Access) for efficiency

Limitations

• Driver quality varies widely
• Potential stutter on driver pipeline compilation
• Limited async compilation support

OpenGL driver quality varies significantly. Prefer Vulkan when available.

Metal Backend

Location: VideoBackends/Metal/

Apple platforms:

Features

• Native macOS/iOS performance
• Optimized for Apple Silicon
• MoltenVK-free implementation

Requirements

• macOS 11.0 (Big Sur) or later
• Metal 2.3+ support

Software Renderer

Location: VideoBackends/Software/

CPU-based reference implementation:

Use Cases

• Debugging graphics issues
• Verifying hardware backend correctness
• Pixel-perfect accuracy testing

Limitations

• Extremely slow (< 10 FPS typically)
• No enhancements
• Single-threaded

# Use software renderer
dolphin-emu --video_backend=Software --exec=game.iso

Shared Video Code

Location: Source/Core/VideoCommon/

Shared across all backends:

Component	Purpose
TextureCacheBase	Texture decoding and caching
VertexManagerBase	Vertex buffer management
PixelShaderGen	Pixel shader generation
VertexShaderGen	Vertex shader generation
ShaderCache	Compiled shader storage
RenderBase	Abstract rendering interface
FramebufferManager	EFB/XFB management

Texture Cache

Central texture management:

// Texture cache lookup
TCacheEntry* GetTexture(u32 address, u32 width, u32 height, 
                        TextureFormat format, u32 tlut_addr);

Cache Strategy

• Hash-based lookup by memory address + format
• LRU eviction when VRAM is full
• Lazy invalidation on RAM writes
• Supports arbitrary mipmaps
• Handles EFB copies (render-to-texture)

Texture Formats

GameCube/Wii formats decoded to RGBA8:

• I4/I8: Intensity (grayscale)
• IA4/IA8: Intensity + Alpha
• RGB565/RGB5A3: Color formats
• RGBA8: Full color + alpha
• CMPR: DXT1-like compression
• C4/C8/C14X2: Palette-based (TLUT)

Shader Generation

Generate shaders for TEV (Texture Environment Unit):

// Generate pixel shader code
ShaderCode GeneratePixelShaderCode(const PixelShaderUid& uid);

TEV configuration determines shader:

• Up to 16 TEV stages
• Each stage: 2 color inputs, 1 alpha input
• Operations: add, sub, multiply, blend, compare
• Konstant colors and rasterized colors

Example TEV setup → generated shader:

// TEV: Stage0 = Tex0 * RasColor  
// Generated GLSL:
vec4 tex0 = texture(samp0, uv0);
vec4 ras = RasColor;
vec4 prev = tex0 * ras;

Graphics Enhancements

Backends support quality improvements:

Internal Resolution

Render at higher resolution than native (640x528):

• 1x (native), 2x, 3x, 4x, 5x, 6x, 7x, 8x
• Dramatically improves clarity
• GPU-intensive

Anti-Aliasing

• MSAA: 2x, 4x, 8x multisample
• SSAA: 4x supersampling (highest quality, slowest)

Anisotropic Filtering

• 1x (off), 2x, 4x, 8x, 16x
• Improves texture clarity at angles

Post-Processing

Shader-based effects:

• Color correction
• Scanlines
• Edge smoothing (AA shaders)
• Custom shaders in User/Shaders/

Performance Profiling

Built-in metrics:

[General]
ShowSpeedPercent = True  # Show FPS and speed %

[GFX]  
ShowStatistics = True    # Show draw calls, textures

Key metrics:

• Draw calls: Primitives submitted to GPU
• Shader compilations: New shaders generated
• Texture uploads: New textures sent to VRAM
• EFB peeks: CPU reads from framebuffer (slow)

See Also

• Graphics Settings Guide
• Graphics Mods
• Custom Pipelines