2020-10-12 17:34:22 +02:00
// dear imgui: Renderer Backend for DirectX12
// This needs to be used along with a Platform Backend (e.g. Win32)
2018-02-22 22:18:59 +01:00
// Implemented features:
2019-10-16 11:23:15 +02:00
// [X] Renderer: User texture binding. Use 'D3D12_GPU_DESCRIPTOR_HANDLE' as ImTextureID. Read the FAQ about ImTextureID!
2023-02-07 12:24:42 +01:00
// [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
2024-10-07 22:12:09 +02:00
// [X] Renderer: Expose selected render state for draw callbacks to use. Access in '(ImGui_ImplXXXX_RenderState*)GetPlatformIO().Renderer_RenderState'.
2022-05-03 17:53:47 +02:00
// [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
2019-10-18 18:03:56 +02:00
// FIXME: The transition from removing a viewport and moving the window in an existing hosted viewport tends to flicker.
2020-09-08 20:02:28 +02:00
2024-11-15 16:03:58 +01:00
// The aim of imgui_impl_dx12.h/.cpp is to be usable in your engine without any modification.
// IF YOU FEEL YOU NEED TO MAKE ANY CHANGE TO THIS CODE, please share them and your feedback at https://github.com/ocornut/imgui/
2021-06-14 17:43:20 +02:00
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
2021-05-27 13:59:35 +02:00
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
2023-09-11 13:47:08 +02:00
// Learn about Dear ImGui:
// - FAQ https://dearimgui.com/faq
// - Getting Started https://dearimgui.com/getting-started
// - Documentation https://dearimgui.com/docs (same as your local docs/ folder).
// - Introduction, links and more at the top of imgui.cpp
2016-02-23 00:22:48 +01:00
2018-02-22 22:18:59 +01:00
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
2024-02-14 14:32:17 +01:00
// 2024-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
2024-11-15 19:02:26 +01:00
// 2024-11-15: DirectX12: *BREAKING CHANGE* Changed ImGui_ImplDX12_Init() signature to take a ImGui_ImplDX12_InitInfo struct. Legacy ImGui_ImplDX12_Init() signature is still supported (will obsolete).
// 2024-11-15: DirectX12: *BREAKING CHANGE* User is now required to pass function pointers to allocate/free SRV Descriptors. We provide convenience legacy fields to pass a single descriptor, matching the old API, but upcoming features will want multiple.
2024-10-23 12:40:20 +02:00
// 2024-10-23: DirectX12: Unmap() call specify written range. The range is informational and may be used by debug tools.
2024-10-07 22:02:55 +02:00
// 2024-10-07: DirectX12: Changed default texture sampler to Clamp instead of Repeat/Wrap.
2024-10-07 21:00:07 +02:00
// 2024-10-07: DirectX12: Expose selected render state in ImGui_ImplDX12_RenderState, which you can access in 'void* platform_io.Renderer_RenderState' during draw callbacks.
2024-10-14 19:13:04 +02:00
// 2024-10-07: DirectX12: Compiling with '#define ImTextureID=ImU64' is unnecessary now that dear imgui defaults ImTextureID to u64 instead of void*.
2022-10-11 12:22:29 +02:00
// 2022-10-11: Using 'nullptr' instead of 'NULL' as per our switch to C++11.
2021-06-28 16:52:10 +02:00
// 2021-06-29: Reorganized backend to pull data from a single structure to facilitate usage with multiple-contexts (all g_XXXX access changed to bd->XXXX).
2021-02-07 12:36:54 +01:00
// 2021-05-19: DirectX12: Replaced direct access to ImDrawCmd::TextureId with a call to ImDrawCmd::GetTexID(). (will become a requirement)
2021-02-17 19:29:07 +01:00
// 2021-02-18: DirectX12: Change blending equation to preserve alpha in output buffer.
2021-01-04 09:27:15 +01:00
// 2021-01-11: DirectX12: Improve Windows 7 compatibility (for D3D12On7) by loading d3d12.dll dynamically.
2020-09-17 09:33:48 +02:00
// 2020-09-16: DirectX12: Avoid rendering calls with zero-sized scissor rectangle since it generates a validation layer warning.
2020-09-08 20:02:28 +02:00
// 2020-09-08: DirectX12: Clarified support for building on 32-bit systems by redefining ImTextureID.
2019-10-18 18:32:48 +02:00
// 2019-10-18: DirectX12: *BREAKING CHANGE* Added extra ID3D12DescriptorHeap parameter to ImGui_ImplDX12_Init() function.
2019-05-29 16:29:17 +02:00
// 2019-05-29: DirectX12: Added support for large mesh (64K+ vertices), enable ImGuiBackendFlags_RendererHasVtxOffset flag.
2019-04-30 22:28:29 +02:00
// 2019-04-30: DirectX12: Added support for special ImDrawCallback_ResetRenderState callback to reset render state.
2019-03-29 16:18:26 +01:00
// 2019-03-29: Misc: Various minor tidying up.
2018-12-03 17:47:10 +01:00
// 2018-12-03: Misc: Added #pragma comment statement to automatically link with d3dcompiler.lib when using D3DCompile().
2018-11-30 18:18:15 +01:00
// 2018-11-30: Misc: Setting up io.BackendRendererName so it can be displayed in the About Window.
2018-06-21 12:13:04 +02:00
// 2018-06-12: DirectX12: Moved the ID3D12GraphicsCommandList* parameter from NewFrame() to RenderDrawData().
2018-06-08 19:37:33 +02:00
// 2018-06-08: Misc: Extracted imgui_impl_dx12.cpp/.h away from the old combined DX12+Win32 example.
// 2018-06-08: DirectX12: Use draw_data->DisplayPos and draw_data->DisplaySize to setup projection matrix and clipping rectangle (to ease support for future multi-viewport).
2018-02-22 22:18:59 +01:00
// 2018-02-22: Merged into master with all Win32 code synchronized to other examples.
# include "imgui.h"
2023-07-13 11:27:52 +02:00
# ifndef IMGUI_DISABLE
2016-02-23 00:22:48 +01:00
# include "imgui_impl_dx12.h"
// DirectX
# include <d3d12.h>
2018-02-27 23:32:30 +01:00
# include <dxgi1_4.h>
2016-02-23 00:22:48 +01:00
# include <d3dcompiler.h>
2018-12-03 17:47:10 +01:00
# ifdef _MSC_VER
# pragma comment(lib, "d3dcompiler") // Automatically link with d3dcompiler.lib as we are using D3DCompile() below.
# endif
2016-02-23 00:22:48 +01:00
2024-11-15 19:14:04 +01:00
// DirectX12 data
2023-02-07 12:24:42 +01:00
struct ImGui_ImplDX12_RenderBuffers ;
2024-11-15 19:14:04 +01:00
struct ImGui_ImplDX12_Texture
{
ID3D12Resource * pTextureResource ;
D3D12_CPU_DESCRIPTOR_HANDLE hFontSrvCpuDescHandle ;
D3D12_GPU_DESCRIPTOR_HANDLE hFontSrvGpuDescHandle ;
2024-11-21 14:48:23 +01:00
ImGui_ImplDX12_Texture ( ) { memset ( ( void * ) this , 0 , sizeof ( * this ) ) ; }
2024-11-15 19:14:04 +01:00
} ;
2021-06-28 16:52:10 +02:00
struct ImGui_ImplDX12_Data
{
2024-11-15 19:02:26 +01:00
ImGui_ImplDX12_InitInfo InitInfo ;
2021-06-28 16:52:10 +02:00
ID3D12Device * pd3dDevice ;
ID3D12RootSignature * pRootSignature ;
ID3D12PipelineState * pPipelineState ;
DXGI_FORMAT RTVFormat ;
2021-06-29 14:53:25 +02:00
ID3D12DescriptorHeap * pd3dSrvDescHeap ;
2021-06-28 16:52:10 +02:00
UINT numFramesInFlight ;
2024-11-18 15:16:41 +01:00
ImGui_ImplDX12_Texture FontTexture ;
bool LegacySingleDescriptorUsed ;
2021-06-28 16:52:10 +02:00
2022-03-23 17:21:34 +01:00
ImGui_ImplDX12_Data ( ) { memset ( ( void * ) this , 0 , sizeof ( * this ) ) ; }
2021-06-28 16:52:10 +02:00
} ;
2021-07-09 20:16:19 +02:00
// Backend data stored in io.BackendRendererUserData to allow support for multiple Dear ImGui contexts
// It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts.
static ImGui_ImplDX12_Data * ImGui_ImplDX12_GetBackendData ( )
{
2022-10-11 15:59:23 +02:00
return ImGui : : GetCurrentContext ( ) ? ( ImGui_ImplDX12_Data * ) ImGui : : GetIO ( ) . BackendRendererUserData : nullptr ;
2021-07-09 20:16:19 +02:00
}
2019-10-17 15:53:43 +02:00
2020-07-10 12:09:24 +02:00
// Buffers used during the rendering of a frame
2020-07-10 12:20:03 +02:00
struct ImGui_ImplDX12_RenderBuffers
2016-02-23 00:22:48 +01:00
{
2019-03-29 16:18:26 +01:00
ID3D12Resource * IndexBuffer ;
ID3D12Resource * VertexBuffer ;
int IndexBufferSize ;
int VertexBufferSize ;
2016-02-23 00:22:48 +01:00
} ;
2019-10-17 15:53:43 +02:00
2020-07-10 12:09:24 +02:00
// Buffers used for secondary viewports created by the multi-viewports systems
2020-07-10 12:20:03 +02:00
struct ImGui_ImplDX12_FrameContext
2019-10-17 15:53:43 +02:00
{
2020-07-10 12:20:03 +02:00
ID3D12CommandAllocator * CommandAllocator ;
ID3D12Resource * RenderTarget ;
D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetCpuDescriptors ;
2019-10-17 15:53:43 +02:00
} ;
2020-07-10 12:09:24 +02:00
// Helper structure we store in the void* RendererUserData field of each ImGuiViewport to easily retrieve our backend data.
2020-07-10 12:20:03 +02:00
// Main viewport created by application will only use the Resources field.
2020-10-14 14:43:45 +02:00
// Secondary viewports created by this backend will use all the fields (including Window fields),
2021-06-29 15:34:54 +02:00
struct ImGui_ImplDX12_ViewportData
2019-10-17 15:53:43 +02:00
{
2020-07-10 12:20:03 +02:00
// Window
ID3D12CommandQueue * CommandQueue ;
ID3D12GraphicsCommandList * CommandList ;
ID3D12DescriptorHeap * RtvDescHeap ;
IDXGISwapChain3 * SwapChain ;
ID3D12Fence * Fence ;
UINT64 FenceSignaledValue ;
HANDLE FenceEvent ;
2021-06-29 14:53:25 +02:00
UINT NumFramesInFlight ;
2020-07-10 12:20:03 +02:00
ImGui_ImplDX12_FrameContext * FrameCtx ;
// Render buffers
UINT FrameIndex ;
ImGui_ImplDX12_RenderBuffers * FrameRenderBuffers ;
2019-10-17 15:53:43 +02:00
2021-06-29 15:34:54 +02:00
ImGui_ImplDX12_ViewportData ( UINT num_frames_in_flight )
2019-10-17 15:53:43 +02:00
{
2022-10-11 15:59:23 +02:00
CommandQueue = nullptr ;
CommandList = nullptr ;
RtvDescHeap = nullptr ;
SwapChain = nullptr ;
Fence = nullptr ;
2019-10-18 18:03:56 +02:00
FenceSignaledValue = 0 ;
2022-10-11 15:59:23 +02:00
FenceEvent = nullptr ;
2021-06-29 14:53:25 +02:00
NumFramesInFlight = num_frames_in_flight ;
FrameCtx = new ImGui_ImplDX12_FrameContext [ NumFramesInFlight ] ;
2019-10-17 15:53:43 +02:00
FrameIndex = UINT_MAX ;
2021-06-29 14:53:25 +02:00
FrameRenderBuffers = new ImGui_ImplDX12_RenderBuffers [ NumFramesInFlight ] ;
2019-10-17 15:53:43 +02:00
2021-06-29 14:53:25 +02:00
for ( UINT i = 0 ; i < NumFramesInFlight ; + + i )
2019-10-17 15:53:43 +02:00
{
2022-10-11 15:59:23 +02:00
FrameCtx [ i ] . CommandAllocator = nullptr ;
FrameCtx [ i ] . RenderTarget = nullptr ;
2019-10-17 15:53:43 +02:00
// Create buffers with a default size (they will later be grown as needed)
2022-10-11 15:59:23 +02:00
FrameRenderBuffers [ i ] . IndexBuffer = nullptr ;
FrameRenderBuffers [ i ] . VertexBuffer = nullptr ;
2020-07-10 12:20:03 +02:00
FrameRenderBuffers [ i ] . VertexBufferSize = 5000 ;
FrameRenderBuffers [ i ] . IndexBufferSize = 10000 ;
2019-10-17 15:53:43 +02:00
}
}
2021-06-29 15:34:54 +02:00
~ ImGui_ImplDX12_ViewportData ( )
2019-10-17 15:53:43 +02:00
{
2022-10-11 15:59:23 +02:00
IM_ASSERT ( CommandQueue = = nullptr & & CommandList = = nullptr ) ;
IM_ASSERT ( RtvDescHeap = = nullptr ) ;
IM_ASSERT ( SwapChain = = nullptr ) ;
IM_ASSERT ( Fence = = nullptr ) ;
IM_ASSERT ( FenceEvent = = nullptr ) ;
2019-10-17 15:53:43 +02:00
2021-06-29 14:53:25 +02:00
for ( UINT i = 0 ; i < NumFramesInFlight ; + + i )
2019-10-17 15:53:43 +02:00
{
2022-10-11 15:59:23 +02:00
IM_ASSERT ( FrameCtx [ i ] . CommandAllocator = = nullptr & & FrameCtx [ i ] . RenderTarget = = nullptr ) ;
IM_ASSERT ( FrameRenderBuffers [ i ] . IndexBuffer = = nullptr & & FrameRenderBuffers [ i ] . VertexBuffer = = nullptr ) ;
2019-10-17 15:53:43 +02:00
}
2022-10-11 15:59:23 +02:00
delete [ ] FrameCtx ; FrameCtx = nullptr ;
delete [ ] FrameRenderBuffers ; FrameRenderBuffers = nullptr ;
2019-10-17 15:53:43 +02:00
}
} ;
2016-02-23 00:22:48 +01:00
2022-06-11 12:52:27 +02:00
struct VERTEX_CONSTANT_BUFFER_DX12
2016-02-23 00:22:48 +01:00
{
2018-06-08 19:37:33 +02:00
float mvp [ 4 ] [ 4 ] ;
2016-02-23 00:22:48 +01:00
} ;
2018-02-27 23:32:30 +01:00
// Forward Declarations
static void ImGui_ImplDX12_InitPlatformInterface ( ) ;
static void ImGui_ImplDX12_ShutdownPlatformInterface ( ) ;
2021-06-29 14:35:30 +02:00
// Functions
2024-10-07 17:52:57 +02:00
static void ImGui_ImplDX12_SetupRenderState ( ImDrawData * draw_data , ID3D12GraphicsCommandList * command_list , ImGui_ImplDX12_RenderBuffers * fr )
2019-04-30 22:15:59 +02:00
{
2021-06-28 16:52:10 +02:00
ImGui_ImplDX12_Data * bd = ImGui_ImplDX12_GetBackendData ( ) ;
2019-04-30 22:15:59 +02:00
// Setup orthographic projection matrix into our constant buffer
// Our visible imgui space lies from draw_data->DisplayPos (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right).
2022-06-11 12:52:27 +02:00
VERTEX_CONSTANT_BUFFER_DX12 vertex_constant_buffer ;
2019-04-30 22:15:59 +02:00
{
float L = draw_data - > DisplayPos . x ;
float R = draw_data - > DisplayPos . x + draw_data - > DisplaySize . x ;
float T = draw_data - > DisplayPos . y ;
float B = draw_data - > DisplayPos . y + draw_data - > DisplaySize . y ;
float mvp [ 4 ] [ 4 ] =
{
{ 2.0f / ( R - L ) , 0.0f , 0.0f , 0.0f } ,
{ 0.0f , 2.0f / ( T - B ) , 0.0f , 0.0f } ,
{ 0.0f , 0.0f , 0.5f , 0.0f } ,
{ ( R + L ) / ( L - R ) , ( T + B ) / ( B - T ) , 0.5f , 1.0f } ,
} ;
memcpy ( & vertex_constant_buffer . mvp , mvp , sizeof ( mvp ) ) ;
}
// Setup viewport
D3D12_VIEWPORT vp ;
memset ( & vp , 0 , sizeof ( D3D12_VIEWPORT ) ) ;
vp . Width = draw_data - > DisplaySize . x ;
vp . Height = draw_data - > DisplaySize . y ;
vp . MinDepth = 0.0f ;
vp . MaxDepth = 1.0f ;
vp . TopLeftX = vp . TopLeftY = 0.0f ;
2024-10-07 17:52:57 +02:00
command_list - > RSSetViewports ( 1 , & vp ) ;
2019-04-30 22:15:59 +02:00
// Bind shader and vertex buffers
unsigned int stride = sizeof ( ImDrawVert ) ;
unsigned int offset = 0 ;
D3D12_VERTEX_BUFFER_VIEW vbv ;
memset ( & vbv , 0 , sizeof ( D3D12_VERTEX_BUFFER_VIEW ) ) ;
vbv . BufferLocation = fr - > VertexBuffer - > GetGPUVirtualAddress ( ) + offset ;
vbv . SizeInBytes = fr - > VertexBufferSize * stride ;
vbv . StrideInBytes = stride ;
2024-10-07 17:52:57 +02:00
command_list - > IASetVertexBuffers ( 0 , 1 , & vbv ) ;
2019-04-30 22:15:59 +02:00
D3D12_INDEX_BUFFER_VIEW ibv ;
memset ( & ibv , 0 , sizeof ( D3D12_INDEX_BUFFER_VIEW ) ) ;
ibv . BufferLocation = fr - > IndexBuffer - > GetGPUVirtualAddress ( ) ;
ibv . SizeInBytes = fr - > IndexBufferSize * sizeof ( ImDrawIdx ) ;
ibv . Format = sizeof ( ImDrawIdx ) = = 2 ? DXGI_FORMAT_R16_UINT : DXGI_FORMAT_R32_UINT ;
2024-10-07 17:52:57 +02:00
command_list - > IASetIndexBuffer ( & ibv ) ;
command_list - > IASetPrimitiveTopology ( D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST ) ;
command_list - > SetPipelineState ( bd - > pPipelineState ) ;
command_list - > SetGraphicsRootSignature ( bd - > pRootSignature ) ;
command_list - > SetGraphicsRoot32BitConstants ( 0 , 16 , & vertex_constant_buffer , 0 ) ;
2019-04-30 22:15:59 +02:00
// Setup blend factor
const float blend_factor [ 4 ] = { 0.f , 0.f , 0.f , 0.f } ;
2024-10-07 17:52:57 +02:00
command_list - > OMSetBlendFactor ( blend_factor ) ;
2019-04-30 22:15:59 +02:00
}
2021-06-30 15:22:15 +02:00
template < typename T >
static inline void SafeRelease ( T * & res )
{
if ( res )
res - > Release ( ) ;
2022-10-11 12:22:29 +02:00
res = nullptr ;
2021-06-30 15:22:15 +02:00
}
2018-02-22 22:18:59 +01:00
// Render function
2024-10-07 17:52:57 +02:00
void ImGui_ImplDX12_RenderDrawData ( ImDrawData * draw_data , ID3D12GraphicsCommandList * command_list )
2016-02-23 00:22:48 +01:00
{
2019-04-15 18:47:36 +02:00
// Avoid rendering when minimized
if ( draw_data - > DisplaySize . x < = 0.0f | | draw_data - > DisplaySize . y < = 0.0f )
return ;
2021-06-28 16:52:10 +02:00
ImGui_ImplDX12_Data * bd = ImGui_ImplDX12_GetBackendData ( ) ;
2021-06-29 15:34:54 +02:00
ImGui_ImplDX12_ViewportData * vd = ( ImGui_ImplDX12_ViewportData * ) draw_data - > OwnerViewport - > RendererUserData ;
vd - > FrameIndex + + ;
ImGui_ImplDX12_RenderBuffers * fr = & vd - > FrameRenderBuffers [ vd - > FrameIndex % bd - > numFramesInFlight ] ;
2016-02-23 00:22:48 +01:00
2017-03-13 18:41:10 +01:00
// Create and grow vertex/index buffers if needed
2022-10-11 12:22:29 +02:00
if ( fr - > VertexBuffer = = nullptr | | fr - > VertexBufferSize < draw_data - > TotalVtxCount )
2016-02-23 00:22:48 +01:00
{
2019-10-18 18:03:56 +02:00
SafeRelease ( fr - > VertexBuffer ) ;
2019-03-29 16:18:26 +01:00
fr - > VertexBufferSize = draw_data - > TotalVtxCount + 5000 ;
2017-03-13 18:41:10 +01:00
D3D12_HEAP_PROPERTIES props ;
memset ( & props , 0 , sizeof ( D3D12_HEAP_PROPERTIES ) ) ;
props . Type = D3D12_HEAP_TYPE_UPLOAD ;
props . CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN ;
props . MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN ;
D3D12_RESOURCE_DESC desc ;
memset ( & desc , 0 , sizeof ( D3D12_RESOURCE_DESC ) ) ;
desc . Dimension = D3D12_RESOURCE_DIMENSION_BUFFER ;
2019-03-29 16:18:26 +01:00
desc . Width = fr - > VertexBufferSize * sizeof ( ImDrawVert ) ;
2017-03-13 18:41:10 +01:00
desc . Height = 1 ;
desc . DepthOrArraySize = 1 ;
desc . MipLevels = 1 ;
desc . Format = DXGI_FORMAT_UNKNOWN ;
desc . SampleDesc . Count = 1 ;
desc . Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR ;
desc . Flags = D3D12_RESOURCE_FLAG_NONE ;
2022-10-11 12:22:29 +02:00
if ( bd - > pd3dDevice - > CreateCommittedResource ( & props , D3D12_HEAP_FLAG_NONE , & desc , D3D12_RESOURCE_STATE_GENERIC_READ , nullptr , IID_PPV_ARGS ( & fr - > VertexBuffer ) ) < 0 )
2017-03-13 18:41:10 +01:00
return ;
2016-02-23 00:22:48 +01:00
}
2022-10-11 12:22:29 +02:00
if ( fr - > IndexBuffer = = nullptr | | fr - > IndexBufferSize < draw_data - > TotalIdxCount )
2016-02-23 00:22:48 +01:00
{
2019-10-18 18:03:56 +02:00
SafeRelease ( fr - > IndexBuffer ) ;
2019-03-29 16:18:26 +01:00
fr - > IndexBufferSize = draw_data - > TotalIdxCount + 10000 ;
2017-03-13 18:41:10 +01:00
D3D12_HEAP_PROPERTIES props ;
memset ( & props , 0 , sizeof ( D3D12_HEAP_PROPERTIES ) ) ;
props . Type = D3D12_HEAP_TYPE_UPLOAD ;
props . CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN ;
props . MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN ;
D3D12_RESOURCE_DESC desc ;
memset ( & desc , 0 , sizeof ( D3D12_RESOURCE_DESC ) ) ;
desc . Dimension = D3D12_RESOURCE_DIMENSION_BUFFER ;
2019-03-29 16:18:26 +01:00
desc . Width = fr - > IndexBufferSize * sizeof ( ImDrawIdx ) ;
2017-03-13 18:41:10 +01:00
desc . Height = 1 ;
desc . DepthOrArraySize = 1 ;
desc . MipLevels = 1 ;
desc . Format = DXGI_FORMAT_UNKNOWN ;
desc . SampleDesc . Count = 1 ;
desc . Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR ;
desc . Flags = D3D12_RESOURCE_FLAG_NONE ;
2022-10-11 12:22:29 +02:00
if ( bd - > pd3dDevice - > CreateCommittedResource ( & props , D3D12_HEAP_FLAG_NONE , & desc , D3D12_RESOURCE_STATE_GENERIC_READ , nullptr , IID_PPV_ARGS ( & fr - > IndexBuffer ) ) < 0 )
2017-03-13 18:41:10 +01:00
return ;
2016-02-23 00:22:48 +01:00
}
2019-03-29 16:18:26 +01:00
// Upload vertex/index data into a single contiguous GPU buffer
2024-10-23 12:40:20 +02:00
// During Map() we specify a null read range (as per DX12 API, this is informational and for tooling only)
2017-03-13 18:41:10 +01:00
void * vtx_resource , * idx_resource ;
2024-10-23 12:40:20 +02:00
D3D12_RANGE range = { 0 , 0 } ;
2019-03-29 16:18:26 +01:00
if ( fr - > VertexBuffer - > Map ( 0 , & range , & vtx_resource ) ! = S_OK )
2017-03-13 18:41:10 +01:00
return ;
2019-03-29 16:18:26 +01:00
if ( fr - > IndexBuffer - > Map ( 0 , & range , & idx_resource ) ! = S_OK )
2017-03-13 18:41:10 +01:00
return ;
2016-02-23 00:22:48 +01:00
ImDrawVert * vtx_dst = ( ImDrawVert * ) vtx_resource ;
ImDrawIdx * idx_dst = ( ImDrawIdx * ) idx_resource ;
for ( int n = 0 ; n < draw_data - > CmdListsCount ; n + + )
{
2024-10-07 17:52:57 +02:00
const ImDrawList * draw_list = draw_data - > CmdLists [ n ] ;
memcpy ( vtx_dst , draw_list - > VtxBuffer . Data , draw_list - > VtxBuffer . Size * sizeof ( ImDrawVert ) ) ;
memcpy ( idx_dst , draw_list - > IdxBuffer . Data , draw_list - > IdxBuffer . Size * sizeof ( ImDrawIdx ) ) ;
vtx_dst + = draw_list - > VtxBuffer . Size ;
idx_dst + = draw_list - > IdxBuffer . Size ;
2016-02-23 00:22:48 +01:00
}
2024-10-23 12:40:20 +02:00
// During Unmap() we specify the written range (as per DX12 API, this is informational and for tooling only)
range . End = ( SIZE_T ) ( ( intptr_t ) vtx_dst - ( intptr_t ) vtx_resource ) ;
IM_ASSERT ( range . End = = draw_data - > TotalVtxCount * sizeof ( ImDrawVert ) ) ;
2019-03-29 16:18:26 +01:00
fr - > VertexBuffer - > Unmap ( 0 , & range ) ;
2024-10-23 12:40:20 +02:00
range . End = ( SIZE_T ) ( ( intptr_t ) idx_dst - ( intptr_t ) idx_resource ) ;
IM_ASSERT ( range . End = = draw_data - > TotalIdxCount * sizeof ( ImDrawIdx ) ) ;
2019-03-29 16:18:26 +01:00
fr - > IndexBuffer - > Unmap ( 0 , & range ) ;
2016-02-23 00:22:48 +01:00
2019-04-30 22:15:59 +02:00
// Setup desired DX state
2024-10-07 17:52:57 +02:00
ImGui_ImplDX12_SetupRenderState ( draw_data , command_list , fr ) ;
2016-02-23 00:22:48 +01:00
2024-10-07 21:00:07 +02:00
// Setup render state structure (for callbacks and custom texture bindings)
ImGuiPlatformIO & platform_io = ImGui : : GetPlatformIO ( ) ;
ImGui_ImplDX12_RenderState render_state ;
render_state . Device = bd - > pd3dDevice ;
render_state . CommandList = command_list ;
platform_io . Renderer_RenderState = & render_state ;
2016-02-23 00:22:48 +01:00
// Render command lists
2019-05-29 15:53:36 +02:00
// (Because we merged all buffers into a single one, we maintain our own offset into them)
int global_vtx_offset = 0 ;
int global_idx_offset = 0 ;
2019-02-11 18:38:07 +01:00
ImVec2 clip_off = draw_data - > DisplayPos ;
2016-02-23 00:22:48 +01:00
for ( int n = 0 ; n < draw_data - > CmdListsCount ; n + + )
{
2024-10-07 17:52:57 +02:00
const ImDrawList * draw_list = draw_data - > CmdLists [ n ] ;
for ( int cmd_i = 0 ; cmd_i < draw_list - > CmdBuffer . Size ; cmd_i + + )
2016-02-23 00:22:48 +01:00
{
2024-10-07 17:52:57 +02:00
const ImDrawCmd * pcmd = & draw_list - > CmdBuffer [ cmd_i ] ;
2022-10-11 12:22:29 +02:00
if ( pcmd - > UserCallback ! = nullptr )
2016-02-23 00:22:48 +01:00
{
2019-04-30 22:15:59 +02:00
// User callback, registered via ImDrawList::AddCallback()
// (ImDrawCallback_ResetRenderState is a special callback value used by the user to request the renderer to reset render state.)
if ( pcmd - > UserCallback = = ImDrawCallback_ResetRenderState )
2024-10-07 17:52:57 +02:00
ImGui_ImplDX12_SetupRenderState ( draw_data , command_list , fr ) ;
2019-04-30 22:15:59 +02:00
else
2024-10-07 17:52:57 +02:00
pcmd - > UserCallback ( draw_list , pcmd ) ;
2016-02-23 00:22:48 +01:00
}
else
{
2021-08-24 17:03:52 +02:00
// Project scissor/clipping rectangles into framebuffer space
ImVec2 clip_min ( pcmd - > ClipRect . x - clip_off . x , pcmd - > ClipRect . y - clip_off . y ) ;
ImVec2 clip_max ( pcmd - > ClipRect . z - clip_off . x , pcmd - > ClipRect . w - clip_off . y ) ;
2021-11-30 21:48:29 +01:00
if ( clip_max . x < = clip_min . x | | clip_max . y < = clip_min . y )
2021-08-24 17:03:52 +02:00
continue ;
2024-10-07 17:52:57 +02:00
// Apply scissor/clipping rectangle
2021-08-24 17:03:52 +02:00
const D3D12_RECT r = { ( LONG ) clip_min . x , ( LONG ) clip_min . y , ( LONG ) clip_max . x , ( LONG ) clip_max . y } ;
2024-10-07 17:52:57 +02:00
command_list - > RSSetScissorRects ( 1 , & r ) ;
// Bind texture, Draw
2021-08-24 17:03:52 +02:00
D3D12_GPU_DESCRIPTOR_HANDLE texture_handle = { } ;
texture_handle . ptr = ( UINT64 ) pcmd - > GetTexID ( ) ;
2024-10-07 17:52:57 +02:00
command_list - > SetGraphicsRootDescriptorTable ( 1 , texture_handle ) ;
command_list - > DrawIndexedInstanced ( pcmd - > ElemCount , 1 , pcmd - > IdxOffset + global_idx_offset , pcmd - > VtxOffset + global_vtx_offset , 0 ) ;
2016-02-23 00:22:48 +01:00
}
}
2024-10-07 17:52:57 +02:00
global_idx_offset + = draw_list - > IdxBuffer . Size ;
global_vtx_offset + = draw_list - > VtxBuffer . Size ;
2016-02-23 00:22:48 +01:00
}
2024-10-07 21:00:07 +02:00
platform_io . Renderer_RenderState = NULL ;
2016-02-23 00:22:48 +01:00
}
static void ImGui_ImplDX12_CreateFontsTexture ( )
{
// Build texture atlas
ImGuiIO & io = ImGui : : GetIO ( ) ;
2021-06-28 16:52:10 +02:00
ImGui_ImplDX12_Data * bd = ImGui_ImplDX12_GetBackendData ( ) ;
2016-02-23 00:22:48 +01:00
unsigned char * pixels ;
int width , height ;
io . Fonts - > GetTexDataAsRGBA32 ( & pixels , & width , & height ) ;
// Upload texture to graphics system
2024-11-15 19:14:04 +01:00
ImGui_ImplDX12_Texture * font_tex = & bd - > FontTexture ;
2016-02-23 00:22:48 +01:00
{
2017-03-13 18:41:10 +01:00
D3D12_HEAP_PROPERTIES props ;
memset ( & props , 0 , sizeof ( D3D12_HEAP_PROPERTIES ) ) ;
2016-02-23 00:22:48 +01:00
props . Type = D3D12_HEAP_TYPE_DEFAULT ;
props . CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN ;
props . MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN ;
2017-03-13 18:41:10 +01:00
D3D12_RESOURCE_DESC desc ;
ZeroMemory ( & desc , sizeof ( desc ) ) ;
desc . Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D ;
desc . Alignment = 0 ;
desc . Width = width ;
desc . Height = height ;
desc . DepthOrArraySize = 1 ;
desc . MipLevels = 1 ;
desc . Format = DXGI_FORMAT_R8G8B8A8_UNORM ;
desc . SampleDesc . Count = 1 ;
desc . SampleDesc . Quality = 0 ;
desc . Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN ;
desc . Flags = D3D12_RESOURCE_FLAG_NONE ;
2022-10-11 12:22:29 +02:00
ID3D12Resource * pTexture = nullptr ;
2021-06-28 16:52:10 +02:00
bd - > pd3dDevice - > CreateCommittedResource ( & props , D3D12_HEAP_FLAG_NONE , & desc ,
2022-10-11 12:22:29 +02:00
D3D12_RESOURCE_STATE_COPY_DEST , nullptr , IID_PPV_ARGS ( & pTexture ) ) ;
2016-02-23 00:22:48 +01:00
UINT uploadPitch = ( width * 4 + D3D12_TEXTURE_DATA_PITCH_ALIGNMENT - 1u ) & ~ ( D3D12_TEXTURE_DATA_PITCH_ALIGNMENT - 1u ) ;
UINT uploadSize = height * uploadPitch ;
2017-03-13 18:41:10 +01:00
desc . Dimension = D3D12_RESOURCE_DIMENSION_BUFFER ;
desc . Alignment = 0 ;
desc . Width = uploadSize ;
desc . Height = 1 ;
desc . DepthOrArraySize = 1 ;
desc . MipLevels = 1 ;
desc . Format = DXGI_FORMAT_UNKNOWN ;
desc . SampleDesc . Count = 1 ;
desc . SampleDesc . Quality = 0 ;
desc . Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR ;
desc . Flags = D3D12_RESOURCE_FLAG_NONE ;
2016-02-23 00:22:48 +01:00
props . Type = D3D12_HEAP_TYPE_UPLOAD ;
props . CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN ;
props . MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN ;
2022-10-11 12:22:29 +02:00
ID3D12Resource * uploadBuffer = nullptr ;
2021-06-28 16:52:10 +02:00
HRESULT hr = bd - > pd3dDevice - > CreateCommittedResource ( & props , D3D12_HEAP_FLAG_NONE , & desc ,
2022-10-11 12:22:29 +02:00
D3D12_RESOURCE_STATE_GENERIC_READ , nullptr , IID_PPV_ARGS ( & uploadBuffer ) ) ;
2018-02-22 22:18:59 +01:00
IM_ASSERT ( SUCCEEDED ( hr ) ) ;
2016-02-23 00:22:48 +01:00
2022-10-11 12:22:29 +02:00
void * mapped = nullptr ;
2016-02-23 00:22:48 +01:00
D3D12_RANGE range = { 0 , uploadSize } ;
hr = uploadBuffer - > Map ( 0 , & range , & mapped ) ;
2018-02-22 22:18:59 +01:00
IM_ASSERT ( SUCCEEDED ( hr ) ) ;
for ( int y = 0 ; y < height ; y + + )
2016-02-23 00:22:48 +01:00
memcpy ( ( void * ) ( ( uintptr_t ) mapped + y * uploadPitch ) , pixels + y * width * 4 , width * 4 ) ;
uploadBuffer - > Unmap ( 0 , & range ) ;
D3D12_TEXTURE_COPY_LOCATION srcLocation = { } ;
srcLocation . pResource = uploadBuffer ;
srcLocation . Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT ;
srcLocation . PlacedFootprint . Footprint . Format = DXGI_FORMAT_R8G8B8A8_UNORM ;
srcLocation . PlacedFootprint . Footprint . Width = width ;
srcLocation . PlacedFootprint . Footprint . Height = height ;
srcLocation . PlacedFootprint . Footprint . Depth = 1 ;
srcLocation . PlacedFootprint . Footprint . RowPitch = uploadPitch ;
D3D12_TEXTURE_COPY_LOCATION dstLocation = { } ;
2017-03-13 18:41:10 +01:00
dstLocation . pResource = pTexture ;
2016-02-23 00:22:48 +01:00
dstLocation . Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX ;
dstLocation . SubresourceIndex = 0 ;
D3D12_RESOURCE_BARRIER barrier = { } ;
barrier . Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION ;
barrier . Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE ;
2017-03-13 18:41:10 +01:00
barrier . Transition . pResource = pTexture ;
2016-02-23 00:22:48 +01:00
barrier . Transition . Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES ;
barrier . Transition . StateBefore = D3D12_RESOURCE_STATE_COPY_DEST ;
barrier . Transition . StateAfter = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE ;
2022-10-11 12:22:29 +02:00
ID3D12Fence * fence = nullptr ;
2021-06-28 16:52:10 +02:00
hr = bd - > pd3dDevice - > CreateFence ( 0 , D3D12_FENCE_FLAG_NONE , IID_PPV_ARGS ( & fence ) ) ;
2018-02-22 22:18:59 +01:00
IM_ASSERT ( SUCCEEDED ( hr ) ) ;
2016-02-23 00:22:48 +01:00
HANDLE event = CreateEvent ( 0 , 0 , 0 , 0 ) ;
2022-10-11 12:22:29 +02:00
IM_ASSERT ( event ! = nullptr ) ;
2016-02-23 00:22:48 +01:00
D3D12_COMMAND_QUEUE_DESC queueDesc = { } ;
queueDesc . Type = D3D12_COMMAND_LIST_TYPE_DIRECT ;
queueDesc . Flags = D3D12_COMMAND_QUEUE_FLAG_NONE ;
queueDesc . NodeMask = 1 ;
2022-10-11 12:22:29 +02:00
ID3D12CommandQueue * cmdQueue = nullptr ;
2021-06-28 16:52:10 +02:00
hr = bd - > pd3dDevice - > CreateCommandQueue ( & queueDesc , IID_PPV_ARGS ( & cmdQueue ) ) ;
2018-02-22 22:18:59 +01:00
IM_ASSERT ( SUCCEEDED ( hr ) ) ;
2016-02-23 00:22:48 +01:00
2022-10-11 12:22:29 +02:00
ID3D12CommandAllocator * cmdAlloc = nullptr ;
2021-06-28 16:52:10 +02:00
hr = bd - > pd3dDevice - > CreateCommandAllocator ( D3D12_COMMAND_LIST_TYPE_DIRECT , IID_PPV_ARGS ( & cmdAlloc ) ) ;
2018-02-22 22:18:59 +01:00
IM_ASSERT ( SUCCEEDED ( hr ) ) ;
2016-02-23 00:22:48 +01:00
2022-10-11 12:22:29 +02:00
ID3D12GraphicsCommandList * cmdList = nullptr ;
hr = bd - > pd3dDevice - > CreateCommandList ( 0 , D3D12_COMMAND_LIST_TYPE_DIRECT , cmdAlloc , nullptr , IID_PPV_ARGS ( & cmdList ) ) ;
2018-02-22 22:18:59 +01:00
IM_ASSERT ( SUCCEEDED ( hr ) ) ;
2016-02-23 00:22:48 +01:00
2022-10-11 12:22:29 +02:00
cmdList - > CopyTextureRegion ( & dstLocation , 0 , 0 , 0 , & srcLocation , nullptr ) ;
2016-02-23 00:22:48 +01:00
cmdList - > ResourceBarrier ( 1 , & barrier ) ;
hr = cmdList - > Close ( ) ;
2018-02-22 22:18:59 +01:00
IM_ASSERT ( SUCCEEDED ( hr ) ) ;
2016-02-23 00:22:48 +01:00
2020-06-30 15:31:54 +02:00
cmdQueue - > ExecuteCommandLists ( 1 , ( ID3D12CommandList * const * ) & cmdList ) ;
2016-02-23 00:22:48 +01:00
hr = cmdQueue - > Signal ( fence , 1 ) ;
2018-02-22 22:18:59 +01:00
IM_ASSERT ( SUCCEEDED ( hr ) ) ;
2016-02-23 00:22:48 +01:00
fence - > SetEventOnCompletion ( 1 , event ) ;
WaitForSingleObject ( event , INFINITE ) ;
cmdList - > Release ( ) ;
cmdAlloc - > Release ( ) ;
cmdQueue - > Release ( ) ;
CloseHandle ( event ) ;
fence - > Release ( ) ;
uploadBuffer - > Release ( ) ;
2017-03-13 18:41:10 +01:00
// Create texture view
D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc ;
ZeroMemory ( & srvDesc , sizeof ( srvDesc ) ) ;
srvDesc . Format = DXGI_FORMAT_R8G8B8A8_UNORM ;
srvDesc . ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D ;
srvDesc . Texture2D . MipLevels = desc . MipLevels ;
srvDesc . Texture2D . MostDetailedMip = 0 ;
srvDesc . Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING ;
2024-11-15 19:14:04 +01:00
bd - > pd3dDevice - > CreateShaderResourceView ( pTexture , & srvDesc , font_tex - > hFontSrvCpuDescHandle ) ;
SafeRelease ( font_tex - > pTextureResource ) ;
font_tex - > pTextureResource = pTexture ;
2017-03-13 18:41:10 +01:00
}
2016-02-23 00:22:48 +01:00
// Store our identifier
2024-11-15 19:14:04 +01:00
io . Fonts - > SetTexID ( ( ImTextureID ) font_tex - > hFontSrvGpuDescHandle . ptr ) ;
2016-02-23 00:22:48 +01:00
}
bool ImGui_ImplDX12_CreateDeviceObjects ( )
{
2021-06-28 16:52:10 +02:00
ImGui_ImplDX12_Data * bd = ImGui_ImplDX12_GetBackendData ( ) ;
2021-06-29 14:53:25 +02:00
if ( ! bd | | ! bd - > pd3dDevice )
2016-02-23 00:22:48 +01:00
return false ;
2021-06-28 16:52:10 +02:00
if ( bd - > pPipelineState )
2016-02-23 00:22:48 +01:00
ImGui_ImplDX12_InvalidateDeviceObjects ( ) ;
// Create the root signature
{
D3D12_DESCRIPTOR_RANGE descRange = { } ;
descRange . RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV ;
descRange . NumDescriptors = 1 ;
descRange . BaseShaderRegister = 0 ;
descRange . RegisterSpace = 0 ;
descRange . OffsetInDescriptorsFromTableStart = 0 ;
D3D12_ROOT_PARAMETER param [ 2 ] = { } ;
param [ 0 ] . ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS ;
param [ 0 ] . Constants . ShaderRegister = 0 ;
param [ 0 ] . Constants . RegisterSpace = 0 ;
param [ 0 ] . Constants . Num32BitValues = 16 ;
param [ 0 ] . ShaderVisibility = D3D12_SHADER_VISIBILITY_VERTEX ;
param [ 1 ] . ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE ;
param [ 1 ] . DescriptorTable . NumDescriptorRanges = 1 ;
param [ 1 ] . DescriptorTable . pDescriptorRanges = & descRange ;
param [ 1 ] . ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL ;
2022-04-07 14:28:08 +02:00
// Bilinear sampling is required by default. Set 'io.Fonts->Flags |= ImFontAtlasFlags_NoBakedLines' or 'style.AntiAliasedLinesUseTex = false' to allow point/nearest sampling.
2016-02-23 00:22:48 +01:00
D3D12_STATIC_SAMPLER_DESC staticSampler = { } ;
staticSampler . Filter = D3D12_FILTER_MIN_MAG_MIP_LINEAR ;
2024-10-07 22:02:55 +02:00
staticSampler . AddressU = D3D12_TEXTURE_ADDRESS_MODE_CLAMP ;
staticSampler . AddressV = D3D12_TEXTURE_ADDRESS_MODE_CLAMP ;
staticSampler . AddressW = D3D12_TEXTURE_ADDRESS_MODE_CLAMP ;
2016-02-23 00:22:48 +01:00
staticSampler . MipLODBias = 0.f ;
staticSampler . MaxAnisotropy = 0 ;
staticSampler . ComparisonFunc = D3D12_COMPARISON_FUNC_ALWAYS ;
staticSampler . BorderColor = D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK ;
staticSampler . MinLOD = 0.f ;
staticSampler . MaxLOD = 0.f ;
staticSampler . ShaderRegister = 0 ;
staticSampler . RegisterSpace = 0 ;
staticSampler . ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL ;
D3D12_ROOT_SIGNATURE_DESC desc = { } ;
desc . NumParameters = _countof ( param ) ;
desc . pParameters = param ;
desc . NumStaticSamplers = 1 ;
desc . pStaticSamplers = & staticSampler ;
desc . Flags =
D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT |
D3D12_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS |
D3D12_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS |
D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS ;
2021-01-04 09:27:15 +01:00
// Load d3d12.dll and D3D12SerializeRootSignature() function address dynamically to facilitate using with D3D12On7.
// See if any version of d3d12.dll is already loaded in the process. If so, give preference to that.
static HINSTANCE d3d12_dll = : : GetModuleHandleA ( " d3d12.dll " ) ;
2022-10-11 12:22:29 +02:00
if ( d3d12_dll = = nullptr )
2021-01-04 09:27:15 +01:00
{
// Attempt to load d3d12.dll from local directories. This will only succeed if
// (1) the current OS is Windows 7, and
// (2) there exists a version of d3d12.dll for Windows 7 (D3D12On7) in one of the following directories.
// See https://github.com/ocornut/imgui/pull/3696 for details.
const char * localD3d12Paths [ ] = { " . \\ d3d12.dll " , " . \\ d3d12on7 \\ d3d12.dll " , " . \\ 12on7 \\ d3d12.dll " } ; // A. current directory, B. used by some games, C. used in Microsoft D3D12On7 sample
for ( int i = 0 ; i < IM_ARRAYSIZE ( localD3d12Paths ) ; i + + )
2022-10-11 12:22:29 +02:00
if ( ( d3d12_dll = : : LoadLibraryA ( localD3d12Paths [ i ] ) ) ! = nullptr )
2021-01-04 09:27:15 +01:00
break ;
// If failed, we are on Windows >= 10.
2022-10-11 12:22:29 +02:00
if ( d3d12_dll = = nullptr )
2021-01-04 09:27:15 +01:00
d3d12_dll = : : LoadLibraryA ( " d3d12.dll " ) ;
2022-10-11 12:22:29 +02:00
if ( d3d12_dll = = nullptr )
2021-01-04 09:27:15 +01:00
return false ;
}
PFN_D3D12_SERIALIZE_ROOT_SIGNATURE D3D12SerializeRootSignatureFn = ( PFN_D3D12_SERIALIZE_ROOT_SIGNATURE ) : : GetProcAddress ( d3d12_dll , " D3D12SerializeRootSignature " ) ;
2022-10-11 12:22:29 +02:00
if ( D3D12SerializeRootSignatureFn = = nullptr )
2021-01-04 09:27:15 +01:00
return false ;
2022-10-11 12:22:29 +02:00
ID3DBlob * blob = nullptr ;
if ( D3D12SerializeRootSignatureFn ( & desc , D3D_ROOT_SIGNATURE_VERSION_1 , & blob , nullptr ) ! = S_OK )
2016-02-23 00:22:48 +01:00
return false ;
2021-06-28 16:52:10 +02:00
bd - > pd3dDevice - > CreateRootSignature ( 0 , blob - > GetBufferPointer ( ) , blob - > GetBufferSize ( ) , IID_PPV_ARGS ( & bd - > pRootSignature ) ) ;
2016-02-23 00:22:48 +01:00
blob - > Release ( ) ;
}
2017-03-13 18:41:10 +01:00
// By using D3DCompile() from <d3dcompiler.h> / d3dcompiler.lib, we introduce a dependency to a given version of d3dcompiler_XX.dll (see D3DCOMPILER_DLL_A)
2019-01-20 17:56:17 +01:00
// If you would like to use this DX12 sample code but remove this dependency you can:
2022-10-20 08:25:00 +02:00
// 1) compile once, save the compiled shader blobs into a file or source code and assign them to psoDesc.VS/PS [preferred solution]
2019-01-20 17:56:17 +01:00
// 2) use code to detect any version of the DLL and grab a pointer to D3DCompile from the DLL.
2017-03-13 18:41:10 +01:00
// See https://github.com/ocornut/imgui/pull/638 for sources and details.
D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc ;
memset ( & psoDesc , 0 , sizeof ( D3D12_GRAPHICS_PIPELINE_STATE_DESC ) ) ;
psoDesc . NodeMask = 1 ;
psoDesc . PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE ;
2021-06-28 16:52:10 +02:00
psoDesc . pRootSignature = bd - > pRootSignature ;
2017-03-13 18:41:10 +01:00
psoDesc . SampleMask = UINT_MAX ;
psoDesc . NumRenderTargets = 1 ;
2021-06-28 16:52:10 +02:00
psoDesc . RTVFormats [ 0 ] = bd - > RTVFormat ;
2017-03-13 18:41:10 +01:00
psoDesc . SampleDesc . Count = 1 ;
psoDesc . Flags = D3D12_PIPELINE_STATE_FLAG_NONE ;
2020-04-28 21:53:46 +02:00
ID3DBlob * vertexShaderBlob ;
ID3DBlob * pixelShaderBlob ;
2017-03-13 18:41:10 +01:00
// Create the vertex shader
2016-02-23 00:22:48 +01:00
{
2017-03-13 18:41:10 +01:00
static const char * vertexShader =
2016-02-23 00:22:48 +01:00
" cbuffer vertexBuffer : register(b0) \
{ \
2018-06-21 12:13:04 +02:00
float4x4 ProjectionMatrix ; \
2016-02-23 00:22:48 +01:00
} ; \
struct VS_INPUT \
{ \
2018-06-21 12:13:04 +02:00
float2 pos : POSITION ; \
float4 col : COLOR0 ; \
float2 uv : TEXCOORD0 ; \
2016-02-23 00:22:48 +01:00
} ; \
\
struct PS_INPUT \
{ \
2018-06-21 12:13:04 +02:00
float4 pos : SV_POSITION ; \
float4 col : COLOR0 ; \
float2 uv : TEXCOORD0 ; \
2016-02-23 00:22:48 +01:00
} ; \
\
PS_INPUT main ( VS_INPUT input ) \
{ \
2018-06-21 12:13:04 +02:00
PS_INPUT output ; \
output . pos = mul ( ProjectionMatrix , float4 ( input . pos . xy , 0.f , 1.f ) ) ; \
output . col = input . col ; \
output . uv = input . uv ; \
return output ; \
2016-02-23 00:22:48 +01:00
} " ;
2022-10-11 12:22:29 +02:00
if ( FAILED ( D3DCompile ( vertexShader , strlen ( vertexShader ) , nullptr , nullptr , nullptr , " main " , " vs_5_0 " , 0 , 0 , & vertexShaderBlob , nullptr ) ) )
2022-10-20 08:25:00 +02:00
return false ; // NB: Pass ID3DBlob* pErrorBlob to D3DCompile() to get error showing in (const char*)pErrorBlob->GetBufferPointer(). Make sure to Release() the blob!
2020-04-28 21:53:46 +02:00
psoDesc . VS = { vertexShaderBlob - > GetBufferPointer ( ) , vertexShaderBlob - > GetBufferSize ( ) } ;
2017-03-13 18:41:10 +01:00
// Create the input layout
2020-06-30 15:31:54 +02:00
static D3D12_INPUT_ELEMENT_DESC local_layout [ ] =
{
2023-11-09 16:44:39 +01:00
{ " POSITION " , 0 , DXGI_FORMAT_R32G32_FLOAT , 0 , ( UINT ) offsetof ( ImDrawVert , pos ) , D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA , 0 } ,
{ " TEXCOORD " , 0 , DXGI_FORMAT_R32G32_FLOAT , 0 , ( UINT ) offsetof ( ImDrawVert , uv ) , D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA , 0 } ,
{ " COLOR " , 0 , DXGI_FORMAT_R8G8B8A8_UNORM , 0 , ( UINT ) offsetof ( ImDrawVert , col ) , D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA , 0 } ,
2017-03-13 18:41:10 +01:00
} ;
psoDesc . InputLayout = { local_layout , 3 } ;
}
// Create the pixel shader
{
2016-02-23 00:22:48 +01:00
static const char * pixelShader =
" struct PS_INPUT \
{ \
2018-06-21 12:13:04 +02:00
float4 pos : SV_POSITION ; \
float4 col : COLOR0 ; \
float2 uv : TEXCOORD0 ; \
2016-02-23 00:22:48 +01:00
} ; \
SamplerState sampler0 : register ( s0 ) ; \
Texture2D texture0 : register ( t0 ) ; \
\
float4 main ( PS_INPUT input ) : SV_Target \
{ \
2018-06-21 12:13:04 +02:00
float4 out_col = input . col * texture0 . Sample ( sampler0 , input . uv ) ; \
return out_col ; \
2016-02-23 00:22:48 +01:00
} " ;
2022-10-11 12:22:29 +02:00
if ( FAILED ( D3DCompile ( pixelShader , strlen ( pixelShader ) , nullptr , nullptr , nullptr , " main " , " ps_5_0 " , 0 , 0 , & pixelShaderBlob , nullptr ) ) )
2020-04-28 21:53:46 +02:00
{
vertexShaderBlob - > Release ( ) ;
2022-10-20 08:25:00 +02:00
return false ; // NB: Pass ID3DBlob* pErrorBlob to D3DCompile() to get error showing in (const char*)pErrorBlob->GetBufferPointer(). Make sure to Release() the blob!
2020-04-28 21:53:46 +02:00
}
psoDesc . PS = { pixelShaderBlob - > GetBufferPointer ( ) , pixelShaderBlob - > GetBufferSize ( ) } ;
2017-03-13 18:41:10 +01:00
}
2016-02-23 00:22:48 +01:00
2017-03-13 18:41:10 +01:00
// Create the blending setup
{
D3D12_BLEND_DESC & desc = psoDesc . BlendState ;
desc . AlphaToCoverageEnable = false ;
desc . RenderTarget [ 0 ] . BlendEnable = true ;
desc . RenderTarget [ 0 ] . SrcBlend = D3D12_BLEND_SRC_ALPHA ;
desc . RenderTarget [ 0 ] . DestBlend = D3D12_BLEND_INV_SRC_ALPHA ;
desc . RenderTarget [ 0 ] . BlendOp = D3D12_BLEND_OP_ADD ;
2021-02-17 19:29:07 +01:00
desc . RenderTarget [ 0 ] . SrcBlendAlpha = D3D12_BLEND_ONE ;
desc . RenderTarget [ 0 ] . DestBlendAlpha = D3D12_BLEND_INV_SRC_ALPHA ;
2017-03-13 18:41:10 +01:00
desc . RenderTarget [ 0 ] . BlendOpAlpha = D3D12_BLEND_OP_ADD ;
desc . RenderTarget [ 0 ] . RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL ;
}
2016-02-23 00:22:48 +01:00
2017-03-13 18:41:10 +01:00
// Create the rasterizer state
{
D3D12_RASTERIZER_DESC & desc = psoDesc . RasterizerState ;
desc . FillMode = D3D12_FILL_MODE_SOLID ;
desc . CullMode = D3D12_CULL_MODE_NONE ;
desc . FrontCounterClockwise = FALSE ;
desc . DepthBias = D3D12_DEFAULT_DEPTH_BIAS ;
desc . DepthBiasClamp = D3D12_DEFAULT_DEPTH_BIAS_CLAMP ;
desc . SlopeScaledDepthBias = D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS ;
desc . DepthClipEnable = true ;
desc . MultisampleEnable = FALSE ;
desc . AntialiasedLineEnable = FALSE ;
desc . ForcedSampleCount = 0 ;
desc . ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF ;
}
// Create depth-stencil State
{
D3D12_DEPTH_STENCIL_DESC & desc = psoDesc . DepthStencilState ;
desc . DepthEnable = false ;
desc . DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL ;
desc . DepthFunc = D3D12_COMPARISON_FUNC_ALWAYS ;
desc . StencilEnable = false ;
desc . FrontFace . StencilFailOp = desc . FrontFace . StencilDepthFailOp = desc . FrontFace . StencilPassOp = D3D12_STENCIL_OP_KEEP ;
desc . FrontFace . StencilFunc = D3D12_COMPARISON_FUNC_ALWAYS ;
desc . BackFace = desc . FrontFace ;
2016-02-23 00:22:48 +01:00
}
2021-06-28 16:52:10 +02:00
HRESULT result_pipeline_state = bd - > pd3dDevice - > CreateGraphicsPipelineState ( & psoDesc , IID_PPV_ARGS ( & bd - > pPipelineState ) ) ;
2020-04-28 21:53:46 +02:00
vertexShaderBlob - > Release ( ) ;
pixelShaderBlob - > Release ( ) ;
2020-05-04 11:32:58 +02:00
if ( result_pipeline_state ! = S_OK )
2017-03-13 18:41:10 +01:00
return false ;
2016-02-23 00:22:48 +01:00
ImGui_ImplDX12_CreateFontsTexture ( ) ;
return true ;
}
2021-07-09 20:16:19 +02:00
static void ImGui_ImplDX12_DestroyRenderBuffers ( ImGui_ImplDX12_RenderBuffers * render_buffers )
{
SafeRelease ( render_buffers - > IndexBuffer ) ;
SafeRelease ( render_buffers - > VertexBuffer ) ;
render_buffers - > IndexBufferSize = render_buffers - > VertexBufferSize = 0 ;
}
2016-02-23 00:22:48 +01:00
void ImGui_ImplDX12_InvalidateDeviceObjects ( )
{
2021-06-28 16:52:10 +02:00
ImGui_ImplDX12_Data * bd = ImGui_ImplDX12_GetBackendData ( ) ;
2021-06-29 14:53:25 +02:00
if ( ! bd | | ! bd - > pd3dDevice )
2016-02-23 00:22:48 +01:00
return ;
2019-03-29 16:18:26 +01:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2021-06-28 16:52:10 +02:00
SafeRelease ( bd - > pRootSignature ) ;
SafeRelease ( bd - > pPipelineState ) ;
2024-11-15 19:02:26 +01:00
// Free SRV descriptor used by texture
2024-11-15 19:14:04 +01:00
ImGui_ImplDX12_Texture * font_tex = & bd - > FontTexture ;
2024-11-18 15:16:41 +01:00
bd - > InitInfo . SrvDescriptorFreeFn ( & bd - > InitInfo , font_tex - > hFontSrvCpuDescHandle , font_tex - > hFontSrvGpuDescHandle ) ;
2024-11-15 19:14:04 +01:00
SafeRelease ( font_tex - > pTextureResource ) ;
2024-11-15 19:02:26 +01:00
io . Fonts - > SetTexID ( 0 ) ; // We copied bd->hFontSrvGpuDescHandle to io.Fonts->TexID so let's clear that as well.
2016-02-23 00:22:48 +01:00
}
2024-11-15 19:02:26 +01:00
bool ImGui_ImplDX12_Init ( ImGui_ImplDX12_InitInfo * init_info )
2016-02-23 00:22:48 +01:00
{
2018-11-30 18:18:15 +01:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2024-05-13 15:07:13 +02:00
IMGUI_CHECKVERSION ( ) ;
2022-10-11 12:22:29 +02:00
IM_ASSERT ( io . BackendRendererUserData = = nullptr & & " Already initialized a renderer backend! " ) ;
2021-06-28 16:52:10 +02:00
2021-06-29 14:53:25 +02:00
// Setup backend capabilities flags
2021-06-30 15:22:15 +02:00
ImGui_ImplDX12_Data * bd = IM_NEW ( ImGui_ImplDX12_Data ) ( ) ;
2024-11-15 19:02:26 +01:00
bd - > InitInfo = * init_info ; // Deep copy
2024-11-18 15:16:41 +01:00
init_info = & bd - > InitInfo ;
2024-11-15 19:02:26 +01:00
bd - > pd3dDevice = init_info - > Device ;
bd - > RTVFormat = init_info - > RTVFormat ;
bd - > numFramesInFlight = init_info - > NumFramesInFlight ;
bd - > pd3dSrvDescHeap = init_info - > SrvDescriptorHeap ;
2021-06-29 14:53:25 +02:00
io . BackendRendererUserData = ( void * ) bd ;
2018-11-30 18:18:15 +01:00
io . BackendRendererName = " imgui_impl_dx12 " ;
2019-05-29 16:29:17 +02:00
io . BackendFlags | = ImGuiBackendFlags_RendererHasVtxOffset ; // We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes.
2021-06-29 14:53:25 +02:00
io . BackendFlags | = ImGuiBackendFlags_RendererHasViewports ; // We can create multi-viewports on the Renderer side (optional)
if ( io . ConfigFlags & ImGuiConfigFlags_ViewportsEnable )
ImGui_ImplDX12_InitPlatformInterface ( ) ;
2016-02-23 00:22:48 +01:00
2021-06-29 15:34:54 +02:00
// Create a dummy ImGui_ImplDX12_ViewportData holder for the main viewport,
2020-07-10 12:09:24 +02:00
// Since this is created and managed by the application, we will only use the ->Resources[] fields.
2019-10-17 15:53:43 +02:00
ImGuiViewport * main_viewport = ImGui : : GetMainViewport ( ) ;
2021-06-29 15:34:54 +02:00
main_viewport - > RendererUserData = IM_NEW ( ImGui_ImplDX12_ViewportData ) ( bd - > numFramesInFlight ) ;
2018-02-27 23:32:30 +01:00
2024-11-15 19:02:26 +01:00
# ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
2024-11-18 15:16:41 +01:00
if ( init_info - > SrvDescriptorAllocFn = = NULL )
{
// Wrap legacy behavior of passing space for a single descriptor
2024-11-15 19:02:26 +01:00
IM_ASSERT ( init_info - > LegacySingleSrvCpuDescriptor . ptr ! = 0 & & init_info - > LegacySingleSrvGpuDescriptor . ptr ! = 0 ) ;
2024-11-18 15:16:41 +01:00
init_info - > SrvDescriptorAllocFn = [ ] ( ImGui_ImplDX12_InitInfo * , D3D12_CPU_DESCRIPTOR_HANDLE * out_cpu_handle , D3D12_GPU_DESCRIPTOR_HANDLE * out_gpu_handle )
{
ImGui_ImplDX12_Data * bd = ImGui_ImplDX12_GetBackendData ( ) ;
IM_ASSERT ( bd - > LegacySingleDescriptorUsed = = false ) ;
* out_cpu_handle = bd - > InitInfo . LegacySingleSrvCpuDescriptor ;
* out_gpu_handle = bd - > InitInfo . LegacySingleSrvGpuDescriptor ;
bd - > LegacySingleDescriptorUsed = true ;
} ;
init_info - > SrvDescriptorFreeFn = [ ] ( ImGui_ImplDX12_InitInfo * , D3D12_CPU_DESCRIPTOR_HANDLE , D3D12_GPU_DESCRIPTOR_HANDLE )
{
ImGui_ImplDX12_Data * bd = ImGui_ImplDX12_GetBackendData ( ) ;
IM_ASSERT ( bd - > LegacySingleDescriptorUsed = = true ) ;
bd - > LegacySingleDescriptorUsed = false ;
} ;
2024-11-15 19:02:26 +01:00
}
2024-11-18 15:16:41 +01:00
# endif
// Allocate 1 SRV descriptor for the font texture
IM_ASSERT ( init_info - > SrvDescriptorAllocFn ! = NULL & & init_info - > SrvDescriptorFreeFn ! = NULL ) ;
init_info - > SrvDescriptorAllocFn ( & bd - > InitInfo , & bd - > FontTexture . hFontSrvCpuDescHandle , & bd - > FontTexture . hFontSrvGpuDescHandle ) ;
2016-02-23 00:22:48 +01:00
return true ;
}
2024-11-15 19:02:26 +01:00
# ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
// Legacy initialization API Obsoleted in 1.91.5
// font_srv_cpu_desc_handle and font_srv_gpu_desc_handle are handles to a single SRV descriptor to use for the internal font texture, they must be in 'srv_descriptor_heap'
bool ImGui_ImplDX12_Init ( ID3D12Device * device , int num_frames_in_flight , DXGI_FORMAT rtv_format , ID3D12DescriptorHeap * srv_descriptor_heap , D3D12_CPU_DESCRIPTOR_HANDLE font_srv_cpu_desc_handle , D3D12_GPU_DESCRIPTOR_HANDLE font_srv_gpu_desc_handle )
{
ImGui_ImplDX12_InitInfo init_info ;
init_info . Device = device ;
init_info . NumFramesInFlight = num_frames_in_flight ;
init_info . RTVFormat = rtv_format ;
init_info . SrvDescriptorHeap = srv_descriptor_heap ;
init_info . LegacySingleSrvCpuDescriptor = font_srv_cpu_desc_handle ;
init_info . LegacySingleSrvGpuDescriptor = font_srv_gpu_desc_handle ; ;
return ImGui_ImplDX12_Init ( & init_info ) ;
}
# endif
2016-02-23 00:22:48 +01:00
void ImGui_ImplDX12_Shutdown ( )
{
2021-06-28 16:52:10 +02:00
ImGui_ImplDX12_Data * bd = ImGui_ImplDX12_GetBackendData ( ) ;
2022-10-11 12:22:29 +02:00
IM_ASSERT ( bd ! = nullptr & & " No renderer backend to shutdown, or already shutdown? " ) ;
2021-09-20 18:43:05 +02:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2021-06-28 16:52:10 +02:00
2020-07-10 12:09:24 +02:00
// Manually delete main viewport render resources in-case we haven't initialized for viewports
ImGuiViewport * main_viewport = ImGui : : GetMainViewport ( ) ;
2021-06-29 15:34:54 +02:00
if ( ImGui_ImplDX12_ViewportData * vd = ( ImGui_ImplDX12_ViewportData * ) main_viewport - > RendererUserData )
2020-07-10 12:09:24 +02:00
{
// We could just call ImGui_ImplDX12_DestroyWindow(main_viewport) as a convenience but that would be misleading since we only use data->Resources[]
2021-06-29 14:53:25 +02:00
for ( UINT i = 0 ; i < bd - > numFramesInFlight ; i + + )
2021-06-29 15:34:54 +02:00
ImGui_ImplDX12_DestroyRenderBuffers ( & vd - > FrameRenderBuffers [ i ] ) ;
IM_DELETE ( vd ) ;
2022-10-11 15:59:23 +02:00
main_viewport - > RendererUserData = nullptr ;
2020-07-10 12:09:24 +02:00
}
// Clean up windows and device objects
2018-02-27 23:32:30 +01:00
ImGui_ImplDX12_ShutdownPlatformInterface ( ) ;
2016-02-23 00:22:48 +01:00
ImGui_ImplDX12_InvalidateDeviceObjects ( ) ;
2019-10-17 15:53:43 +02:00
2022-10-11 12:22:29 +02:00
io . BackendRendererName = nullptr ;
io . BackendRendererUserData = nullptr ;
2023-04-19 16:40:18 +02:00
io . BackendFlags & = ~ ( ImGuiBackendFlags_RendererHasVtxOffset | ImGuiBackendFlags_RendererHasViewports ) ;
2021-06-30 15:22:15 +02:00
IM_DELETE ( bd ) ;
2016-02-23 00:22:48 +01:00
}
2018-06-21 12:13:04 +02:00
void ImGui_ImplDX12_NewFrame ( )
2016-02-23 00:22:48 +01:00
{
2021-06-28 16:52:10 +02:00
ImGui_ImplDX12_Data * bd = ImGui_ImplDX12_GetBackendData ( ) ;
2024-05-07 16:53:03 +02:00
IM_ASSERT ( bd ! = nullptr & & " Context or backend not initialized! Did you call ImGui_ImplDX12_Init()? " ) ;
2021-06-29 17:53:41 +02:00
2021-06-28 16:52:10 +02:00
if ( ! bd - > pPipelineState )
2016-02-23 00:22:48 +01:00
ImGui_ImplDX12_CreateDeviceObjects ( ) ;
}
2018-02-27 23:32:30 +01:00
2018-03-18 18:44:57 +01:00
//--------------------------------------------------------------------------------------------------------
2018-04-24 17:09:50 +02:00
// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
2020-10-14 14:43:45 +02:00
// This is an _advanced_ and _optional_ feature, allowing the backend to create and handle multiple viewports simultaneously.
2018-04-24 17:09:50 +02:00
// If you are new to dear imgui or creating a new binding for dear imgui, it is recommended that you completely ignore this section first..
2018-03-18 18:44:57 +01:00
//--------------------------------------------------------------------------------------------------------
2018-02-27 23:32:30 +01:00
2018-03-18 18:44:57 +01:00
static void ImGui_ImplDX12_CreateWindow ( ImGuiViewport * viewport )
2018-02-27 23:32:30 +01:00
{
2021-06-29 14:53:25 +02:00
ImGui_ImplDX12_Data * bd = ImGui_ImplDX12_GetBackendData ( ) ;
2021-06-29 15:34:54 +02:00
ImGui_ImplDX12_ViewportData * vd = IM_NEW ( ImGui_ImplDX12_ViewportData ) ( bd - > numFramesInFlight ) ;
viewport - > RendererUserData = vd ;
2018-02-27 23:32:30 +01:00
2019-06-18 23:35:48 +02:00
// PlatformHandleRaw should always be a HWND, whereas PlatformHandle might be a higher-level handle (e.g. GLFWWindow*, SDL_Window*).
2023-04-11 16:19:59 +02:00
// Some backends will leave PlatformHandleRaw == 0, in which case we assume PlatformHandle will contain the HWND.
2019-06-18 23:35:48 +02:00
HWND hwnd = viewport - > PlatformHandleRaw ? ( HWND ) viewport - > PlatformHandleRaw : ( HWND ) viewport - > PlatformHandle ;
2018-02-27 23:32:30 +01:00
IM_ASSERT ( hwnd ! = 0 ) ;
2021-06-29 15:34:54 +02:00
vd - > FrameIndex = UINT_MAX ;
2019-10-17 15:53:43 +02:00
// Create command queue.
D3D12_COMMAND_QUEUE_DESC queue_desc = { } ;
queue_desc . Flags = D3D12_COMMAND_QUEUE_FLAG_NONE ;
queue_desc . Type = D3D12_COMMAND_LIST_TYPE_DIRECT ;
HRESULT res = S_OK ;
2021-06-29 15:34:54 +02:00
res = bd - > pd3dDevice - > CreateCommandQueue ( & queue_desc , IID_PPV_ARGS ( & vd - > CommandQueue ) ) ;
2019-10-17 15:53:43 +02:00
IM_ASSERT ( res = = S_OK ) ;
// Create command allocator.
2021-06-29 14:53:25 +02:00
for ( UINT i = 0 ; i < bd - > numFramesInFlight ; + + i )
2019-10-17 15:53:43 +02:00
{
2021-06-29 15:34:54 +02:00
res = bd - > pd3dDevice - > CreateCommandAllocator ( D3D12_COMMAND_LIST_TYPE_DIRECT , IID_PPV_ARGS ( & vd - > FrameCtx [ i ] . CommandAllocator ) ) ;
2019-10-17 15:53:43 +02:00
IM_ASSERT ( res = = S_OK ) ;
}
// Create command list.
2022-10-11 15:59:23 +02:00
res = bd - > pd3dDevice - > CreateCommandList ( 0 , D3D12_COMMAND_LIST_TYPE_DIRECT , vd - > FrameCtx [ 0 ] . CommandAllocator , nullptr , IID_PPV_ARGS ( & vd - > CommandList ) ) ;
2019-10-17 15:53:43 +02:00
IM_ASSERT ( res = = S_OK ) ;
2021-06-29 15:34:54 +02:00
vd - > CommandList - > Close ( ) ;
2019-10-17 15:53:43 +02:00
// Create fence.
2021-06-29 15:34:54 +02:00
res = bd - > pd3dDevice - > CreateFence ( 0 , D3D12_FENCE_FLAG_NONE , IID_PPV_ARGS ( & vd - > Fence ) ) ;
2019-10-17 15:53:43 +02:00
IM_ASSERT ( res = = S_OK ) ;
2022-10-11 15:59:23 +02:00
vd - > FenceEvent = CreateEvent ( nullptr , FALSE , FALSE , nullptr ) ;
IM_ASSERT ( vd - > FenceEvent ! = nullptr ) ;
2019-10-17 15:53:43 +02:00
2018-02-27 23:32:30 +01:00
// Create swap chain
2019-10-18 18:03:56 +02:00
// FIXME-VIEWPORT: May want to copy/inherit swap chain settings from the user/application.
2019-10-17 15:53:43 +02:00
DXGI_SWAP_CHAIN_DESC1 sd1 ;
ZeroMemory ( & sd1 , sizeof ( sd1 ) ) ;
2021-06-29 14:53:25 +02:00
sd1 . BufferCount = bd - > numFramesInFlight ;
2019-10-17 15:53:43 +02:00
sd1 . Width = ( UINT ) viewport - > Size . x ;
sd1 . Height = ( UINT ) viewport - > Size . y ;
2021-06-29 14:53:25 +02:00
sd1 . Format = bd - > RTVFormat ;
2019-10-17 15:53:43 +02:00
sd1 . BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT ;
sd1 . SampleDesc . Count = 1 ;
sd1 . SampleDesc . Quality = 0 ;
sd1 . SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD ;
sd1 . AlphaMode = DXGI_ALPHA_MODE_UNSPECIFIED ;
2023-12-20 10:34:37 +01:00
sd1 . Scaling = DXGI_SCALING_NONE ;
2019-10-17 15:53:43 +02:00
sd1 . Stereo = FALSE ;
2022-10-11 15:59:23 +02:00
IDXGIFactory4 * dxgi_factory = nullptr ;
2019-10-21 13:38:33 +02:00
res = : : CreateDXGIFactory1 ( IID_PPV_ARGS ( & dxgi_factory ) ) ;
2019-10-17 15:53:43 +02:00
IM_ASSERT ( res = = S_OK ) ;
2022-10-11 15:59:23 +02:00
IDXGISwapChain1 * swap_chain = nullptr ;
res = dxgi_factory - > CreateSwapChainForHwnd ( vd - > CommandQueue , hwnd , & sd1 , nullptr , nullptr , & swap_chain ) ;
2019-10-17 15:53:43 +02:00
IM_ASSERT ( res = = S_OK ) ;
dxgi_factory - > Release ( ) ;
// Or swapChain.As(&mSwapChain)
2022-10-11 15:59:23 +02:00
IM_ASSERT ( vd - > SwapChain = = nullptr ) ;
2021-06-29 15:34:54 +02:00
swap_chain - > QueryInterface ( IID_PPV_ARGS ( & vd - > SwapChain ) ) ;
2019-10-18 18:03:56 +02:00
swap_chain - > Release ( ) ;
2019-10-17 15:53:43 +02:00
// Create the render targets
2021-06-29 15:34:54 +02:00
if ( vd - > SwapChain )
2018-02-27 23:32:30 +01:00
{
2019-10-17 15:53:43 +02:00
D3D12_DESCRIPTOR_HEAP_DESC desc = { } ;
desc . Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV ;
2021-06-29 14:53:25 +02:00
desc . NumDescriptors = bd - > numFramesInFlight ;
2019-10-17 15:53:43 +02:00
desc . Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE ;
desc . NodeMask = 1 ;
2021-06-29 15:34:54 +02:00
HRESULT hr = bd - > pd3dDevice - > CreateDescriptorHeap ( & desc , IID_PPV_ARGS ( & vd - > RtvDescHeap ) ) ;
2020-04-13 15:22:27 +02:00
IM_ASSERT ( hr = = S_OK ) ;
2019-10-17 15:53:43 +02:00
2021-06-29 14:53:25 +02:00
SIZE_T rtv_descriptor_size = bd - > pd3dDevice - > GetDescriptorHandleIncrementSize ( D3D12_DESCRIPTOR_HEAP_TYPE_RTV ) ;
2021-06-29 15:34:54 +02:00
D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle = vd - > RtvDescHeap - > GetCPUDescriptorHandleForHeapStart ( ) ;
2021-06-29 14:53:25 +02:00
for ( UINT i = 0 ; i < bd - > numFramesInFlight ; i + + )
2019-10-17 15:53:43 +02:00
{
2021-06-29 15:34:54 +02:00
vd - > FrameCtx [ i ] . RenderTargetCpuDescriptors = rtv_handle ;
2019-10-17 15:53:43 +02:00
rtv_handle . ptr + = rtv_descriptor_size ;
}
ID3D12Resource * back_buffer ;
2021-06-29 14:53:25 +02:00
for ( UINT i = 0 ; i < bd - > numFramesInFlight ; i + + )
2019-10-17 15:53:43 +02:00
{
2022-10-11 15:59:23 +02:00
IM_ASSERT ( vd - > FrameCtx [ i ] . RenderTarget = = nullptr ) ;
2021-06-29 15:34:54 +02:00
vd - > SwapChain - > GetBuffer ( i , IID_PPV_ARGS ( & back_buffer ) ) ;
2022-10-11 15:59:23 +02:00
bd - > pd3dDevice - > CreateRenderTargetView ( back_buffer , nullptr , vd - > FrameCtx [ i ] . RenderTargetCpuDescriptors ) ;
2021-06-29 15:34:54 +02:00
vd - > FrameCtx [ i ] . RenderTarget = back_buffer ;
2019-10-17 15:53:43 +02:00
}
}
2021-06-29 14:53:25 +02:00
for ( UINT i = 0 ; i < bd - > numFramesInFlight ; i + + )
2021-06-29 15:34:54 +02:00
ImGui_ImplDX12_DestroyRenderBuffers ( & vd - > FrameRenderBuffers [ i ] ) ;
2019-10-17 15:53:43 +02:00
}
2021-06-29 15:34:54 +02:00
static void ImGui_WaitForPendingOperations ( ImGui_ImplDX12_ViewportData * vd )
2020-05-07 22:50:51 +02:00
{
HRESULT hr = S_FALSE ;
2021-06-29 15:34:54 +02:00
if ( vd & & vd - > CommandQueue & & vd - > Fence & & vd - > FenceEvent )
2020-05-07 22:50:51 +02:00
{
2021-06-29 15:34:54 +02:00
hr = vd - > CommandQueue - > Signal ( vd - > Fence , + + vd - > FenceSignaledValue ) ;
2020-05-07 22:50:51 +02:00
IM_ASSERT ( hr = = S_OK ) ;
2021-06-29 15:34:54 +02:00
: : WaitForSingleObject ( vd - > FenceEvent , 0 ) ; // Reset any forgotten waits
hr = vd - > Fence - > SetEventOnCompletion ( vd - > FenceSignaledValue , vd - > FenceEvent ) ;
2020-05-07 22:50:51 +02:00
IM_ASSERT ( hr = = S_OK ) ;
2021-06-29 15:34:54 +02:00
: : WaitForSingleObject ( vd - > FenceEvent , INFINITE ) ;
2020-05-07 22:50:51 +02:00
}
}
2018-03-18 18:44:57 +01:00
static void ImGui_ImplDX12_DestroyWindow ( ImGuiViewport * viewport )
2018-02-27 23:32:30 +01:00
{
2023-04-11 16:19:59 +02:00
// The main viewport (owned by the application) will always have RendererUserData == 0 since we didn't create the data for it.
2021-06-29 14:53:25 +02:00
ImGui_ImplDX12_Data * bd = ImGui_ImplDX12_GetBackendData ( ) ;
2021-06-29 15:34:54 +02:00
if ( ImGui_ImplDX12_ViewportData * vd = ( ImGui_ImplDX12_ViewportData * ) viewport - > RendererUserData )
2018-02-27 23:32:30 +01:00
{
2021-06-29 15:34:54 +02:00
ImGui_WaitForPendingOperations ( vd ) ;
2020-04-13 15:22:27 +02:00
2021-06-29 15:34:54 +02:00
SafeRelease ( vd - > CommandQueue ) ;
SafeRelease ( vd - > CommandList ) ;
SafeRelease ( vd - > SwapChain ) ;
SafeRelease ( vd - > RtvDescHeap ) ;
SafeRelease ( vd - > Fence ) ;
: : CloseHandle ( vd - > FenceEvent ) ;
2022-10-11 15:59:23 +02:00
vd - > FenceEvent = nullptr ;
2019-10-17 15:53:43 +02:00
2021-06-29 14:53:25 +02:00
for ( UINT i = 0 ; i < bd - > numFramesInFlight ; i + + )
2019-10-17 15:53:43 +02:00
{
2021-06-29 15:34:54 +02:00
SafeRelease ( vd - > FrameCtx [ i ] . RenderTarget ) ;
SafeRelease ( vd - > FrameCtx [ i ] . CommandAllocator ) ;
ImGui_ImplDX12_DestroyRenderBuffers ( & vd - > FrameRenderBuffers [ i ] ) ;
2019-10-17 15:53:43 +02:00
}
2021-06-29 15:34:54 +02:00
IM_DELETE ( vd ) ;
2018-02-27 23:32:30 +01:00
}
2022-10-11 15:59:23 +02:00
viewport - > RendererUserData = nullptr ;
2018-02-27 23:32:30 +01:00
}
2018-03-18 18:44:57 +01:00
static void ImGui_ImplDX12_SetWindowSize ( ImGuiViewport * viewport , ImVec2 size )
2018-02-27 23:32:30 +01:00
{
2021-06-29 14:53:25 +02:00
ImGui_ImplDX12_Data * bd = ImGui_ImplDX12_GetBackendData ( ) ;
2021-06-29 15:34:54 +02:00
ImGui_ImplDX12_ViewportData * vd = ( ImGui_ImplDX12_ViewportData * ) viewport - > RendererUserData ;
2019-10-17 15:53:43 +02:00
2021-06-29 15:34:54 +02:00
ImGui_WaitForPendingOperations ( vd ) ;
2020-05-07 22:50:51 +02:00
2021-06-29 14:53:25 +02:00
for ( UINT i = 0 ; i < bd - > numFramesInFlight ; i + + )
2021-06-29 15:34:54 +02:00
SafeRelease ( vd - > FrameCtx [ i ] . RenderTarget ) ;
2019-10-17 15:53:43 +02:00
2021-06-29 15:34:54 +02:00
if ( vd - > SwapChain )
2018-02-27 23:32:30 +01:00
{
2022-10-11 15:59:23 +02:00
ID3D12Resource * back_buffer = nullptr ;
2021-06-29 15:34:54 +02:00
vd - > SwapChain - > ResizeBuffers ( 0 , ( UINT ) size . x , ( UINT ) size . y , DXGI_FORMAT_UNKNOWN , 0 ) ;
2021-06-29 14:53:25 +02:00
for ( UINT i = 0 ; i < bd - > numFramesInFlight ; i + + )
2019-10-17 15:53:43 +02:00
{
2021-06-29 15:34:54 +02:00
vd - > SwapChain - > GetBuffer ( i , IID_PPV_ARGS ( & back_buffer ) ) ;
2022-10-11 15:59:23 +02:00
bd - > pd3dDevice - > CreateRenderTargetView ( back_buffer , nullptr , vd - > FrameCtx [ i ] . RenderTargetCpuDescriptors ) ;
2021-06-29 15:34:54 +02:00
vd - > FrameCtx [ i ] . RenderTarget = back_buffer ;
2019-10-17 15:53:43 +02:00
}
2018-02-27 23:32:30 +01:00
}
}
2019-10-17 15:53:43 +02:00
static void ImGui_ImplDX12_RenderWindow ( ImGuiViewport * viewport , void * )
2018-02-27 23:32:30 +01:00
{
2021-06-29 14:53:25 +02:00
ImGui_ImplDX12_Data * bd = ImGui_ImplDX12_GetBackendData ( ) ;
2021-06-29 15:34:54 +02:00
ImGui_ImplDX12_ViewportData * vd = ( ImGui_ImplDX12_ViewportData * ) viewport - > RendererUserData ;
2018-11-28 15:41:17 +01:00
2021-06-29 15:34:54 +02:00
ImGui_ImplDX12_FrameContext * frame_context = & vd - > FrameCtx [ vd - > FrameIndex % bd - > numFramesInFlight ] ;
UINT back_buffer_idx = vd - > SwapChain - > GetCurrentBackBufferIndex ( ) ;
2019-10-18 18:03:56 +02:00
const ImVec4 clear_color = ImVec4 ( 0.0f , 0.0f , 0.0f , 1.0f ) ;
2019-10-17 15:53:43 +02:00
D3D12_RESOURCE_BARRIER barrier = { } ;
barrier . Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION ;
barrier . Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE ;
2021-06-29 15:34:54 +02:00
barrier . Transition . pResource = vd - > FrameCtx [ back_buffer_idx ] . RenderTarget ;
2019-10-17 15:53:43 +02:00
barrier . Transition . Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES ;
barrier . Transition . StateBefore = D3D12_RESOURCE_STATE_PRESENT ;
barrier . Transition . StateAfter = D3D12_RESOURCE_STATE_RENDER_TARGET ;
2019-10-18 18:03:56 +02:00
// Draw
2021-06-29 15:34:54 +02:00
ID3D12GraphicsCommandList * cmd_list = vd - > CommandList ;
2019-10-17 15:53:43 +02:00
frame_context - > CommandAllocator - > Reset ( ) ;
2022-10-11 15:59:23 +02:00
cmd_list - > Reset ( frame_context - > CommandAllocator , nullptr ) ;
2019-10-17 15:53:43 +02:00
cmd_list - > ResourceBarrier ( 1 , & barrier ) ;
2022-10-11 15:59:23 +02:00
cmd_list - > OMSetRenderTargets ( 1 , & vd - > FrameCtx [ back_buffer_idx ] . RenderTargetCpuDescriptors , FALSE , nullptr ) ;
2018-03-15 17:52:53 +01:00
if ( ! ( viewport - > Flags & ImGuiViewportFlags_NoRendererClear ) )
2022-10-11 15:59:23 +02:00
cmd_list - > ClearRenderTargetView ( vd - > FrameCtx [ back_buffer_idx ] . RenderTargetCpuDescriptors , ( float * ) & clear_color , 0 , nullptr ) ;
2021-06-29 14:53:25 +02:00
cmd_list - > SetDescriptorHeaps ( 1 , & bd - > pd3dSrvDescHeap ) ;
2019-10-17 15:53:43 +02:00
ImGui_ImplDX12_RenderDrawData ( viewport - > DrawData , cmd_list ) ;
barrier . Transition . StateBefore = D3D12_RESOURCE_STATE_RENDER_TARGET ;
barrier . Transition . StateAfter = D3D12_RESOURCE_STATE_PRESENT ;
cmd_list - > ResourceBarrier ( 1 , & barrier ) ;
cmd_list - > Close ( ) ;
2021-06-29 15:34:54 +02:00
vd - > CommandQueue - > Wait ( vd - > Fence , vd - > FenceSignaledValue ) ;
vd - > CommandQueue - > ExecuteCommandLists ( 1 , ( ID3D12CommandList * const * ) & cmd_list ) ;
vd - > CommandQueue - > Signal ( vd - > Fence , + + vd - > FenceSignaledValue ) ;
2018-02-27 23:32:30 +01:00
}
2018-03-19 15:20:47 +01:00
static void ImGui_ImplDX12_SwapBuffers ( ImGuiViewport * viewport , void * )
2018-02-27 23:32:30 +01:00
{
2021-06-29 15:34:54 +02:00
ImGui_ImplDX12_ViewportData * vd = ( ImGui_ImplDX12_ViewportData * ) viewport - > RendererUserData ;
2019-10-17 15:53:43 +02:00
2021-06-29 15:34:54 +02:00
vd - > SwapChain - > Present ( 0 , 0 ) ;
while ( vd - > Fence - > GetCompletedValue ( ) < vd - > FenceSignaledValue )
2019-10-18 18:03:56 +02:00
: : SwitchToThread ( ) ;
2018-02-27 23:32:30 +01:00
}
void ImGui_ImplDX12_InitPlatformInterface ( )
{
2018-03-18 18:44:57 +01:00
ImGuiPlatformIO & platform_io = ImGui : : GetPlatformIO ( ) ;
platform_io . Renderer_CreateWindow = ImGui_ImplDX12_CreateWindow ;
platform_io . Renderer_DestroyWindow = ImGui_ImplDX12_DestroyWindow ;
platform_io . Renderer_SetWindowSize = ImGui_ImplDX12_SetWindowSize ;
platform_io . Renderer_RenderWindow = ImGui_ImplDX12_RenderWindow ;
platform_io . Renderer_SwapBuffers = ImGui_ImplDX12_SwapBuffers ;
2018-02-27 23:32:30 +01:00
}
void ImGui_ImplDX12_ShutdownPlatformInterface ( )
{
2020-03-06 17:53:09 +01:00
ImGui : : DestroyPlatformWindows ( ) ;
2018-02-27 23:32:30 +01:00
}
2023-07-20 23:18:47 +02:00
2023-07-13 11:27:52 +02:00
//-----------------------------------------------------------------------------
# endif // #ifndef IMGUI_DISABLE