| /* |
| * Copyright 2020 Google LLC |
| * |
| */ |
| |
| /* |
| * Copyright (c) 2020, Alliance for Open Media. All rights reserved |
| * |
| * This source code is subject to the terms of the BSD 2 Clause License and |
| * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License |
| * was not distributed with this source code in the LICENSE file, you can |
| * obtain it at www.aomedia.org/license/software. If the Alliance for Open |
| * Media Patent License 1.0 was not distributed with this source code in the |
| * PATENTS file, you can obtain it at www.aomedia.org/license/patent. |
| */ |
| |
| #include "pch.h" |
| #include "DXEngine.h" |
| #include "SamplePixelShader.h" |
| #include "SampleVertexShader.h" |
| #include "ps_cbuf.h" |
| |
| using namespace Windows::Graphics::Display; |
| |
| DXEngine::DXEngine(Windows::UI::Core::CoreWindow ^ window) : m_frameIndex(0), m_rtvDescriptorSize(0) { |
| DisplayInformation ^ currentDisplayInformation = DisplayInformation::GetForCurrentView(); |
| m_window = window; |
| m_logicalSize = Windows::Foundation::Size(m_window->Bounds.Width, m_window->Bounds.Height); |
| m_dpi = currentDisplayInformation->LogicalDpi; |
| UpdateRenderTargetSize(); |
| m_viewport = CD3DX12_VIEWPORT(0.0f, 0.0f, static_cast<float>(m_width), static_cast<float>(m_height)); |
| m_scissorRect = CD3DX12_RECT(0, 0, static_cast<LONG>(m_width), static_cast<LONG>(m_height)), strides_[0] = m_width; |
| strides_[1] = strides_[2] = strides_[0] / 2; |
| upload_buffer_size_[0] = upload_buffer_size_[1] = upload_buffer_size_[2] = 0; |
| } |
| |
| // Converts a length in device-independent pixels (DIPs) to a length in physical pixels. |
| static inline float ConvertDipsToPixels(float dips, float dpi) { |
| static const float dipsPerInch = 96.0f; |
| return floorf(dips * dpi / dipsPerInch + 0.5f); // Round to nearest integer. |
| } |
| |
| void DXEngine::UpdateRenderTargetSize() { |
| m_effectiveDpi = m_dpi; |
| |
| // Calculate the necessary render target size in pixels. |
| m_width = max(lround(ConvertDipsToPixels(m_logicalSize.Width, m_effectiveDpi)), 1); |
| m_height = max(lround(ConvertDipsToPixels(m_logicalSize.Height, m_effectiveDpi)), 1); |
| } |
| |
| int DXEngine::OnInit() { |
| if (LoadPipeline() || LoadAssets()) return -1; |
| ready_ = 1; |
| return 0; |
| } |
| |
| // Load the rendering pipeline dependencies. |
| int DXEngine::LoadPipeline() { |
| UINT dxgiFactoryFlags = 0; |
| D2D1_FACTORY_OPTIONS factory_options = {D2D1_DEBUG_LEVEL_NONE}; |
| #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; |
| factory_options.debugLevel = D2D1_DEBUG_LEVEL_INFORMATION; |
| } |
| } |
| #endif |
| |
| ComPtr<IDXGIFactory4> factory; |
| CHECK_HRESULT(CreateDXGIFactory2(dxgiFactoryFlags, IID_PPV_ARGS(&factory))); |
| |
| if (m_useWarpDevice) { |
| ComPtr<IDXGIAdapter> warpAdapter; |
| CHECK_HRESULT(factory->EnumWarpAdapter(IID_PPV_ARGS(&warpAdapter))); |
| |
| CHECK_HRESULT(D3D12CreateDevice(warpAdapter.Get(), D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&m_device))); |
| } else { |
| ComPtr<IDXGIAdapter1> hardwareAdapter; |
| GetHardwareAdapter(factory.Get(), &hardwareAdapter); |
| |
| CHECK_HRESULT(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; |
| |
| CHECK_HRESULT(m_device->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&m_commandQueue))); |
| |
| ComPtr<ID3D11Device> d3d11Device; |
| CHECK_HRESULT(D3D11On12CreateDevice(m_device.Get(), D3D11_CREATE_DEVICE_BGRA_SUPPORT, nullptr, 0, |
| reinterpret_cast<IUnknown**>(m_commandQueue.GetAddressOf()), 1, 0, &d3d11Device, |
| &d11on12device_context_, nullptr)); |
| |
| // Query the 11On12 device from the 11 device. |
| CHECK_HRESULT(d3d11Device.As(&d11on12device_)); |
| |
| // 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.Scaling = DXGI_SCALING_NONE; |
| |
| ComPtr<IDXGISwapChain1> swapChain; |
| CHECK_HRESULT(factory->CreateSwapChainForCoreWindow( |
| m_commandQueue.Get(), // Swap chain needs the queue so that it can force a flush on it. |
| reinterpret_cast<IUnknown*>(m_window.Get()), &swapChainDesc, nullptr, &swapChain)); |
| |
| D2D1_DEVICE_CONTEXT_OPTIONS deviceOptions = D2D1_DEVICE_CONTEXT_OPTIONS_NONE; |
| CHECK_HRESULT( |
| D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, __uuidof(ID2D1Factory3), &factory_options, &d2d1factory_)); |
| ComPtr<IDXGIDevice> dxgiDevice; |
| CHECK_HRESULT(d11on12device_.As(&dxgiDevice)); |
| CHECK_HRESULT(d2d1factory_->CreateDevice(dxgiDevice.Get(), &d2d1device2_)); |
| CHECK_HRESULT(d2d1device2_->CreateDeviceContext(deviceOptions, &d2d1deviceContext_)); |
| CHECK_HRESULT(DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory), &d2writeFactory_)); |
| |
| float dpiX; |
| float dpiY; |
| d2d1factory_->GetDesktopDpi(&dpiX, &dpiY); |
| D2D1_BITMAP_PROPERTIES1 bitmapProperties = |
| D2D1::BitmapProperties1(D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW, |
| D2D1::PixelFormat(DXGI_FORMAT_UNKNOWN, D2D1_ALPHA_MODE_PREMULTIPLIED), dpiX, dpiY); |
| |
| CHECK_HRESULT(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; |
| CHECK_HRESULT(m_device->CreateDescriptorHeap(&rtvHeapDesc, IID_PPV_ARGS(&m_rtvHeap))); |
| |
| // Describe and create a shader resource view (SRV) heap for the texture. |
| D3D12_DESCRIPTOR_HEAP_DESC srvHeapDesc = {}; |
| srvHeapDesc.NumDescriptors = 4; |
| srvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV; |
| srvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE; |
| CHECK_HRESULT(m_device->CreateDescriptorHeap(&srvHeapDesc, IID_PPV_ARGS(&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 a RTV for each frame. |
| for (UINT n = 0; n < FrameCount; n++) { |
| CHECK_HRESULT(m_swapChain->GetBuffer(n, IID_PPV_ARGS(&m_renderTargets[n]))); |
| m_device->CreateRenderTargetView(m_renderTargets[n].Get(), nullptr, rtvHandle); |
| // Create a wrapped 11On12 resource of this back buffer. Since we are |
| // rendering all D3D12 content first and then all D2D content, we specify |
| // the In resource state as RENDER_TARGET - because D3D12 will have last |
| // used it in this state - and the Out resource state as PRESENT. When |
| // ReleaseWrappedResources() is called on the 11On12 device, the resource |
| // will be transitioned to the PRESENT state. |
| D3D11_RESOURCE_FLAGS d3d11Flags = {D3D11_BIND_RENDER_TARGET}; |
| CHECK_HRESULT(d11on12device_->CreateWrappedResource( |
| m_renderTargets[n].Get(), &d3d11Flags, D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT, |
| IID_PPV_ARGS(&wrappedBackBuffers_[n]))); |
| |
| // Create a render target for D2D to draw directly to this back buffer. |
| ComPtr<IDXGISurface> surface; |
| CHECK_HRESULT(wrappedBackBuffers_[n].As(&surface)); |
| CHECK_HRESULT( |
| d2d1deviceContext_->CreateBitmapFromDxgiSurface(surface.Get(), &bitmapProperties, &d2d1renderTargets_[n])); |
| |
| rtvHandle.Offset(1, m_rtvDescriptorSize); |
| } |
| } |
| |
| CHECK_HRESULT(m_device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&m_commandAllocator))); |
| |
| CHECK_HRESULT(d2d1deviceContext_->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::LightGreen), &textBrush_)); |
| CHECK_HRESULT(d2writeFactory_->CreateTextFormat(L"Verdana", NULL, DWRITE_FONT_WEIGHT_NORMAL, DWRITE_FONT_STYLE_NORMAL, |
| DWRITE_FONT_STRETCH_NORMAL, 24, L"en-us", &textFormat_)); |
| CHECK_HRESULT(textFormat_->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_LEADING)); |
| CHECK_HRESULT(textFormat_->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_NEAR)); |
| |
| return S_OK; |
| } |
| |
| #define TEXT_TOP 20 |
| #define TEXT_LEFT 20 |
| void DXEngine::RenderUI(std::shared_ptr<OneRenderTask> task) { |
| D2D1_SIZE_F rtSize = d2d1renderTargets_[m_frameIndex]->GetSize(); |
| D2D1_RECT_F textRect = D2D1::RectF(TEXT_LEFT, TEXT_TOP, rtSize.width - TEXT_LEFT, 100); |
| // static const WCHAR text[] = L"11On12"; |
| |
| // Acquire our wrapped render target resource for the current back buffer. |
| d11on12device_->AcquireWrappedResources(wrappedBackBuffers_[m_frameIndex].GetAddressOf(), 1); |
| |
| // Render text directly to the back buffer. |
| d2d1deviceContext_->SetTarget(d2d1renderTargets_[m_frameIndex].Get()); |
| d2d1deviceContext_->BeginDraw(); |
| d2d1deviceContext_->SetTransform(D2D1::Matrix3x2F::Identity()); |
| d2d1deviceContext_->DrawText(task->screen_msg.c_str(), (UINT32)task->screen_msg.length(), textFormat_.Get(), |
| &textRect, textBrush_.Get()); |
| CHECK_HRESULT_0(d2d1deviceContext_->EndDraw()); |
| |
| // Release our wrapped render target resource. Releasing |
| // transitions the back buffer resource to the state specified |
| // as the OutState when the wrapped resource was created. |
| d11on12device_->ReleaseWrappedResources(wrappedBackBuffers_[m_frameIndex].GetAddressOf(), 1); |
| |
| // Flush to submit the 11 command list to the shared command queue. |
| d11on12device_context_->Flush(); |
| } |
| |
| // Load the sample assets. |
| int DXEngine::LoadAssets() { |
| // Create the root signature. |
| { |
| HRESULT hr; |
| D3D12_FEATURE_DATA_ROOT_SIGNATURE featureData = {}; |
| |
| // This is the highest version the sample supports. If CheckFeatureSupport succeeds, the HighestVersion returned |
| // will not be greater than this. |
| featureData.HighestVersion = D3D_ROOT_SIGNATURE_VERSION_1_1; |
| |
| if (FAILED(m_device->CheckFeatureSupport(D3D12_FEATURE_ROOT_SIGNATURE, &featureData, sizeof(featureData)))) { |
| featureData.HighestVersion = D3D_ROOT_SIGNATURE_VERSION_1_0; |
| } |
| |
| CD3DX12_DESCRIPTOR_RANGE1 ranges[2]; |
| ranges[0].Init(D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 1, 0, 0, |
| D3D12_DESCRIPTOR_RANGE_FLAG_NONE /*D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC*/); |
| ranges[1].Init(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 3, 0, 0, |
| D3D12_DESCRIPTOR_RANGE_FLAG_NONE /*D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC*/); |
| |
| CD3DX12_ROOT_PARAMETER1 rootParameters[1]; |
| rootParameters[0].InitAsDescriptorTable(2, &ranges[0], D3D12_SHADER_VISIBILITY_PIXEL); |
| |
| D3D12_STATIC_SAMPLER_DESC sampler = {}; |
| sampler.Filter = D3D12_FILTER_MIN_MAG_MIP_POINT; |
| sampler.AddressU = D3D12_TEXTURE_ADDRESS_MODE_BORDER; |
| sampler.AddressV = D3D12_TEXTURE_ADDRESS_MODE_BORDER; |
| sampler.AddressW = D3D12_TEXTURE_ADDRESS_MODE_BORDER; |
| sampler.MipLODBias = 0; |
| sampler.MaxAnisotropy = 0; |
| sampler.ComparisonFunc = D3D12_COMPARISON_FUNC_NEVER; |
| sampler.BorderColor = D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK; |
| sampler.MinLOD = 0.0f; |
| sampler.MaxLOD = D3D12_FLOAT32_MAX; |
| sampler.ShaderRegister = 0; |
| sampler.RegisterSpace = 0; |
| sampler.ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL; |
| D3D12_STATIC_SAMPLER_DESC sampler1 = sampler; |
| sampler1.ShaderRegister = 1; |
| |
| D3D12_STATIC_SAMPLER_DESC samplers[2] = {sampler, sampler1}; |
| |
| CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC rootSignatureDesc; |
| rootSignatureDesc.Init_1_1(_countof(rootParameters), rootParameters, 2, samplers, |
| D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT); |
| |
| ComPtr<ID3DBlob> signature; |
| ComPtr<ID3DBlob> error; |
| hr = D3DX12SerializeVersionedRootSignature(&rootSignatureDesc, featureData.HighestVersion, &signature, &error); |
| if (FAILED(hr)) { |
| void* ss = error->GetBufferPointer(); |
| wprintf(L"%s\n", (wchar_t*)ss); |
| } |
| CHECK_HRESULT(m_device->CreateRootSignature(0, signature->GetBufferPointer(), signature->GetBufferSize(), |
| IID_PPV_ARGS(&m_rootSignature))); |
| |
| // create CbPixShData buffer |
| const D3D12_HEAP_TYPE heapType = D3D12_HEAP_TYPE_UPLOAD; |
| const D3D12_RESOURCE_STATES state = D3D12_RESOURCE_STATE_GENERIC_READ; |
| D3D12_HEAP_PROPERTIES heapProp; |
| heapProp.Type = heapType; |
| heapProp.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN; // |
| heapProp.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN; |
| heapProp.CreationNodeMask = 0; |
| heapProp.VisibleNodeMask = 0; |
| |
| const D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE; |
| hr = m_device->CreateCommittedResource(&heapProp, D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(256, flags), |
| state, NULL, IID_PPV_ARGS(&hdr_buffer_)); |
| CHECK_HRESULT(hr); |
| void* ptr = 0; |
| hr = hdr_buffer_->Map(0, NULL, &ptr); |
| if (FAILED(hr)) return 0; |
| CbPixShData buffer = {}; |
| buffer.scale_factor = 1.0; |
| buffer.hdr_10_10_10_2 = 0; |
| memcpy(ptr, &buffer, sizeof(CbPixShData)); |
| hdr_buffer_->Unmap(0, 0); |
| } |
| |
| // Create the pipeline state, which includes compiling and loading shaders. |
| { |
| // Define the vertex input layout. |
| D3D12_INPUT_ELEMENT_DESC inputElementDescs[] = { |
| {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0}, |
| {"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0}}; |
| |
| // Describe and create the graphics pipeline state object (PSO). |
| D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc = {}; |
| psoDesc.InputLayout = {inputElementDescs, _countof(inputElementDescs)}; |
| psoDesc.pRootSignature = m_rootSignature.Get(); |
| psoDesc.VS = CD3DX12_SHADER_BYTECODE(SampleVertexShader, sizeof(SampleVertexShader)); |
| psoDesc.PS = CD3DX12_SHADER_BYTECODE(SamplePixelShader, sizeof(SamplePixelShader)); |
| psoDesc.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT); |
| psoDesc.BlendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT); |
| psoDesc.DepthStencilState.DepthEnable = FALSE; |
| psoDesc.DepthStencilState.StencilEnable = FALSE; |
| psoDesc.SampleMask = UINT_MAX; |
| psoDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE; |
| psoDesc.NumRenderTargets = 1; |
| psoDesc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM; |
| psoDesc.SampleDesc.Count = 1; |
| HRESULT hr = m_device->CreateGraphicsPipelineState(&psoDesc, IID_PPV_ARGS(&m_pipelineState)); |
| CHECK_HRESULT(hr); |
| } |
| |
| // Create the command list. |
| CHECK_HRESULT(m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, m_commandAllocator.Get(), |
| m_pipelineState.Get(), IID_PPV_ARGS(&m_commandList))); |
| SET_D3D12_NAME(m_commandList); |
| setVertexes(); |
| |
| // Close the command list and execute it to begin the initial GPU setup. |
| CHECK_HRESULT(m_commandList->Close()); |
| ID3D12CommandList* ppCommandLists[] = {m_commandList.Get()}; |
| m_commandQueue->ExecuteCommandLists(_countof(ppCommandLists), ppCommandLists); |
| |
| // Create synchronization objects and wait until assets have been uploaded to the GPU. |
| { |
| CHECK_HRESULT(m_device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&m_fence))); |
| m_fenceValue = 1; |
| |
| // Create an event handle to use for frame synchronization. |
| m_fenceEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr); |
| if (m_fenceEvent == nullptr) { |
| CHECK_HRESULT(HRESULT_FROM_WIN32(GetLastError())); |
| } |
| |
| // Wait for the command list to execute; we are reusing the same command |
| // list in our main loop but for now, we just want to wait for setup to |
| // complete before continuing. |
| WaitForPreviousFrame(); |
| } |
| return S_OK; |
| } |
| |
| void DXEngine::setVertexes() { |
| fRect startRect = {-1.0f, 1.0f, 1.0f, -1.0f}; |
| float texture_right = 1.0; |
| Vertex triangleVertices[] = {{{startRect.left, startRect.top, 0.0f}, {0.0f, 0.0f}}, |
| {{startRect.right, startRect.top, 0.0f}, {texture_right, 0.0f}}, |
| {{startRect.left, startRect.bottom, 0.0f}, {0.0f, 1.0f}}, |
| {{startRect.right, startRect.bottom, 0.0f}, {texture_right, 1.0f}}}; |
| const UINT vertexesNumber = sizeof(triangleVertices) / sizeof(Vertex); |
| setVertexes(triangleVertices, vertexesNumber); |
| } |
| |
| void DXEngine::OnResize() { |
| std::unique_lock<std::mutex> lck(cs_render_); |
| if (hasTexture_) { |
| CHECK_HRESULT_0(m_commandAllocator->Reset()); |
| CHECK_HRESULT_0(m_commandList->Reset(m_commandAllocator.Get(), m_pipelineState.Get())); |
| setVertexes(); |
| InternalRender(FALSE, 0); |
| } |
| } |
| |
| // Update frame-based values. |
| void DXEngine::OnUpdate() {} |
| |
| // Render the scene. |
| void DXEngine::OnRender(std::shared_ptr<OneRenderTask> task) { |
| if (ready_ && task && !task->shown) { |
| InternalRender(TRUE, task); |
| } |
| } |
| |
| void DXEngine::InternalRender(BOOL reset, std::shared_ptr<OneRenderTask> task) { |
| // Record all the commands we need to render the scene into the command list. |
| PopulateCommandList(reset, task); |
| |
| // Execute the command list. |
| ID3D12CommandList* ppCommandLists[] = {m_commandList.Get()}; |
| m_commandQueue->ExecuteCommandLists(_countof(ppCommandLists), ppCommandLists); |
| |
| RenderUI(task); |
| |
| // Present the frame. |
| CHECK_HRESULT_0(m_swapChain->Present(1, 0)); |
| |
| WaitForPreviousFrame(); |
| } |
| |
| void DXEngine::OnDestroy() { |
| // Ensure that the GPU is no longer referencing resources that are about to be |
| // cleaned up by the destructor. |
| WaitForPreviousFrame(); |
| ready_ = 0; |
| CloseHandle(m_fenceEvent); |
| } |
| |
| void DXEngine::PopulateCommandList(BOOL reset, std::shared_ptr<OneRenderTask> task) { |
| // Command list allocators can only be reset when the associated |
| // command lists have finished execution on the GPU; apps should use |
| // fences to determine GPU execution progress. |
| if (reset) { |
| CHECK_HRESULT_0(m_commandAllocator->Reset()); |
| |
| // However, when ExecuteCommandList() is called on a particular command |
| // list, that command list can then be reset at any time and must be before |
| // re-recording. |
| CHECK_HRESULT_0(m_commandList->Reset(m_commandAllocator.Get(), m_pipelineState.Get())); |
| } |
| |
| CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHandle(m_rtvHeap->GetCPUDescriptorHandleForHeapStart(), m_frameIndex, |
| m_rtvDescriptorSize); |
| m_commandList->OMSetRenderTargets(1, &rtvHandle, FALSE, nullptr); |
| m_commandList->ResourceBarrier( |
| 1, &CD3DX12_RESOURCE_BARRIER::Transition(m_renderTargets[m_frameIndex].Get(), D3D12_RESOURCE_STATE_PRESENT, |
| D3D12_RESOURCE_STATE_RENDER_TARGET)); |
| const float clearColor[] = {0.0f, 0.2f, 0.4f, 1.0f}; |
| m_commandList->ClearRenderTargetView(rtvHandle, clearColor, 0, nullptr); |
| |
| if (task) { |
| if (task->type != renderType_) { |
| void* ptr = 0; |
| HRESULT hr = hdr_buffer_->Map(0, NULL, &ptr); |
| CHECK_HRESULT_0(hr); |
| renderType_ = task->type; |
| CbPixShData* cbptr = (CbPixShData*)ptr; |
| cbptr->scale_factor = renderType_ == ft10bit ? 64.0f : 1.0f; |
| cbptr->hdr_10_10_10_2 = renderType_ == ft10x3 ? 1 : 0; |
| if (cbptr->hdr_10_10_10_2) { |
| D3D12_RESOURCE_DESC desc = task->textures[0]->GetDesc(); |
| cbptr->disp_w = lround(m_viewport.Width); |
| cbptr->disp_h = lround(m_viewport.Height); |
| cbptr->frame_w = task->render_width; |
| cbptr->frame_h = task->render_height; |
| cbptr->ptex_w = (int)desc.Width; |
| cbptr->ptex_h = desc.Height; |
| } |
| hdr_buffer_->Unmap(0, 0); |
| } |
| const D3D12_RESOURCE_BARRIER barriers[3] = { |
| CD3DX12_RESOURCE_BARRIER::Transition(task->textures[0].Get(), D3D12_RESOURCE_STATE_COPY_DEST, |
| D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE), |
| CD3DX12_RESOURCE_BARRIER::Transition(task->textures[1].Get(), D3D12_RESOURCE_STATE_COPY_DEST, |
| D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE), |
| CD3DX12_RESOURCE_BARRIER::Transition(task->textures[2].Get(), D3D12_RESOURCE_STATE_COPY_DEST, |
| D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE)}; |
| m_commandList->ResourceBarrier(3, barriers); |
| CD3DX12_CPU_DESCRIPTOR_HANDLE srvHandle(m_srvHeap->GetCPUDescriptorHandleForHeapStart()); |
| |
| m_commandList->SetGraphicsRootSignature(m_rootSignature.Get()); |
| |
| D3D12_CONSTANT_BUFFER_VIEW_DESC cbvDesc{}; |
| D3D12_RESOURCE_DESC cbdesk = hdr_buffer_->GetDesc(); |
| cbvDesc.BufferLocation = hdr_buffer_->GetGPUVirtualAddress(); |
| cbvDesc.SizeInBytes = (UINT)cbdesk.Width; |
| m_device->CreateConstantBufferView(&cbvDesc, srvHandle); |
| srvHandle.Offset(1, m_srvDescriptorSize); |
| |
| for (int i = 0; i < 3; i++) { |
| D3D12_RESOURCE_DESC textureDesc = task->textures[i]->GetDesc(); |
| D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {}; |
| srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; |
| srvDesc.Format = textureDesc.Format; |
| srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D; |
| srvDesc.Texture2D.MipLevels = 1; |
| m_device->CreateShaderResourceView(task->textures[i].Get(), &srvDesc, srvHandle); |
| srvHandle.Offset(1, m_srvDescriptorSize); |
| } |
| // Set necessary state. |
| |
| ID3D12DescriptorHeap* ppHeaps[] = {m_srvHeap.Get()}; |
| m_commandList->SetDescriptorHeaps(_countof(ppHeaps), ppHeaps); |
| |
| m_commandList->SetGraphicsRootDescriptorTable(0, m_srvHeap->GetGPUDescriptorHandleForHeapStart()); |
| m_commandList->RSSetViewports(1, &m_viewport); |
| m_commandList->RSSetScissorRects(1, &m_scissorRect); |
| |
| // Record commands. |
| m_commandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP /*D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST*/); |
| m_commandList->IASetVertexBuffers(0, 1, &m_vertexBufferView); |
| m_commandList->DrawInstanced(4, 1, 0, 0); |
| { |
| const D3D12_RESOURCE_BARRIER barriers[3] = { |
| CD3DX12_RESOURCE_BARRIER::Transition(task->textures[0].Get(), D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE, |
| D3D12_RESOURCE_STATE_COPY_DEST), |
| CD3DX12_RESOURCE_BARRIER::Transition(task->textures[1].Get(), D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE, |
| D3D12_RESOURCE_STATE_COPY_DEST), |
| CD3DX12_RESOURCE_BARRIER::Transition(task->textures[2].Get(), D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE, |
| D3D12_RESOURCE_STATE_COPY_DEST)}; |
| m_commandList->ResourceBarrier(3, barriers); |
| } |
| } |
| |
| CHECK_HRESULT_0(m_commandList->Close()); |
| } |
| |
| void DXEngine::WaitForPreviousFrame() { |
| // WAITING FOR THE FRAME TO COMPLETE BEFORE CONTINUING IS NOT BEST PRACTICE. |
| // This is code implemented as such for simplicity. The D3D12HelloFrameBuffering |
| // sample illustrates how to use fences for efficient resource usage and to |
| // maximize GPU utilization. |
| |
| // Signal and increment the fence value. |
| const UINT64 fence = m_fenceValue; |
| CHECK_HRESULT_0(m_commandQueue->Signal(m_fence.Get(), fence)); |
| m_fenceValue++; |
| |
| // Wait until the previous frame is finished. |
| if (m_fence->GetCompletedValue() < fence) { |
| CHECK_HRESULT_0(m_fence->SetEventOnCompletion(fence, m_fenceEvent)); |
| WaitForSingleObject(m_fenceEvent, INFINITE); |
| } |
| |
| m_frameIndex = m_swapChain->GetCurrentBackBufferIndex(); |
| } |
| |
| // Helper function for acquiring the first available hardware adapter that supports Direct3D 12. |
| // If no such adapter can be found, *ppAdapter will be set to nullptr. |
| _Use_decl_annotations_ void DXEngine::GetHardwareAdapter(IDXGIFactory2* pFactory, IDXGIAdapter1** ppAdapter) { |
| ComPtr<IDXGIAdapter1> adapter; |
| *ppAdapter = nullptr; |
| |
| for (UINT adapterIndex = 0; DXGI_ERROR_NOT_FOUND != pFactory->EnumAdapters1(adapterIndex, &adapter); ++adapterIndex) { |
| DXGI_ADAPTER_DESC1 desc; |
| adapter->GetDesc1(&desc); |
| |
| if (desc.Flags & DXGI_ADAPTER_FLAG_SOFTWARE) { |
| // Don't select the Basic Render Driver adapter. |
| // If you want a software adapter, pass in "/warp" on the command line. |
| continue; |
| } |
| |
| // Check to see if the adapter supports Direct3D 12, but don't create the |
| // actual device yet. |
| if (SUCCEEDED(D3D12CreateDevice(adapter.Get(), D3D_FEATURE_LEVEL_11_0, _uuidof(ID3D12Device), nullptr))) { |
| break; |
| } |
| } |
| |
| *ppAdapter = adapter.Detach(); |
| } |
| |
| void DXEngine::setVertexes(Vertex* vertexes, UINT size) { |
| UINT vertexBufferSize = sizeof(Vertex) * size; |
| CHECK_HRESULT_0(m_device->CreateCommittedResource( |
| &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, |
| &CD3DX12_RESOURCE_DESC::Buffer(vertexBufferSize), D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, |
| IID_PPV_ARGS(&vertexUploadBuffer_))); |
| SET_D3D12_NAME(vertexUploadBuffer_); |
| |
| // Copy the triangle data to the vertex buffer. |
| UINT8* pVertexDataBegin; |
| CD3DX12_RANGE readRange(0, 0); // We do not intend to read from this resource on the CPU. |
| CHECK_HRESULT_0(vertexUploadBuffer_->Map(0, &readRange, reinterpret_cast<void**>(&pVertexDataBegin))); |
| memcpy(pVertexDataBegin, vertexes, vertexBufferSize); |
| vertexUploadBuffer_->Unmap(0, nullptr); |
| |
| CHECK_HRESULT_0( |
| m_device->CreateCommittedResource(&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT), D3D12_HEAP_FLAG_NONE, |
| &CD3DX12_RESOURCE_DESC::Buffer(vertexBufferSize), |
| D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&m_vertexBuffer))); |
| SET_D3D12_NAME(m_vertexBuffer); |
| if (m_commandList) { |
| m_commandList->CopyBufferRegion(m_vertexBuffer.Get(), 0, vertexUploadBuffer_.Get(), 0, vertexBufferSize); |
| const D3D12_RESOURCE_BARRIER barriers[1] = {CD3DX12_RESOURCE_BARRIER::Transition( |
| m_vertexBuffer.Get(), D3D12_RESOURCE_STATE_COPY_DEST, |
| D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER /*D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE*/)}; |
| m_commandList->ResourceBarrier(1, barriers); |
| } |
| |
| // Initialize the vertex buffer view. |
| m_vertexBufferView.BufferLocation = m_vertexBuffer->GetGPUVirtualAddress(); |
| m_vertexBufferView.StrideInBytes = sizeof(Vertex); |
| m_vertexBufferView.SizeInBytes = vertexBufferSize; |
| } |
