// Load the rendering pipeline dependencies.
void D3D12HelloWindow::LoadPipeline()
{
UINT dxgiFactoryFlags = 0;
#if defined(_DEBUG)
// Enable the debug layer (requires the Graphics Tools "optional feature").
// NOTE: Enabling the debug layer after device creation will invalidate the active device.
{
ComPtr<ID3D12Debug> debugController;
if (SUCCEEDED(D3D12GetDebugInterface(IID_PPV_ARGS(&debugController))))
{
debugController->EnableDebugLayer();
// Enable additional debug layers.
dxgiFactoryFlags |= DXGI_CREATE_FACTORY_DEBUG;
}
}
#endif
ComPtr<IDXGIFactory4> factory;
ThrowIfFailed(CreateDXGIFactory2(dxgiFactoryFlags, IID_PPV_ARGS(&factory)));
if (m_useWarpDevice)
{
ComPtr<IDXGIAdapter> warpAdapter;
ThrowIfFailed(factory->EnumWarpAdapter(IID_PPV_ARGS(&warpAdapter)));
ThrowIfFailed(D3D12CreateDevice(
warpAdapter.Get(),
D3D_FEATURE_LEVEL_11_0,
IID_PPV_ARGS(&m_device)
));
}
else
{
ComPtr<IDXGIAdapter1> hardwareAdapter;
GetHardwareAdapter(factory.Get(), &hardwareAdapter);
ThrowIfFailed(D3D12CreateDevice(
hardwareAdapter.Get(),
D3D_FEATURE_LEVEL_11_0,
IID_PPV_ARGS(&m_device)
));
}
// Describe and create the 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)));
// Describe and create the swap chain.
DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {};
swapChainDesc.BufferCount = FrameCount;
swapChainDesc.Width = m_width;
swapChainDesc.Height = m_height;
swapChainDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
swapChainDesc.SampleDesc.Count = 1;
ComPtr<IDXGISwapChain1> swapChain;
ThrowIfFailed(factory->CreateSwapChainForCoreWindow(
m_commandQueue.Get(), // Swap chain needs the queue so that it can force a flush on it.
reinterpret_cast<IUnknown*>(Windows::UI::Core::CoreWindow::GetForCurrentThread()),
&swapChainDesc,
nullptr,
&swapChain
));
ThrowIfFailed(swapChain.As(&m_swapChain));
m_frameIndex = m_swapChain->GetCurrentBackBufferIndex();
// Create descriptor heaps.
{
// Describe and create a render target view (RTV) descriptor heap.
D3D12_DESCRIPTOR_HEAP_DESC rtvHeapDesc = {};
rtvHeapDesc.NumDescriptors = FrameCount;
rtvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
rtvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
ThrowIfFailed(m_device->CreateDescriptorHeap(&rtvHeapDesc, IID_PPV_ARGS(&m_rtvHeap)));
m_rtvDescriptorSize = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
}
// Create frame resources.
{
CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHandle(m_rtvHeap->GetCPUDescriptorHandleForHeapStart());
// Create a RTV for each frame.
for (UINT n = 0; n < FrameCount; n++)
{
ThrowIfFailed(m_swapChain->GetBuffer(n, IID_PPV_ARGS(&m_renderTargets[n])));
m_device->CreateRenderTargetView(m_renderTargets[n].Get(), nullptr, rtvHandle);
rtvHandle.Offset(1, m_rtvDescriptorSize);
}
}
ThrowIfFailed(m_device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&m_commandAllocator)));
}
// Load the rendering pipeline dependencies.
void D3D12Fullscreen::LoadPipeline()
{
UINT dxgiFactoryFlags = 0;
#if defined(_DEBUG)
// Enable the debug layer (requires the Graphics Tools "optional feature").
// NOTE: Enabling the debug layer after device creation will invalidate the active device.
{
ComPtr<ID3D12Debug> debugController;
if (SUCCEEDED(D3D12GetDebugInterface(IID_PPV_ARGS(&debugController))))
{
debugController->EnableDebugLayer();
// Enable additional debug layers.
dxgiFactoryFlags |= DXGI_CREATE_FACTORY_DEBUG;
}
}
#endif
ComPtr<IDXGIFactory4> factory;
ThrowIfFailed(CreateDXGIFactory2(dxgiFactoryFlags, IID_PPV_ARGS(&factory)));
if (m_useWarpDevice)
{
ComPtr<IDXGIAdapter> warpAdapter;
ThrowIfFailed(factory->EnumWarpAdapter(IID_PPV_ARGS(&warpAdapter)));
ThrowIfFailed(D3D12CreateDevice(
warpAdapter.Get(),
D3D_FEATURE_LEVEL_11_0,
IID_PPV_ARGS(&m_device)
));
}
else
{
ComPtr<IDXGIAdapter1> hardwareAdapter;
GetHardwareAdapter(factory.Get(), &hardwareAdapter);
ThrowIfFailed(D3D12CreateDevice(
hardwareAdapter.Get(),
D3D_FEATURE_LEVEL_11_0,
IID_PPV_ARGS(&m_device)
));
}
// Describe and create the 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)));
NAME_D3D12_OBJECT(m_commandQueue);
// Describe and create the swap chain.
// The resolution of the swap chain buffers will match the resolution of the window, enabling the
// app to enter iFlip when in fullscreen mode. We will also keep a separate buffer that is not part
// of the swap chain as an intermediate render target, whose resolution will control the rendering
// resolution of the scene.
DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {};
swapChainDesc.BufferCount = FrameCount;
swapChainDesc.Width = m_width;
swapChainDesc.Height = m_height;
swapChainDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
swapChainDesc.SampleDesc.Count = 1;
// It is recommended to always use the tearing flag when it is available.
swapChainDesc.Flags = m_tearingSupport ? DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING : 0;
ComPtr<IDXGISwapChain1> swapChain;
ThrowIfFailed(factory->CreateSwapChainForHwnd(
m_commandQueue.Get(), // Swap chain needs the queue so that it can force a flush on it.
Win32Application::GetHwnd(),
&swapChainDesc,
nullptr,
nullptr,
&swapChain
));
if (m_tearingSupport)
{
// When tearing support is enabled we will handle ALT+Enter key presses in the
// window message loop rather than let DXGI handle it by calling SetFullscreenState.
factory->MakeWindowAssociation(Win32Application::GetHwnd(), DXGI_MWA_NO_ALT_ENTER);
}
ThrowIfFailed(swapChain.As(&m_swapChain));
m_frameIndex = m_swapChain->GetCurrentBackBufferIndex();
// Create descriptor heaps.
{
// Describe and create a render target view (RTV) descriptor heap.
D3D12_DESCRIPTOR_HEAP_DESC rtvHeapDesc = {};
rtvHeapDesc.NumDescriptors = FrameCount + 1; // + 1 for the intermediate render target.
rtvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
rtvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
ThrowIfFailed(m_device->CreateDescriptorHeap(&rtvHeapDesc, IID_PPV_ARGS(&m_rtvHeap)));
// Describe and create a constant buffer view (CBV) and shader resource view (SRV) descriptor heap.
D3D12_DESCRIPTOR_HEAP_DESC cbvSrvHeapDesc = {};
cbvSrvHeapDesc.NumDescriptors = FrameCount + 1; // One CBV per frame and one SRV for the intermediate render target.
cbvSrvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
cbvSrvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
ThrowIfFailed(m_device->CreateDescriptorHeap(&cbvSrvHeapDesc, IID_PPV_ARGS(&m_cbvSrvHeap)));
m_rtvDescriptorSize = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
m_cbvSrvDescriptorSize = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
}
// Create command allocators for each frame.
for (UINT n = 0; n < FrameCount; n++)
{
ThrowIfFailed(m_device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&m_sceneCommandAllocators[n])));
ThrowIfFailed(m_device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&m_postCommandAllocators[n])));
}
}
// Load the rendering pipeline dependencies.
void D3D12PipelineStateCache::LoadPipeline()
{
UINT dxgiFactoryFlags = 0;
#if defined(_DEBUG)
// Enable the debug layer (requires the Graphics Tools "optional feature").
// NOTE: Enabling the debug layer after device creation will invalidate the active device.
{
ComPtr<ID3D12Debug> debugController;
if (SUCCEEDED(D3D12GetDebugInterface(IID_PPV_ARGS(&debugController))))
{
debugController->EnableDebugLayer();
// Enable additional debug layers.
dxgiFactoryFlags |= DXGI_CREATE_FACTORY_DEBUG;
}
}
#endif
ComPtr<IDXGIFactory4> factory;
ThrowIfFailed(CreateDXGIFactory2(dxgiFactoryFlags, IID_PPV_ARGS(&factory)));
if (m_useWarpDevice)
{
ComPtr<IDXGIAdapter> warpAdapter;
ThrowIfFailed(factory->EnumWarpAdapter(IID_PPV_ARGS(&warpAdapter)));
ThrowIfFailed(D3D12CreateDevice(
warpAdapter.Get(),
D3D_FEATURE_LEVEL_11_0,
IID_PPV_ARGS(&m_device)
));
}
else
{
ComPtr<IDXGIAdapter1> hardwareAdapter;
GetHardwareAdapter(factory.Get(), &hardwareAdapter);
ThrowIfFailed(D3D12CreateDevice(
hardwareAdapter.Get(),
D3D_FEATURE_LEVEL_11_0,
IID_PPV_ARGS(&m_device)
));
}
// Describe and create the 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)));
NAME_D3D12_OBJECT(m_commandQueue);
// Describe and create the swap chain.
DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {};
swapChainDesc.BufferCount = FrameCount;
swapChainDesc.Width = m_width;
swapChainDesc.Height = m_height;
swapChainDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.Flags = DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT;
ComPtr<IDXGISwapChain1> swapChain;
ThrowIfFailed(factory->CreateSwapChainForHwnd(
m_commandQueue.Get(), // Swap chain needs the queue so that it can force a flush on it.
Win32Application::GetHwnd(),
&swapChainDesc,
nullptr,
nullptr,
&swapChain
));
// This sample does not support fullscreen transitions.
ThrowIfFailed(factory->MakeWindowAssociation(Win32Application::GetHwnd(), DXGI_MWA_NO_ALT_ENTER));
ThrowIfFailed(swapChain.As(&m_swapChain));
m_frameIndex = m_swapChain->GetCurrentBackBufferIndex();
m_swapChainEvent = m_swapChain->GetFrameLatencyWaitableObject();
// Create descriptor heaps.
{
// Describe and create a render target view (RTV) descriptor heap.
D3D12_DESCRIPTOR_HEAP_DESC rtvHeapDesc = {};
rtvHeapDesc.NumDescriptors = FrameCount + 1; // A descriptor for each frame + 1 intermediate render target.
rtvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
rtvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
ThrowIfFailed(m_device->CreateDescriptorHeap(&rtvHeapDesc, IID_PPV_ARGS(&m_rtvHeap)));
// Describe and create a shader resource view (SRV) descriptor heap.
D3D12_DESCRIPTOR_HEAP_DESC srvHeapDesc = {};
srvHeapDesc.NumDescriptors = 1;
srvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
srvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
ThrowIfFailed(m_device->CreateDescriptorHeap(&srvHeapDesc, IID_PPV_ARGS(&m_srvHeap)));
NAME_D3D12_OBJECT(m_srvHeap);
m_rtvDescriptorSize = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
m_srvDescriptorSize = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
}
// Create frame resources.
{
CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHandle(m_rtvHeap->GetCPUDescriptorHandleForHeapStart());
// Create RTVs and a command allocator for each frame.
for (UINT n = 0; n < FrameCount; n++)
{
ThrowIfFailed(m_swapChain->GetBuffer(n, IID_PPV_ARGS(&m_renderTargets[n])));
m_device->CreateRenderTargetView(m_renderTargets[n].Get(), nullptr, rtvHandle);
rtvHandle.Offset(1, m_rtvDescriptorSize);
NAME_D3D12_OBJECT_INDEXED(m_renderTargets, n);
ThrowIfFailed(m_device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&m_commandAllocators[n])));
}
D3D12_RESOURCE_DESC renderTargetDesc = m_renderTargets[0]->GetDesc();
D3D12_CLEAR_VALUE clearValue = {};
memcpy(clearValue.Color, IntermediateClearColor, sizeof(IntermediateClearColor));
clearValue.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
// Create an intermediate render target that is the same dimensions as the swap chain.
ThrowIfFailed(m_device->CreateCommittedResource(
&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT),
D3D12_HEAP_FLAG_NONE,
&renderTargetDesc,
D3D12_RESOURCE_STATE_RENDER_TARGET,
&clearValue,
IID_PPV_ARGS(&m_intermediateRenderTarget)));
NAME_D3D12_OBJECT(m_intermediateRenderTarget);
m_device->CreateRenderTargetView(m_intermediateRenderTarget.Get(), nullptr, rtvHandle);
rtvHandle.Offset(1, m_rtvDescriptorSize);
// Create a SRV of the intermediate render target.
D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {};
srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
srvDesc.Format = renderTargetDesc.Format;
srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
srvDesc.Texture2D.MipLevels = 1;
CD3DX12_CPU_DESCRIPTOR_HANDLE srvHandle(m_srvHeap->GetCPUDescriptorHandleForHeapStart());
m_device->CreateShaderResourceView(m_intermediateRenderTarget.Get(), &srvDesc, srvHandle);
}
}
// Load the rendering pipeline dependencies.
void D3D12DynamicIndexing::LoadPipeline()
{
UINT dxgiFactoryFlags = 0;
#if defined(_DEBUG)
// Enable the debug layer (requires the Graphics Tools "optional feature").
// NOTE: Enabling the debug layer after device creation will invalidate the active device.
{
ComPtr<ID3D12Debug> debugController;
if (SUCCEEDED(D3D12GetDebugInterface(IID_PPV_ARGS(&debugController))))
{
debugController->EnableDebugLayer();
// Enable additional debug layers.
dxgiFactoryFlags |= DXGI_CREATE_FACTORY_DEBUG;
}
}
#endif
ComPtr<IDXGIFactory4> factory;
ThrowIfFailed(CreateDXGIFactory2(dxgiFactoryFlags, IID_PPV_ARGS(&factory)));
if (m_useWarpDevice)
{
ComPtr<IDXGIAdapter> warpAdapter;
ThrowIfFailed(factory->EnumWarpAdapter(IID_PPV_ARGS(&warpAdapter)));
ThrowIfFailed(D3D12CreateDevice(
warpAdapter.Get(),
D3D_FEATURE_LEVEL_11_0,
IID_PPV_ARGS(&m_device)
));
}
else
{
ComPtr<IDXGIAdapter1> hardwareAdapter;
GetHardwareAdapter(factory.Get(), &hardwareAdapter);
ThrowIfFailed(D3D12CreateDevice(
hardwareAdapter.Get(),
D3D_FEATURE_LEVEL_11_0,
IID_PPV_ARGS(&m_device)
));
}
// Describe and create the 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)));
NAME_D3D12_OBJECT(m_commandQueue);
// Describe and create the swap chain.
DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {};
swapChainDesc.BufferCount = FrameCount;
swapChainDesc.Width = m_width;
swapChainDesc.Height = m_height;
swapChainDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
swapChainDesc.SampleDesc.Count = 1;
ComPtr<IDXGISwapChain1> swapChain;
ThrowIfFailed(factory->CreateSwapChainForHwnd(
m_commandQueue.Get(), // Swap chain needs the queue so that it can force a flush on it.
Win32Application::GetHwnd(),
&swapChainDesc,
nullptr,
nullptr,
&swapChain
));
// This sample does not support fullscreen transitions.
ThrowIfFailed(factory->MakeWindowAssociation(Win32Application::GetHwnd(), DXGI_MWA_NO_ALT_ENTER));
ThrowIfFailed(swapChain.As(&m_swapChain));
m_frameIndex = m_swapChain->GetCurrentBackBufferIndex();
// Create descriptor heaps.
{
// Describe and create a render target view (RTV) descriptor heap.
D3D12_DESCRIPTOR_HEAP_DESC rtvHeapDesc = {};
rtvHeapDesc.NumDescriptors = FrameCount;
rtvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
rtvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
ThrowIfFailed(m_device->CreateDescriptorHeap(&rtvHeapDesc, IID_PPV_ARGS(&m_rtvHeap)));
// Describe and create a depth stencil view (DSV) descriptor heap.
D3D12_DESCRIPTOR_HEAP_DESC dsvHeapDesc = {};
dsvHeapDesc.NumDescriptors = 1;
dsvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_DSV;
dsvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
ThrowIfFailed(m_device->CreateDescriptorHeap(&dsvHeapDesc, IID_PPV_ARGS(&m_dsvHeap)));
// Describe and create a shader resource view (SRV) and constant
// buffer view (CBV) descriptor heap.
D3D12_DESCRIPTOR_HEAP_DESC cbvSrvHeapDesc = {};
cbvSrvHeapDesc.NumDescriptors =
FrameCount * CityRowCount * CityColumnCount + // FrameCount frames * CityRowCount * CityColumnCount.
CityMaterialCount + 1; // CityMaterialCount + 1 for the SRVs.
cbvSrvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
cbvSrvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
ThrowIfFailed(m_device->CreateDescriptorHeap(&cbvSrvHeapDesc, IID_PPV_ARGS(&m_cbvSrvHeap)));
NAME_D3D12_OBJECT(m_cbvSrvHeap);
// Describe and create a sampler descriptor heap.
D3D12_DESCRIPTOR_HEAP_DESC samplerHeapDesc = {};
samplerHeapDesc.NumDescriptors = 1;
samplerHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER;
samplerHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
ThrowIfFailed(m_device->CreateDescriptorHeap(&samplerHeapDesc, IID_PPV_ARGS(&m_samplerHeap)));
m_rtvDescriptorSize = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
m_cbvSrvDescriptorSize = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
}
ThrowIfFailed(m_device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&m_commandAllocator)));
}
bool TestRenderer::Initialize()
{
UINT d3dFlag = 0;
#if defined(_DEBUG)
d3dFlag |= D3D11_CREATE_DEVICE_DEBUG;
#endif
D3D_FEATURE_LEVEL featureLevel = D3D_FEATURE_LEVEL_11_0;
HRESULT hr = D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr,
d3dFlag, &featureLevel, 1, D3D11_SDK_VERSION, &Device, nullptr, &Context);
if (FAILED(hr))
{
// Did it fail because we're requesting the debug layer and it's not present on this machine?
if (d3dFlag == D3D11_CREATE_DEVICE_DEBUG && hr == DXGI_ERROR_SDK_COMPONENT_MISSING)
{
// Try again without debug layer
d3dFlag &= ~D3D11_CREATE_DEVICE_DEBUG;
hr = D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr,
d3dFlag, &featureLevel, 1, D3D11_SDK_VERSION, &Device, nullptr, &Context);
}
if (FAILED(hr))
{
LogError(L"Failed to create D3D11 device.");
return false;
}
}
UINT dxgiFlag = 0;
#if defined(_DEBUG)
dxgiFlag |= DXGI_CREATE_FACTORY_DEBUG;
#endif
ComPtr<IDXGIFactory> factory;
hr = CreateDXGIFactory2(dxgiFlag, IID_PPV_ARGS(&factory));
if (FAILED(hr))
{
LogError(L"Failed to create DXGI factory.");
return false;
}
DXGI_SWAP_CHAIN_DESC scd{};
scd.BufferCount = 2;
scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
#if USE_SRGB
scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
#else
scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
#endif
scd.SampleDesc.Count = 4;
scd.OutputWindow = Window;
scd.Windowed = TRUE;
hr = factory->CreateSwapChain(Device.Get(), &scd, &SwapChain);
if (FAILED(hr))
{
LogError(L"Failed to create swapchain.");
return false;
}
ComPtr<ID3D11Texture2D> texture;
hr = SwapChain->GetBuffer(0, IID_PPV_ARGS(&texture));
if (FAILED(hr))
{
LogError(L"Failed to get backbuffer.");
return false;
}
hr = Device->CreateRenderTargetView(texture.Get(), nullptr, &RenderTarget);
if (FAILED(hr))
{
LogError(L"Failed to get backbuffer.");
return false;
}
D3D11_TEXTURE2D_DESC td{};
texture->GetDesc(&td);
td.BindFlags = D3D11_BIND_DEPTH_STENCIL;
td.Format = DXGI_FORMAT_D32_FLOAT;
hr = Device->CreateTexture2D(&td, nullptr, texture.ReleaseAndGetAddressOf());
if (FAILED(hr))
{
LogError(L"Failed to create depth texture.");
return false;
}
hr = Device->CreateDepthStencilView(texture.Get(), nullptr, &DepthBuffer);
if (FAILED(hr))
{
LogError(L"Failed to create depth stencil view.");
return false;
}
hr = Device->CreateVertexShader(SimpleTransformVS, sizeof(SimpleTransformVS), nullptr, &VertexShader);
if (FAILED(hr))
{
LogError(L"Failed to create vertex shader.");
return false;
}
hr = Device->CreatePixelShader(SimpleTexturePS, sizeof(SimpleTexturePS), nullptr, &PixelShader);
if (FAILED(hr))
{
LogError(L"Failed to create pixel shader.");
return false;
}
D3D11_INPUT_ELEMENT_DESC elems[5] {};
elems[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
elems[0].SemanticName = "POSITION";
elems[1].AlignedByteOffset = sizeof(XMFLOAT3);
elems[1].Format = DXGI_FORMAT_R32G32B32_FLOAT;
elems[1].SemanticName = "NORMAL";
elems[2].AlignedByteOffset = sizeof(XMFLOAT3) * 2;
elems[2].Format = DXGI_FORMAT_R32G32B32_FLOAT;
elems[2].SemanticName = "TANGENT";
elems[3].AlignedByteOffset = sizeof(XMFLOAT3) * 2;
elems[3].Format = DXGI_FORMAT_R32G32B32_FLOAT;
elems[3].SemanticName = "BITANGENT";
elems[4].AlignedByteOffset = sizeof(XMFLOAT3) * 4;
elems[4].Format = DXGI_FORMAT_R32G32_FLOAT;
elems[4].SemanticName = "TEXCOORD";
hr = Device->CreateInputLayout(elems, _countof(elems), SimpleTransformVS, sizeof(SimpleTransformVS), &InputLayout);
if (FAILED(hr))
{
LogError(L"Failed to create input layout.");
return false;
}
D3D11_BUFFER_DESC bd = {};
bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
bd.ByteWidth = sizeof(Constants);
bd.StructureByteStride = bd.ByteWidth;
bd.Usage = D3D11_USAGE_DYNAMIC;
bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
hr = Device->CreateBuffer(&bd, nullptr, &ConstantBuffer);
if (FAILED(hr))
{
LogError(L"Failed to create constant buffer.");
return false;
}
bd.ByteWidth = sizeof(LightConstants);
bd.StructureByteStride = bd.ByteWidth;
bd.Usage = D3D11_USAGE_DEFAULT;
bd.CPUAccessFlags = 0;
hr = Device->CreateBuffer(&bd, nullptr, &LightsConstantBuffer);
if (FAILED(hr))
{
LogError(L"Failed to create constant buffer.");
return false;
}
D3D11_SAMPLER_DESC sd = {};
sd.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
sd.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
sd.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
sd.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
sd.MaxLOD = 12;
hr = Device->CreateSamplerState(&sd, &Sampler);
if (FAILED(hr))
{
LogError(L"Failed to create sampler.");
return false;
}
D3D11_RASTERIZER_DESC rd = {};
rd.FrontCounterClockwise = TRUE;
rd.AntialiasedLineEnable = TRUE;
rd.FillMode = D3D11_FILL_SOLID;
rd.CullMode = D3D11_CULL_BACK;
rd.DepthClipEnable = TRUE;
hr = Device->CreateRasterizerState(&rd, &RasterizerState);
if (FAILED(hr))
{
LogError(L"Failed to create rasterizer state.");
return false;
}
RECT rc{};
GetClientRect(Window, &rc);
D3D11_VIEWPORT vp = {};
vp.Width = (float)(rc.right - rc.left);
vp.Height = (float)(rc.bottom - rc.top);
vp.MaxDepth = 1.f;
Context->OMSetRenderTargets(1, RenderTarget.GetAddressOf(), DepthBuffer.Get());
Context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
Context->IASetInputLayout(InputLayout.Get());
Context->VSSetShader(VertexShader.Get(), nullptr, 0);
Context->PSSetShader(PixelShader.Get(), nullptr, 0);
Context->VSSetConstantBuffers(0, 1, ConstantBuffer.GetAddressOf());
Context->PSSetSamplers(0, 1, Sampler.GetAddressOf());
Context->PSSetConstantBuffers(0, 1, LightsConstantBuffer.GetAddressOf());
Context->RSSetState(RasterizerState.Get());
Context->RSSetViewports(1, &vp);
return true;
}
bool PngViewer::init_d2d()
{
DXGI_SWAP_CHAIN_DESC1 swap_descriptor;
RECT client_rect;
ID3D11Device * device;
IDXGISwapChain1 * swap_chain_1;
HRESULT r;
if(D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, D3D11_CREATE_DEVICE_BGRA_SUPPORT, nullptr, 0, D3D11_SDK_VERSION, &device, nullptr, nullptr) != S_OK)
{
return false;
}
r = device->QueryInterface(__uuidof(IDXGIDevice3), (void **)&this->device_gi);
device->Release();
if(r != S_OK)
{
return false;
}
if(CreateDXGIFactory2(DXGI_CREATE_FACTORY_DEBUG, __uuidof(IDXGIFactory3), (void **)&this->gi_factory) != S_OK)
{
return false;
}
::GetClientRect(this->window, &client_rect);
this->swap_chain_region.cx = client_rect.right - client_rect.left;
this->swap_chain_region.cy = client_rect.bottom - client_rect.top;
::memset(&swap_descriptor, 0, sizeof(DXGI_SWAP_CHAIN_DESC1));
swap_descriptor.Width = this->swap_chain_region.cx;
swap_descriptor.Height = this->swap_chain_region.cy;
swap_descriptor.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
swap_descriptor.SampleDesc.Count = 1;
swap_descriptor.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swap_descriptor.BufferCount = 2;
swap_descriptor.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
swap_descriptor.AlphaMode = DXGI_ALPHA_MODE_PREMULTIPLIED;
if(this->gi_factory->CreateSwapChainForComposition(this->device_gi, &swap_descriptor, nullptr, &swap_chain_1) != S_OK)
{
return false;
}
r = swap_chain_1->QueryInterface(__uuidof(IDXGISwapChain2), (void **)&this->swap_chain);
swap_chain_1->Release();
if(r != S_OK)
{
return false;
}
if(DCompositionCreateDevice(this->device_gi, __uuidof(IDCompositionDevice), (void **)&this->comp_device) != S_OK)
{
return false;
}
if(this->comp_device->CreateTargetForHwnd(this->window, true, &this->comp_target) != S_OK)
{
return false;
}
if(this->comp_device->CreateVisual(&this->comp_visual) != S_OK)
{
return false;
}
this->comp_visual->SetContent(this->swap_chain);
this->comp_target->SetRoot(this->comp_visual);
this->comp_device->Commit();
return true;
}
//-------------------------------------------------------------------------------------------------
// D3D12の初期化処理です.
//-------------------------------------------------------------------------------------------------
bool App::InitD3D()
{
HRESULT hr = S_OK;
// ウィンドウ幅を取得.
RECT rc;
GetClientRect( m_hWnd, &rc );
u32 w = rc.right - rc.left;
u32 h = rc.bottom - rc.top;
UINT flags = 0;
#if defined(DEBUG) || defined(_DEBUG)
ID3D12Debug* pDebug;
D3D12GetDebugInterface(IID_ID3D12Debug, (void**)&pDebug);
if (pDebug)
{
pDebug->EnableDebugLayer();
pDebug->Release();
}
flags |= DXGI_CREATE_FACTORY_DEBUG;
#endif
hr = CreateDXGIFactory2(flags, IID_IDXGIFactory4, (void**)m_Factory.GetAddress());
if (FAILED(hr))
{
ELOG("Error : CreateDXGIFactory() Failed.");
return false;
}
hr = m_Factory->EnumAdapters(0, m_Adapter.GetAddress());
if (FAILED(hr))
{
ELOG("Error : IDXGIFactory::EnumAdapters() Failed.");
return false;
}
// デバイス生成.
hr = D3D12CreateDevice(
m_Adapter.GetPtr(),
D3D_FEATURE_LEVEL_11_0,
IID_ID3D12Device,
(void**)m_Device.GetAddress() );
// 生成チェック.
if ( FAILED( hr ) )
{
// Warpアダプターで再トライ.
m_Adapter.Reset();
m_Device.Reset();
hr = m_Factory->EnumWarpAdapter(IID_PPV_ARGS(m_Adapter.GetAddress()));
if (FAILED(hr))
{
ELOG("Error : IDXGIFactory::EnumWarpAdapter() Failed.");
return false;
}
// デバイス生成.
hr = D3D12CreateDevice(
m_Adapter.GetPtr(),
D3D_FEATURE_LEVEL_11_0,
IID_ID3D12Device,
(void**)m_Device.GetAddress());
if (FAILED(hr))
{
ELOG("Error: D3D12CreateDevice() Failed.");
return false;
}
}
// コマンドアロケータを生成.
hr = m_Device->CreateCommandAllocator(
D3D12_COMMAND_LIST_TYPE_DIRECT,
IID_ID3D12CommandAllocator,
(void**)m_CmdAllocator.GetAddress() );
if ( FAILED( hr ) )
{
ELOG( "Error : ID3D12Device::CreateCommandAllocator() Failed." );
return false;
}
// コマンドキューを生成.
{
D3D12_COMMAND_QUEUE_DESC desc;
ZeroMemory( &desc, sizeof(desc) );
desc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
desc.Priority = 0;
desc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
hr = m_Device->CreateCommandQueue( &desc, IID_ID3D12CommandQueue, (void**)m_CmdQueue.GetAddress() );
if ( FAILED( hr ) )
{
ELOG( "Error : ID3D12Device::CreateCommandQueue() Failed." );
return false;
}
}
// スワップチェインを生成.
{
DXGI_SWAP_CHAIN_DESC desc;
ZeroMemory( &desc, sizeof(desc) );
desc.BufferCount = m_BufferCount;
desc.BufferDesc.Format = m_SwapChainFormat;
desc.BufferDesc.Width = w;
desc.BufferDesc.Height = h;
desc.BufferDesc.RefreshRate.Numerator = 60;
desc.BufferDesc.RefreshRate.Denominator = 1;
desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT;
desc.OutputWindow = m_hWnd;
desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0;
desc.Windowed = TRUE;
desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
desc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
// アダプター単位の処理にマッチするのは m_Device ではなく m_CmdQueue なので，m_CmdQueue を第一引数として渡す.
hr = m_Factory->CreateSwapChain( m_CmdQueue.GetPtr(), &desc, m_SwapChain.GetAddress() );
if ( FAILED( hr ) )
{
ELOG( "Error : IDXGIFactory::CreateSwapChain() Failed." );
return false;
}
}
// デスクリプタヒープの生成.
{
D3D12_DESCRIPTOR_HEAP_DESC desc;
ZeroMemory( &desc, sizeof(desc) );
desc.NumDescriptors = 1;
desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
hr = m_Device->CreateDescriptorHeap( &desc, IID_ID3D12DescriptorHeap, (void**)m_DescriptorHeap.GetAddress() );
if ( FAILED( hr ) )
{
ELOG( "Error : ID3D12Device::CreateDescriptorHeap() Failed." );
return false;
}
}
// コマンドリストの生成.
{
hr = m_Device->CreateCommandList(
1,
D3D12_COMMAND_LIST_TYPE_DIRECT,
m_CmdAllocator.GetPtr(),
nullptr,
IID_ID3D12GraphicsCommandList,
(void**)m_CmdList.GetAddress() );
if ( FAILED( hr ) )
{
ELOG( "Error : ID3D12Device::CreateCommandList() Failed." );
return false;
}
}
// バックバッファからレンダーターゲットを生成.
{
hr = m_SwapChain->GetBuffer( 0, IID_ID3D12Resource, (void**)m_ColorTarget.GetAddress() );
if ( FAILED( hr ) )
{
ELOG( "Error : IDXGISwapChain::GetBuffer() Failed." );
return false;
}
m_ColorTargetHandle = m_DescriptorHeap->GetCPUDescriptorHandleForHeapStart();
m_Device->CreateRenderTargetView( m_ColorTarget.GetPtr(), nullptr, m_ColorTargetHandle );
}
// フェンスの生成.
{
m_EventHandle = CreateEvent( 0, FALSE, FALSE, 0 );
hr = m_Device->CreateFence( 0, D3D12_FENCE_FLAG_NONE, IID_ID3D12Fence, (void**)m_Fence.GetAddress() );
if ( FAILED( hr ) )
{
ELOG( "Error : ID3D12Device::CreateFence() Failed." );
return false;
}
}
// ビューポートの設定.
{
m_Viewport.TopLeftX = 0;
m_Viewport.TopLeftY = 0;
m_Viewport.Width = FLOAT(w);
m_Viewport.Height = FLOAT(h);
m_Viewport.MinDepth = 0.0f;
m_Viewport.MaxDepth = 1.0f;
}
// 正常終了.
return true;
}
void QD3D12WindowPrivate::initialize()
{
Q_Q(QD3D12Window);
if (initialized)
return;
swapChainBufferCount = 2;
HWND hwnd = reinterpret_cast<HWND>(q->winId());
ComPtr<ID3D12Debug> debugController;
if (SUCCEEDED(D3D12GetDebugInterface(IID_PPV_ARGS(&debugController))))
debugController->EnableDebugLayer();
ComPtr<IDXGIFactory4> factory;
if (FAILED(CreateDXGIFactory2(0, IID_PPV_ARGS(&factory)))) {
qWarning("Failed to create DXGI");
return;
}
ComPtr<IDXGIAdapter1> adapter;
getHardwareAdapter(factory.Get(), &adapter);
bool warp = true;
if (adapter) {
HRESULT hr = D3D12CreateDevice(adapter.Get(), D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&device));
if (SUCCEEDED(hr))
warp = false;
else
qWarning("Failed to create device: 0x%x", hr);
} else {
qWarning("No usable hardware adapters found");
}
if (warp) {
qDebug("Using WARP");
ComPtr<IDXGIAdapter> warpAdapter;
factory->EnumWarpAdapter(IID_PPV_ARGS(&warpAdapter));
HRESULT hr = D3D12CreateDevice(warpAdapter.Get(), D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&device));
if (FAILED(hr)) {
qWarning("Failed to create WARP device: 0x%x", hr);
return;
}
}
D3D12_COMMAND_QUEUE_DESC queueDesc = {};
queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
if (FAILED(device->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&commandQueue)))) {
qWarning("Failed to create command queue");
return;
}
DXGI_SWAP_CHAIN_DESC swapChainDesc = {};
swapChainDesc.BufferCount = swapChainBufferCount;
swapChainDesc.BufferDesc.Width = q->width() * q->devicePixelRatio();
swapChainDesc.BufferDesc.Height = q->height() * q->devicePixelRatio();
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD; // D3D12 requires the flip model
swapChainDesc.OutputWindow = hwnd;
swapChainDesc.SampleDesc.Count = 1; // Flip does not support MSAA so no choice here
swapChainDesc.Windowed = TRUE;
ComPtr<IDXGISwapChain> baseSwapChain;
HRESULT hr = factory->CreateSwapChain(commandQueue.Get(), &swapChainDesc, &baseSwapChain);
if (FAILED(hr)) {
qWarning("Failed to create swap chain: 0x%x", hr);
return;
}
if (FAILED(baseSwapChain.As(&swapChain))) {
qWarning("Failed to cast swap chain");
return;
}
factory->MakeWindowAssociation(hwnd, DXGI_MWA_NO_ALT_ENTER);
if (FAILED(device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&commandAllocator)))) {
qWarning("Failed to create command allocator");
return;
}
if (FAILED(device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_BUNDLE, IID_PPV_ARGS(&bundleAllocator)))) {
qWarning("Failed to create command bundle allocator");
return;
}
D3D12_DESCRIPTOR_HEAP_DESC rtvHeapDesc = {};
rtvHeapDesc.NumDescriptors = swapChainBufferCount + extraRenderTargetCount;
rtvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
if (FAILED(device->CreateDescriptorHeap(&rtvHeapDesc, IID_PPV_ARGS(&rtvHeap)))) {
qWarning("Failed to create render target view descriptor heap");
return;
}
rtvStride = device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
D3D12_DESCRIPTOR_HEAP_DESC dsvHeapDesc = {};
dsvHeapDesc.NumDescriptors = 1 + extraRenderTargetCount;
dsvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_DSV;
if (FAILED(device->CreateDescriptorHeap(&dsvHeapDesc, IID_PPV_ARGS(&dsvHeap)))) {
qWarning("Failed to create depth stencil heap");
return;
}
dsvStride = device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_DSV);
setupRenderTargets();
initialized = true;
q->initializeD3D();
}
void XApp::init()
{
//// Basic initialization
if (initialized) return;
initialized = true;
if (!ovrRendering) ovrMirror = false;
if (ovrRendering) vr.init();
if (appName.length() == 0) {
// no app name specified - just use first one from iterator
auto it = appMap.begin();
XAppBase *a = it->second;
if (a != nullptr) {
appName = it->first;
Log("WARNING: xapp not specified, using this app: " << appName.c_str() << endl);
}
}
//assert(appName.length() > 0);
app = getApp(appName);
if (app != nullptr) {
//Log("initializing " << appName.c_str() << "\n");
SetWindowText(getHWND(), string2wstring(app->getWindowTitle()));
}
else {
Log("ERROR: xapp not available " << appName.c_str() << endl);
// throw assertion error in debug mode
assert(app != nullptr);
}
#ifdef _DEBUG
// Enable the D3D12 debug layer.
{
ComPtr<ID3D12Debug> debugController;
if (SUCCEEDED(D3D12GetDebugInterface(IID_PPV_ARGS(&debugController))))
{
debugController->EnableDebugLayer();
}
HRESULT getAnalysis = DXGIGetDebugInterface1(0, __uuidof(pGraphicsAnalysis), reinterpret_cast<void**>(&pGraphicsAnalysis));
}
#endif
//// Viewport and Scissor
/* D3D12_RECT rect;
if (GetWindowRect(getHWND(), &rect))
{
int width = rect.right - rect.left;
int height = rect.bottom - rect.top;
viewport.MinDepth = 0.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
viewport.Width = static_cast<float>(width);
viewport.Height = static_cast<float>(height);
viewport.MaxDepth = 1.0f;
scissorRect.left = 0;
scissorRect.top = 0;
scissorRect.right = static_cast<LONG>(width);
scissorRect.bottom = static_cast<LONG>(height);
vr.adaptViews(viewport, scissorRect);
}
*/
//// Pipeline
ComPtr<IDXGIFactory4> factory;
ThrowIfFailed(CreateDXGIFactory2(0
#ifdef _DEBUG
| DXGI_CREATE_FACTORY_DEBUG
#endif
, IID_PPV_ARGS(&factory)));
if (warp)
{
ComPtr<IDXGIAdapter> warpAdapter;
ThrowIfFailed(factory->EnumWarpAdapter(IID_PPV_ARGS(&warpAdapter)));
ThrowIfFailed(D3D12CreateDevice(
warpAdapter.Get(),
D3D_FEATURE_LEVEL_11_0,
IID_PPV_ARGS(&device)
));
}
else {
ThrowIfFailed(D3D12CreateDevice(
nullptr,
D3D_FEATURE_LEVEL_11_0,
IID_PPV_ARGS(&device)
));
}
// disable auto alt-enter fullscreen switch (does leave an unresponsive window during debug sessions)
ThrowIfFailed(factory->MakeWindowAssociation(getHWND(), DXGI_MWA_NO_ALT_ENTER));
//IDXGIFactory4 *parentFactoryPtr = nullptr;
//if (SUCCEEDED(swapChain->GetParent(__uuidof(IDXGIFactory4), (void **)&parentFactoryPtr))) {
// parentFactoryPtr->MakeWindowAssociation(getHWND(), DXGI_MWA_NO_ALT_ENTER);
// parentFactoryPtr->Release();
//}
// Describe and create the command queue.
D3D12_COMMAND_QUEUE_DESC queueDesc = {};
queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
ThrowIfFailed(device->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&commandQueue)));
commandQueue->SetName(L"commandQueue_xapp");
calcBackbufferSizeAndAspectRatio();
camera.aspectRatio = aspectRatio;
if (ovrRendering) {
camera.aspectRatio /= 2.0f;
}
camera.projectionTransform();
// Describe the swap chain.
DXGI_SWAP_CHAIN_DESC swapChainDesc = {};
swapChainDesc.BufferCount = FrameCount;
swapChainDesc.BufferDesc.Width = backbufferWidth;
swapChainDesc.BufferDesc.Height = backbufferHeight;
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
swapChainDesc.OutputWindow = getHWND();
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.Windowed = TRUE;
ComPtr<IDXGISwapChain> swapChain0; // we cannot use create IDXGISwapChain3 directly - create IDXGISwapChain, then call As() to map to IDXGISwapChain3
ThrowIfFailed(factory->CreateSwapChain(
commandQueue.Get(), // Swap chain needs the queue so that it can force a flush on it.
&swapChainDesc,
&swapChain0
));
ThrowIfFailed(swapChain0.As(&swapChain));
//swapChain = nullptr;
frameIndex = xapp().swapChain->GetCurrentBackBufferIndex();
if (ovrRendering) {
vr.initD3D();
}
// Create descriptor heaps.
{
// Describe and create a render target view (RTV) descriptor heap.
D3D12_DESCRIPTOR_HEAP_DESC rtvHeapDesc = {};
rtvHeapDesc.NumDescriptors = FrameCount;
rtvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
rtvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
ThrowIfFailed(device->CreateDescriptorHeap(&rtvHeapDesc, IID_PPV_ARGS(&rtvHeap)));
rtvHeap->SetName(L"rtvHeap_xapp");
rtvDescriptorSize = device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
}
// Create frame resources.
{
CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHandle(rtvHeap->GetCPUDescriptorHandleForHeapStart());
// Create a RTV for each frame.
for (UINT n = 0; n < FrameCount; n++)
{
ThrowIfFailed(swapChain->GetBuffer(n, IID_PPV_ARGS(&renderTargets[n])));
device->CreateRenderTargetView(renderTargets[n].Get(), nullptr, rtvHandle);
wstringstream s;
s << L"renderTarget_xapp[" << n << "]";
renderTargets[n]->SetName(s.str().c_str());
rtvHandle.Offset(1, rtvDescriptorSize);
//ThrowIfFailed(device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&commandAllocators[n])));
// Describe and create a depth stencil view (DSV) descriptor heap.
D3D12_DESCRIPTOR_HEAP_DESC dsvHeapDesc = {};
dsvHeapDesc.NumDescriptors = 1;
dsvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_DSV;
dsvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
ThrowIfFailed(device->CreateDescriptorHeap(&dsvHeapDesc, IID_PPV_ARGS(&dsvHeaps[n])));
}
// Create the depth stencil view for each frame
for (UINT n = 0; n < FrameCount; n++)
{
D3D12_DEPTH_STENCIL_VIEW_DESC depthStencilDesc = {};
depthStencilDesc.Format = DXGI_FORMAT_D32_FLOAT;
depthStencilDesc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2D;
depthStencilDesc.Flags = D3D12_DSV_FLAG_NONE;
D3D12_CLEAR_VALUE depthOptimizedClearValue = {};
depthOptimizedClearValue.Format = DXGI_FORMAT_D32_FLOAT;
depthOptimizedClearValue.DepthStencil.Depth = 1.0f;
depthOptimizedClearValue.DepthStencil.Stencil = 0;
ThrowIfFailed(device->CreateCommittedResource(
&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT),
D3D12_HEAP_FLAG_NONE,
&CD3DX12_RESOURCE_DESC::Tex2D(DXGI_FORMAT_D32_FLOAT, backbufferWidth, backbufferHeight, 1, 0, 1, 0, D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL),
D3D12_RESOURCE_STATE_DEPTH_WRITE,
&depthOptimizedClearValue,
IID_PPV_ARGS(&depthStencils[n])
));
//NAME_D3D12_OBJECT(m_depthStencil);
device->CreateDepthStencilView(depthStencils[n].Get(), &depthStencilDesc, dsvHeaps[n]->GetCPUDescriptorHandleForHeapStart());
wstringstream s;
s << L"depthStencil_xapp[" << n << "]";
depthStencils[n]->SetName(s.str().c_str());
}
}
//// Assets
// Create an empty root signature.
{
CD3DX12_ROOT_SIGNATURE_DESC rootSignatureDesc;
rootSignatureDesc.Init(0, nullptr, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);
ComPtr<ID3DBlob> signature;
ComPtr<ID3DBlob> error;
ThrowIfFailed(D3D12SerializeRootSignature(&rootSignatureDesc, D3D_ROOT_SIGNATURE_VERSION_1, &signature, &error));
ThrowIfFailed(device->CreateRootSignature(0, signature->GetBufferPointer(), signature->GetBufferSize(), IID_PPV_ARGS(&rootSignature)));
}
// 11 on 12 device support
UINT d3d11DeviceFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
#if defined(_DEBUG)
if (disableDX11Debug == false) {
d3d11DeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
}
#endif
ThrowIfFailed(D3D11On12CreateDevice(
device.Get(),
d3d11DeviceFlags,
nullptr,
0,
reinterpret_cast<IUnknown**>(commandQueue.GetAddressOf()),
1,
0,
&d3d11Device,
&d3d11DeviceContext,
nullptr
));
// Query the 11On12 device from the 11 device.
ThrowIfFailed(d3d11Device.As(&d3d11On12Device));
// feature levels: we need DX 10.1 as minimum
D3D_FEATURE_LEVEL out_level;
array<D3D_FEATURE_LEVEL, 3> levels{ {
D3D_FEATURE_LEVEL_11_1,
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1
} };
//ID3D11DeviceContext* context = nullptr;
UINT flags = disableDX11Debug ? 0 : D3D11_CREATE_DEVICE_DEBUG;
ThrowIfFailed(D3D11CreateDevice(nullptr,
D3D_DRIVER_TYPE_HARDWARE,
nullptr,
flags,
&levels[0],
(UINT)levels.size(),
D3D11_SDK_VERSION,
&reald3d11Device,
&out_level,
&reald3d11DeviceContext));
// 11 on 12 end
camera.ovrCamera = true;
if (!ovrRendering) camera.ovrCamera = false;
gametime.init(1); // init to real time
camera.setSpeed(1.0f);
initPakFiles();
app->init();
app->update();
}
