MSDN Documentation

Getting Started with DirectX 12

This tutorial series will guide you through the fundamentals of DirectX 12 (DX12) programming. DX12 offers a lower-level API than its predecessors, providing greater control over the GPU and improved performance, especially for multi-threaded applications.

Prerequisites

• A strong understanding of C++ programming.
• Familiarity with graphics concepts (e.g., vertices, shaders, rendering pipeline).
• A Windows 10 or later system with a DirectX 12 compatible GPU.
• Visual Studio 2019 or later with the "Game development with C++" workload installed.

Setting Up Your Development Environment

Before you begin, ensure you have the necessary tools installed:

1. Install Visual Studio: Download and install Visual Studio from the official Microsoft website.
2. Install DirectX SDK (if needed): For modern Windows development, the DirectX components are often included with the Windows SDK, which is installed as part of the "Game development with C++" workload.
3. Create a New Project: In Visual Studio, create a new C++ project. A "Blank App (Universal Windows)" or a "DirectX 12 App (Universal Windows)" template can be a good starting point.

Key Concepts in DirectX 12

DX12 introduces several new concepts that differ from older DirectX versions:

• Command Lists and Command Queues: Instead of direct API calls to the GPU, you record commands into command lists, which are then submitted to command queues for execution. This allows for parallel recording and execution.
• Descriptor Heaps: These manage resources like textures, samplers, and constant buffers, providing a unified way to access them.
• Root Signatures: Define how shader resources are bound to the pipeline, offering more flexibility and performance optimization opportunities.
• Pipelines State Objects (PSOs): Encapsulate the entire graphics or compute pipeline state, reducing draw call overhead.
• Resource Binding: DX12 uses explicit resource binding, giving you more control over memory management and data transfer.

Step 1: Initializing DirectX 12

The first step in any DX12 application is to initialize the necessary components:

1. Create a DXGI Factory: Used to enumerate adapters and output devices.
2. Select an Adapter: Choose the appropriate GPU to use.
3. Create a Device: The central object for interacting with the GPU.
4. Create a Command Queue: To submit command lists for execution.

Here's a simplified C++ snippet demonstrating device creation:

#include <dxgi1_6.h>
#include <d3d12.h>

// ...

Microsoft::WRL::ComPtr<ID3D12Device> m_device;
Microsoft::WRL::ComPtr<IDXGIFactory4> m_dxgiFactory;
Microsoft::WRL::ComPtr<ID3D12CommandQueue> m_commandQueue;

// Enable debug layer if available
UINT dxgiFactoryFlags = 0;
#ifdef _DEBUG
    Microsoft::WRL::ComPtr<ID3D12Debug> debugController;
    if (SUCCEEDED(D3D12GetDebugInterface(IID_PPV_ARGS(&debugController))))
    {
        debugController->EnableDebugLayer();
        dxgiFactoryFlags |= DXGI_CREATE_FACTORY_DEBUG;
    }
#endif

// Create DXGI factory
ThrowIfFailed(CreateDXGIFactory2(dxgiFactoryFlags, IID_PPV_ARGS(&m_dxgiFactory)));

// Try to find a hardware adapter
Microsoft::WRL::ComPtr<IDXGIAdapter1> hardwareAdapter;
// ... (logic to find hardware adapter) ...

// Create device
ThrowIfFailed(D3D12CreateDevice(
    hardwareAdapter.Get(), // Use null for WARP driver
    D3D_FEATURE_LEVEL_11_0,
    IID_PPV_ARGS(&m_device)
));

// Create command queue
D3D12_COMMAND_QUEUE_DESC queueDesc = {};
queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
ThrowIfFailed(m_device->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&m_commandQueue)));
            

Next Steps

In the following tutorials, we will cover:

• Swap Chains and Presentation
• Command Lists and Execution
• Root Signatures and Shaders
• Pipeline State Objects
• Basic Rendering of a Triangle