// 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(); }