A Native DirectX 12 Backend for a Reusable C++ Engine
DirectX 12 Engine Backend is an in-development rendering backend built on top of EngineInterface, providing a native DirectX 12 implementation of the engine abstraction layer. Rather than coupling applications directly to the DirectX API, the backend implements the reusable interfaces defined by the engine architecture, allowing applications to remain independent of the underlying graphics technology.
The project is being developed as a second backend alongside the SFML Engine Backend, initially targeting a complete 2D rendering pipeline before expanding into a fully featured 3D rendering backend. Its goal is to demonstrate how multiple rendering technologies can coexist beneath a common interface without requiring changes to application or gameplay code.
The Engineering Problem
Supporting multiple rendering technologies often results in duplicated application code or engine systems becoming tightly coupled to a single graphics API. Modern APIs such as DirectX 12 also introduce significantly greater complexity through explicit resource management, command queues, descriptor heaps and pipeline state configuration.
The challenge is to provide a native DirectX 12 implementation that satisfies the Engine Interface contracts while preserving the backend-agnostic architecture established by the wider engine. This enables applications to target different rendering backends without sacrificing maintainability, modularity or long-term extensibility.
My Role
I designed and am implementing the DirectX 12 backend, developing the platform layer, Win32 window management, DirectX 12 device initialisation and backend integration required to support the Engine Interface. The project establishes the foundation for a reusable rendering backend, with development currently focused on completing the 2D rendering systems before extending the architecture to support 3D rendering capabilities.
Architecture Overview
The DirectX 12 Engine Backend forms one implementation of the Engine Interface, providing concrete rendering, windowing and platform services through Microsoft’s DirectX 12 graphics API.
Applications continue to communicate exclusively through the engine interfaces, while the backend translates those abstract requests into DirectX 12 commands. This separation allows additional backends to coexist while keeping higher-level engine systems and applications independent of the underlying graphics implementation.
Core Framework
The backend is being developed in focused layers that progressively build a complete rendering implementation while maintaining compatibility with the reusable engine architecture.
Platform and Initialisation
Implements the Win32 platform layer together with DirectX 12 device creation, swap chain management, command queues and the graphics infrastructure required to establish a reusable rendering backend. As well as initialises the window for DirectX.
Rendering Infrastructure
Develops the core rendering architecture, including command lists, descriptor heaps, resource management and graphics pipeline configuration that underpin the rendering systems while remaining abstracted behind the Engine Interface.
2D & 3D Roadmap
Current development will be focused on delivering a complete 2D rendering pipeline as with SFML backend before expanding the backend to support cameras, meshes, materials, lighting and other reusable 3D rendering systems through the same architectural foundation.
Together, these systems provide the foundation for a modern graphics backend capable of supporting increasingly advanced rendering features without altering application-level code.
Engineering Principles
| Principle | Application |
| Interface-Driven Development | Implements the contracts defined by Engine Interface, allowing applications to remain independent of DirectX 12. |
| Backend Abstraction | Encapsulates DirectX 12 behind reusable engine interfaces so multiple rendering backends can coexist. |
| Layered Architecture | Separates platform services, rendering infrastructure and engine integration into focused architectural layers. |
| Separation of Concerns | Keeps rendering, window management, resource handling and application logic isolated within dedicated systems. |
| Object-Oriented Design | Organises backend components into reusable classes with clearly defined responsibilities. |
| Explicit Resource Management | Encapsulates DirectX 12 command queues, descriptor heaps, resource lifetimes and synchronisation within the backend implementation. |
| Incremental Architecture | Develops the backend in stages, progressing from platform initialisation to 2D rendering before expanding into 3D capabilities. |
| Reusable Engine Integration | Provides a drop-in backend implementation that can be used by any application targeting the Engine Interface. |
| Scalable System Design | Establishes a foundation that supports future rendering features without requiring changes to higher-level engine or application code. |
| Modern Graphics Programming | Applies contemporary graphics API concepts including explicit pipelines, GPU resource management and command recording while maintaining architectural abstraction. |
Key Design Decisions
Backend-Agnostic Integration
The backend implements the Engine Interface contracts, allowing applications to utilise DirectX 12 without introducing API-specific dependencies into gameplay or engine code.
Layered Development Strategy
The backend is being developed incrementally, beginning with platform initialisation and core rendering infrastructure before introducing higher-level 2D and 3D rendering capabilities.
Explicit Resource Management
DirectX 12’s explicit command submission and resource management model is encapsulated within dedicated backend systems, preventing low-level graphics concerns from propagating throughout the wider architecture.
Long-Term Extensibility
The architecture is designed to evolve beyond its initial 2D implementation, providing a scalable foundation capable of supporting more advanced rendering techniques and future engine features.
Technologies
Development
C++ 20
Visual Studio 2022
Git
Git Submodules
DirectX12
Win32 API
Engineering Approach
Interface-Driven Architecture
RAII
Dependency Inversion
Backend Abstraction
Resource encapsulation
Modular Architecture
Layered Architecture
Contract-Based Design
Separation of Concerns
Modern Graphics Programming
Explicit Resource Management
Engineering Outcome
The DirectX 12 Engine Backend extends the reusable engine architecture with a native modern graphics implementation while preserving backend independence through Engine Interface. Although still under development, the project establishes the foundations for a scalable rendering backend that will support both 2D and 3D applications, demonstrating how multiple graphics APIs can coexist beneath a common architectural framework.
Repository
Explore the source code to see how the DirectX 12 backend implements platform initialisation, graphics infrastructure and the reusable engine interfaces that will support future 2D and 3D rendering systems.
