| // ImGui - standalone example application for DirectX 11 |
| // If you are new to ImGui, see examples/README.txt and documentation at the top of imgui.cpp. |
| |
| #include <imgui.h> |
| #include "imgui_impl_dx12.h" |
| #include <d3d12.h> |
| #include <dxgi1_4.h> |
| #include <tchar.h> |
| |
| #define D3D11_CREATE_DEVICE_DEBUG 2 |
| |
| struct FrameContext |
| { |
| ID3D12CommandAllocator* CommandAllocator; |
| UINT64 FenceValue; |
| bool FenceSignalled; |
| }; |
| |
| // Data |
| static int const NUM_FRAMES_IN_FLIGHT = 3; |
| static FrameContext g_frameContext[NUM_FRAMES_IN_FLIGHT] = {}; |
| static UINT g_frameIndex = 0; |
| |
| static int const NUM_BACK_BUFFERS = 3; |
| static ID3D12Device* g_pd3dDevice = NULL; |
| static ID3D12DescriptorHeap* g_pd3dRtvDescHeap = NULL; |
| static ID3D12DescriptorHeap* g_pd3dSrvDescHeap = NULL; |
| static ID3D12CommandQueue* g_pd3dCommandQueue = NULL; |
| static ID3D12GraphicsCommandList* g_pd3dCommandList = NULL; |
| static ID3D12Fence* g_fence = NULL; |
| static HANDLE g_fenceEvent = NULL; |
| static UINT64 g_fenceLastSignalledValue = 0; |
| static IDXGISwapChain3* g_pSwapChain = NULL; |
| static HANDLE g_hSwapChainWaitableObject = NULL; |
| static ID3D12Resource* g_mainRenderTargetResource[NUM_BACK_BUFFERS] = {}; |
| static D3D12_CPU_DESCRIPTOR_HANDLE g_mainRenderTargetDescriptor[NUM_BACK_BUFFERS] = {}; |
| |
| void CreateRenderTarget() |
| { |
| DXGI_SWAP_CHAIN_DESC sd; |
| g_pSwapChain->GetDesc(&sd); |
| |
| // Create the render target |
| ID3D12Resource* pBackBuffer; |
| D3D12_RENDER_TARGET_VIEW_DESC render_target_view_desc; |
| ZeroMemory(&render_target_view_desc, sizeof(render_target_view_desc)); |
| render_target_view_desc.Format = sd.BufferDesc.Format; |
| render_target_view_desc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2D; |
| for (UINT i = 0; i < NUM_BACK_BUFFERS; ++i) |
| { |
| g_pSwapChain->GetBuffer(i, IID_PPV_ARGS(&pBackBuffer)); |
| g_pd3dDevice->CreateRenderTargetView(pBackBuffer, &render_target_view_desc, g_mainRenderTargetDescriptor[i]); |
| g_mainRenderTargetResource[i] = pBackBuffer; |
| } |
| } |
| |
| void WaitForLastSubmittedFrame() |
| { |
| FrameContext* frameCtxt = &g_frameContext[g_frameIndex % NUM_FRAMES_IN_FLIGHT]; |
| |
| UINT64 fenceValue = frameCtxt->FenceValue; |
| if (fenceValue == 0) |
| return; // no fence was signalled |
| |
| frameCtxt->FenceValue = 0; |
| if (g_fence->GetCompletedValue() >= fenceValue) |
| return; |
| |
| g_fence->SetEventOnCompletion(fenceValue, g_fenceEvent); |
| WaitForSingleObject(g_fenceEvent, INFINITE); |
| } |
| |
| FrameContext* WaitForNextFrameResources() |
| { |
| UINT nextFrameIndex = g_frameIndex + 1; |
| g_frameIndex = nextFrameIndex; |
| |
| HANDLE waitableObjects[] = { |
| g_hSwapChainWaitableObject, |
| NULL, |
| }; |
| DWORD numWaitableObjects = 1; |
| |
| FrameContext* frameCtxt = &g_frameContext[nextFrameIndex % NUM_FRAMES_IN_FLIGHT]; |
| UINT64 fenceValue = frameCtxt->FenceValue; |
| if (fenceValue != 0) // means no fence was signalled |
| { |
| frameCtxt->FenceValue = 0; |
| g_fence->SetEventOnCompletion(fenceValue, g_fenceEvent); |
| waitableObjects[1] = g_fenceEvent; |
| numWaitableObjects = 2; |
| } |
| |
| WaitForMultipleObjects(numWaitableObjects, waitableObjects, TRUE, INFINITE); |
| |
| return frameCtxt; |
| } |
| |
| void ResizeSwapChain(HWND hWnd, int width, int height) |
| { |
| DXGI_SWAP_CHAIN_DESC1 sd; |
| g_pSwapChain->GetDesc1(&sd); |
| sd.Width = width; |
| sd.Height = height; |
| |
| IDXGIFactory4* dxgiFactory = nullptr; |
| g_pSwapChain->GetParent(IID_PPV_ARGS(&dxgiFactory)); |
| |
| g_pSwapChain->Release(); |
| CloseHandle(g_hSwapChainWaitableObject); |
| |
| IDXGISwapChain1* swapChain1 = NULL; |
| dxgiFactory->CreateSwapChainForHwnd(g_pd3dCommandQueue, hWnd, &sd, NULL, NULL, &swapChain1); |
| swapChain1->QueryInterface(IID_PPV_ARGS(&g_pSwapChain)); |
| swapChain1->Release(); |
| dxgiFactory->Release(); |
| |
| g_pSwapChain->SetMaximumFrameLatency(NUM_BACK_BUFFERS); |
| |
| g_hSwapChainWaitableObject = g_pSwapChain->GetFrameLatencyWaitableObject(); |
| assert(g_hSwapChainWaitableObject != NULL); |
| } |
| |
| void CleanupRenderTarget() |
| { |
| WaitForLastSubmittedFrame(); |
| |
| for (UINT i = 0; i < NUM_BACK_BUFFERS; ++i) |
| if (g_mainRenderTargetResource[i]) { g_mainRenderTargetResource[i]->Release(); g_mainRenderTargetResource[i] = NULL; } |
| } |
| |
| HRESULT CreateDeviceD3D(HWND hWnd) |
| { |
| // Setup swap chain |
| DXGI_SWAP_CHAIN_DESC1 sd; |
| { |
| ZeroMemory(&sd, sizeof(sd)); |
| sd.BufferCount = NUM_BACK_BUFFERS; |
| sd.Width = 0; |
| sd.Height = 0; |
| sd.Format = DXGI_FORMAT_R8G8B8A8_UNORM; |
| sd.Flags = DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT; |
| sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; |
| sd.SampleDesc.Count = 1; |
| sd.SampleDesc.Quality = 0; |
| sd.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD; |
| sd.AlphaMode = DXGI_ALPHA_MODE_UNSPECIFIED; |
| sd.Scaling = DXGI_SCALING_STRETCH; |
| sd.Stereo = FALSE; |
| } |
| |
| UINT createDeviceFlags = 0; |
| //createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG; |
| D3D_FEATURE_LEVEL featureLevel; |
| featureLevel = D3D_FEATURE_LEVEL_11_0; |
| if (createDeviceFlags & D3D11_CREATE_DEVICE_DEBUG) |
| { |
| ID3D12Debug* dx12Debug = NULL; |
| if (SUCCEEDED(D3D12GetDebugInterface(IID_PPV_ARGS(&dx12Debug)))) |
| { |
| dx12Debug->EnableDebugLayer(); |
| dx12Debug->Release(); |
| } |
| } |
| if (D3D12CreateDevice(NULL, featureLevel, IID_PPV_ARGS(&g_pd3dDevice)) != S_OK) |
| return E_FAIL; |
| |
| { |
| D3D12_DESCRIPTOR_HEAP_DESC desc = {}; |
| desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV; |
| desc.NumDescriptors = NUM_BACK_BUFFERS; |
| desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE; |
| desc.NodeMask = 1; |
| if (g_pd3dDevice->CreateDescriptorHeap(&desc, IID_PPV_ARGS(&g_pd3dRtvDescHeap)) != S_OK) |
| return E_FAIL; |
| |
| SIZE_T rtvDescriptorSize = g_pd3dDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV); |
| D3D12_CPU_DESCRIPTOR_HANDLE rtvHandle = g_pd3dRtvDescHeap->GetCPUDescriptorHandleForHeapStart(); |
| for (UINT i = 0; i < NUM_BACK_BUFFERS; ++i) { |
| g_mainRenderTargetDescriptor[i] = rtvHandle; |
| rtvHandle.ptr += rtvDescriptorSize; |
| } |
| } |
| |
| { |
| D3D12_DESCRIPTOR_HEAP_DESC desc = {}; |
| desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV; |
| desc.NumDescriptors = 1; |
| desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE; |
| if (g_pd3dDevice->CreateDescriptorHeap(&desc, IID_PPV_ARGS(&g_pd3dSrvDescHeap)) != S_OK) |
| return E_FAIL; |
| } |
| |
| { |
| D3D12_COMMAND_QUEUE_DESC desc = {}; |
| desc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT; |
| desc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE; |
| desc.NodeMask = 1; |
| if (g_pd3dDevice->CreateCommandQueue(&desc, IID_PPV_ARGS(&g_pd3dCommandQueue)) != S_OK) |
| return E_FAIL; |
| } |
| |
| for (UINT i = 0; i < NUM_FRAMES_IN_FLIGHT; ++i) |
| { |
| if (g_pd3dDevice->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&g_frameContext[i].CommandAllocator)) != S_OK) |
| return E_FAIL; |
| } |
| |
| if (g_pd3dDevice->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, g_frameContext[0].CommandAllocator, NULL, IID_PPV_ARGS(&g_pd3dCommandList)) != S_OK || |
| g_pd3dCommandList->Close() != S_OK) |
| return E_FAIL; |
| |
| if (g_pd3dDevice->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&g_fence)) != S_OK) |
| return E_FAIL; |
| |
| g_fenceEvent = CreateEvent(NULL, FALSE, FALSE, NULL); |
| if (g_fenceEvent == NULL) |
| return E_FAIL; |
| |
| { |
| IDXGIFactory4* dxgiFactory = NULL; |
| IDXGISwapChain1* swapChain1 = NULL; |
| if (CreateDXGIFactory1(IID_PPV_ARGS(&dxgiFactory)) != S_OK || |
| dxgiFactory->CreateSwapChainForHwnd(g_pd3dCommandQueue, hWnd, &sd, NULL, NULL, &swapChain1) != S_OK || |
| swapChain1->QueryInterface(IID_PPV_ARGS(&g_pSwapChain)) != S_OK) |
| return E_FAIL; |
| swapChain1->Release(); |
| dxgiFactory->Release(); |
| g_pSwapChain->SetMaximumFrameLatency(NUM_BACK_BUFFERS); |
| g_hSwapChainWaitableObject = g_pSwapChain->GetFrameLatencyWaitableObject(); |
| } |
| |
| CreateRenderTarget(); |
| |
| return S_OK; |
| } |
| |
| void CleanupDeviceD3D() |
| { |
| CleanupRenderTarget(); |
| if (g_pSwapChain) { g_pSwapChain->Release(); g_pSwapChain = NULL; } |
| if (g_hSwapChainWaitableObject != NULL) { CloseHandle(g_hSwapChainWaitableObject); } |
| for (UINT i = 0; i < NUM_FRAMES_IN_FLIGHT; ++i) |
| if (g_frameContext[i].CommandAllocator) { g_frameContext[i].CommandAllocator->Release(); g_frameContext[i].CommandAllocator = NULL; } |
| if (g_pd3dCommandQueue) { g_pd3dCommandQueue->Release(); g_pd3dCommandQueue = NULL; } |
| if (g_pd3dCommandList) { g_pd3dCommandList->Release(); g_pd3dCommandList = NULL; } |
| if (g_pd3dRtvDescHeap) { g_pd3dRtvDescHeap->Release(); g_pd3dRtvDescHeap = NULL; } |
| if (g_pd3dSrvDescHeap) { g_pd3dSrvDescHeap->Release(); g_pd3dSrvDescHeap = NULL; } |
| if (g_fence) { g_fence->Release(); g_fence = NULL; } |
| if (g_fenceEvent) { CloseHandle(g_fenceEvent); g_fenceEvent = NULL; } |
| if (g_pd3dDevice) { g_pd3dDevice->Release(); g_pd3dDevice = NULL; } |
| } |
| |
| extern LRESULT ImGui_ImplDX12_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam); |
| LRESULT WINAPI WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) |
| { |
| if (ImGui_ImplDX12_WndProcHandler(hWnd, msg, wParam, lParam)) |
| return true; |
| |
| switch (msg) |
| { |
| case WM_SIZE: |
| if (g_pd3dDevice != NULL && wParam != SIZE_MINIMIZED) |
| { |
| ImGui_ImplDX12_InvalidateDeviceObjects(); |
| CleanupRenderTarget(); |
| ResizeSwapChain(hWnd, (UINT)LOWORD(lParam), (UINT)HIWORD(lParam)); |
| CreateRenderTarget(); |
| ImGui_ImplDX12_CreateDeviceObjects(); |
| } |
| return 0; |
| case WM_SYSCOMMAND: |
| if ((wParam & 0xfff0) == SC_KEYMENU) // Disable ALT application menu |
| return 0; |
| break; |
| case WM_DESTROY: |
| PostQuitMessage(0); |
| return 0; |
| } |
| return DefWindowProc(hWnd, msg, wParam, lParam); |
| } |
| |
| int main(int, char**) |
| { |
| // Create application window |
| WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, WndProc, 0L, 0L, GetModuleHandle(NULL), NULL, LoadCursor(NULL, IDC_ARROW), NULL, NULL, _T("ImGui Example"), NULL }; |
| RegisterClassEx(&wc); |
| HWND hwnd = CreateWindow(_T("ImGui Example"), _T("ImGui DirectX12 Example"), WS_OVERLAPPEDWINDOW, 100, 100, 1280, 800, NULL, NULL, wc.hInstance, NULL); |
| |
| // Initialize Direct3D |
| if (CreateDeviceD3D(hwnd) < 0) |
| { |
| CleanupDeviceD3D(); |
| UnregisterClass(_T("ImGui Example"), wc.hInstance); |
| return 1; |
| } |
| |
| // Show the window |
| ShowWindow(hwnd, SW_SHOWDEFAULT); |
| UpdateWindow(hwnd); |
| |
| // Setup ImGui binding |
| ImGui_ImplDX12_Init(hwnd, NUM_FRAMES_IN_FLIGHT, g_pd3dDevice, |
| DXGI_FORMAT_R8G8B8A8_UNORM, |
| g_pd3dSrvDescHeap->GetCPUDescriptorHandleForHeapStart(), |
| g_pd3dSrvDescHeap->GetGPUDescriptorHandleForHeapStart()); |
| |
| // Load Fonts |
| // (there is a default font, this is only if you want to change it. see extra_fonts/README.txt for more details) |
| //ImGuiIO& io = ImGui::GetIO(); |
| //io.Fonts->AddFontDefault(); |
| //io.Fonts->AddFontFromFileTTF("../../extra_fonts/Cousine-Regular.ttf", 15.0f); |
| //io.Fonts->AddFontFromFileTTF("../../extra_fonts/DroidSans.ttf", 16.0f); |
| //io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyClean.ttf", 13.0f); |
| //io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyTiny.ttf", 10.0f); |
| //io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, NULL, io.Fonts->GetGlyphRangesJapanese()); |
| |
| bool show_test_window = true; |
| bool show_another_window = false; |
| ImVec4 clear_col = ImColor(114, 144, 154); |
| |
| // Main loop |
| MSG msg; |
| ZeroMemory(&msg, sizeof(msg)); |
| while (msg.message != WM_QUIT) |
| { |
| if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE)) |
| { |
| TranslateMessage(&msg); |
| DispatchMessage(&msg); |
| continue; |
| } |
| ImGui_ImplDX12_NewFrame(g_pd3dCommandList); |
| |
| // 1. Show a simple window |
| // Tip: if we don't call ImGui::Begin()/ImGui::End() the widgets appears in a window automatically called "Debug" |
| { |
| static float f = 0.0f; |
| ImGui::Text("Hello, world!"); |
| ImGui::SliderFloat("float", &f, 0.0f, 1.0f); |
| ImGui::ColorEdit3("clear color", (float*)&clear_col); |
| if (ImGui::Button("Test Window")) show_test_window ^= 1; |
| if (ImGui::Button("Another Window")) show_another_window ^= 1; |
| ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate); |
| } |
| |
| // 2. Show another simple window, this time using an explicit Begin/End pair |
| if (show_another_window) |
| { |
| ImGui::Begin("Another Window", &show_another_window); |
| ImGui::Text("Hello from another window!"); |
| ImGui::End(); |
| } |
| |
| // 3. Show the ImGui test window. Most of the sample code is in ImGui::ShowTestWindow() |
| if (show_test_window) |
| { |
| ImGui::SetNextWindowPos(ImVec2(650, 20), ImGuiCond_FirstUseEver); // Normally user code doesn't need/want to call it because positions are saved in .ini file anyway. Here we just want to make the demo initial state a bit more friendly! |
| ImGui::ShowTestWindow(&show_test_window); |
| } |
| |
| // Rendering |
| FrameContext* frameCtxt = WaitForNextFrameResources(); |
| UINT backBufferIdx = g_pSwapChain->GetCurrentBackBufferIndex(); |
| frameCtxt->CommandAllocator->Reset(); |
| |
| D3D12_RESOURCE_BARRIER barrier = {}; |
| barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION; |
| barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE; |
| barrier.Transition.pResource = g_mainRenderTargetResource[backBufferIdx]; |
| barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES; |
| barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_PRESENT; |
| barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_RENDER_TARGET; |
| |
| g_pd3dCommandList->Reset(frameCtxt->CommandAllocator, NULL); |
| g_pd3dCommandList->ResourceBarrier(1, &barrier); |
| g_pd3dCommandList->ClearRenderTargetView(g_mainRenderTargetDescriptor[backBufferIdx], (float*)&clear_col, 0, NULL); |
| g_pd3dCommandList->OMSetRenderTargets(1, &g_mainRenderTargetDescriptor[backBufferIdx], FALSE, NULL); |
| g_pd3dCommandList->SetDescriptorHeaps(1, &g_pd3dSrvDescHeap); |
| ImGui::Render(); |
| barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_RENDER_TARGET; |
| barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_PRESENT; |
| g_pd3dCommandList->ResourceBarrier(1, &barrier); |
| g_pd3dCommandList->Close(); |
| |
| g_pd3dCommandQueue->ExecuteCommandLists(1, (ID3D12CommandList* const*) &g_pd3dCommandList); |
| |
| g_pSwapChain->Present(1, 0); // Present with vsync |
| //g_pSwapChain->Present(0, 0); // Present without vsync |
| |
| auto fenceValue = g_fenceLastSignalledValue + 1; |
| g_pd3dCommandQueue->Signal(g_fence, fenceValue); |
| g_fenceLastSignalledValue = fenceValue; |
| frameCtxt->FenceValue = fenceValue; |
| } |
| |
| ImGui_ImplDX12_Shutdown(); |
| CleanupDeviceD3D(); |
| UnregisterClass(_T("ImGui Example"), wc.hInstance); |
| |
| return 0; |
| } |
