D3D12Core implementation

#include "hzpch.h"
#include "DirectX12Core.h"
namespace Hazel
{
    D3D12Core* D3D12Core::s_Instance = nullptr;
    D3D12Core::D3D12Core()
    {
#ifdef HZ_DEBUG
        ComPtr<ID3D12Debug> debugInterface;
        D3D12GetDebugInterface(IID_PPV_ARGS(&debugInterface));
        debugInterface->EnableDebugLayer();
#endif
        m_Device = CreateDevice(m_UseWarp);
        m_DirectCommandQueue = CreateRef<CommandQueue>(m_Device, D3D12_COMMAND_LIST_TYPE_DIRECT);
        m_ComputeCommandQueue = CreateRef<CommandQueue>(m_Device, D3D12_COMMAND_LIST_TYPE_COMPUTE);
        m_CopyCommandQueue = CreateRef<CommandQueue>(m_Device, D3D12_COMMAND_LIST_TYPE_COPY);
    }
    Ref<CommandQueue> D3D12Core::GetCommandQueue(D3D12_COMMAND_LIST_TYPE type)
    {
        Ref<CommandQueue> commandQueue;
        switch (type)
        {
        case D3D12_COMMAND_LIST_TYPE_DIRECT:
            commandQueue = m_DirectCommandQueue;
            break;
        case D3D12_COMMAND_LIST_TYPE_COMPUTE:
            commandQueue = m_ComputeCommandQueue;
            break;
        case D3D12_COMMAND_LIST_TYPE_COPY:
            commandQueue = m_CopyCommandQueue;
            break;
        default:
            assert(false && "Invalid command queue type.");
        }
        return commandQueue;
    }
    ComPtr<ID3D12Device2> D3D12Core::CreateDevice(bool bUseWarp)
    {
        ComPtr<IDXGIFactory4> dxgiFactory;
        UINT createFactoryFlags = 0;
#if defined(_DEBUG)
        createFactoryFlags = DXGI_CREATE_FACTORY_DEBUG;
#endif
        CreateDXGIFactory2(createFactoryFlags, IID_PPV_ARGS(&dxgiFactory));
        ComPtr<IDXGIAdapter1> dxgiAdapter1;
        ComPtr<IDXGIAdapter4> dxgiAdapter4;
        if (bUseWarp)
        {
            dxgiFactory->EnumWarpAdapter(IID_PPV_ARGS(&dxgiAdapter1));
            dxgiAdapter1.As(&dxgiAdapter4);
        }
        else
        {
            SIZE_T maxDedicatedVideoMemory = 0;
            for (UINT i = 0; dxgiFactory->EnumAdapters1(i, &dxgiAdapter1) != DXGI_ERROR_NOT_FOUND; ++i)
            {
                DXGI_ADAPTER_DESC1 dxgiAdapterDesc1;
                dxgiAdapter1->GetDesc1(&dxgiAdapterDesc1);
                if ((dxgiAdapterDesc1.Flags & DXGI_ADAPTER_FLAG_SOFTWARE) == 0 &&
                    SUCCEEDED(D3D12CreateDevice(dxgiAdapter1.Get(),
                        D3D_FEATURE_LEVEL_11_0, __uuidof(ID3D12Device), nullptr)) &&
                    dxgiAdapterDesc1.DedicatedVideoMemory > maxDedicatedVideoMemory)
                {
                    maxDedicatedVideoMemory = dxgiAdapterDesc1.DedicatedVideoMemory;
                    dxgiAdapter1.As(&dxgiAdapter4);
                }
            }
        }
        ComPtr<ID3D12Device2> D3DDevice;
        D3D12CreateDevice(dxgiAdapter4.Get(), D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&D3DDevice));
        #if defined(_DEBUG)
        ComPtr<ID3D12InfoQueue> pInfoQueue;
        if (SUCCEEDED(D3DDevice.As(&pInfoQueue)))
        {
            pInfoQueue->SetBreakOnSeverity(D3D12_MESSAGE_SEVERITY_CORRUPTION, TRUE);
            pInfoQueue->SetBreakOnSeverity(D3D12_MESSAGE_SEVERITY_ERROR, TRUE);
            pInfoQueue->SetBreakOnSeverity(D3D12_MESSAGE_SEVERITY_WARNING, TRUE);
            D3D12_MESSAGE_SEVERITY Severities[] =
            {
                D3D12_MESSAGE_SEVERITY_INFO
            };
            D3D12_MESSAGE_ID DenyIds[] = {
                D3D12_MESSAGE_ID_CLEARRENDERTARGETVIEW_MISMATCHINGCLEARVALUE,   // I'm really not sure how to avoid this message.
                D3D12_MESSAGE_ID_MAP_INVALID_NULLRANGE,                         // This warning occurs when using capture frame while graphics debugging.
                D3D12_MESSAGE_ID_UNMAP_INVALID_NULLRANGE,                       // This warning occurs when using capture frame while graphics debugging.
            };
            D3D12_INFO_QUEUE_FILTER NewFilter = {};
            NewFilter.DenyList.NumSeverities = _countof(Severities);
            NewFilter.DenyList.pSeverityList = Severities;
            NewFilter.DenyList.NumIDs = _countof(DenyIds);
            NewFilter.DenyList.pIDList = DenyIds;
            pInfoQueue->PushStorageFilter(&NewFilter);
        }
#endif
        return D3DDevice;
    }
    ComPtr<ID3D12DescriptorHeap> D3D12Core::CreateDescriptorHeap(UINT numDescriptors, D3D12_DESCRIPTOR_HEAP_TYPE type)
    {
        D3D12_DESCRIPTOR_HEAP_DESC desc = {};
        desc.Type = type;
        desc.NumDescriptors = numDescriptors;
        desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
        desc.NodeMask = 0;
        ComPtr<ID3D12DescriptorHeap> descriptorHeap;
        m_Device->CreateDescriptorHeap(&desc, IID_PPV_ARGS(&descriptorHeap));
        return descriptorHeap;
    }
    ComPtr<IDXGISwapChain4> D3D12Core::CreateSwapChain(HWND windowHandle,ComPtr<ID3D12CommandQueue> commandqueue, uint32_t width, uint32_t height)
    {
        ComPtr<IDXGISwapChain4> dxgiSwapChain4;
        ComPtr<IDXGIFactory4> dxgiFactory4;
        UINT createFactoryFlags = 0;
#if defined(_DEBUG)
        createFactoryFlags = DXGI_CREATE_FACTORY_DEBUG;
#endif
        CreateDXGIFactory2(createFactoryFlags, IID_PPV_ARGS(&dxgiFactory4));
        DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {};
        swapChainDesc.Width = width;
        swapChainDesc.Height = height;
        swapChainDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
        swapChainDesc.Stereo = FALSE;
        swapChainDesc.SampleDesc = { 1, 0 };
        swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
        swapChainDesc.BufferCount = m_BufferCount;
        swapChainDesc.Scaling = DXGI_SCALING_STRETCH;
        swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
        swapChainDesc.AlphaMode = DXGI_ALPHA_MODE_UNSPECIFIED;
        swapChainDesc.Flags = CheckTearingSupport() ? DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING : 0;
        ComPtr<IDXGISwapChain1> swapChain1;
        dxgiFactory4->CreateSwapChainForHwnd(commandqueue.Get(), windowHandle, &swapChainDesc, nullptr, nullptr, &swapChain1);
        dxgiFactory4->MakeWindowAssociation(windowHandle, DXGI_MWA_NO_ALT_ENTER);
        swapChain1.As(&dxgiSwapChain4);
        return dxgiSwapChain4;
    }
    void D3D12Core::UpdateRenderTargetViews(ComPtr<IDXGISwapChain4> swapChain, ComPtr<ID3D12DescriptorHeap> descriptorHeap)
    {
        auto rtvDescriptorSize = m_Device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);

        CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHandle(descriptorHeap->GetCPUDescriptorHandleForHeapStart());

        for (int i = 0; i < m_BufferCount; ++i)
        {
            ComPtr<ID3D12Resource> BackBuffer;
            swapChain->GetBuffer(i, IID_PPV_ARGS(&BackBuffer));

            m_Device->CreateRenderTargetView(BackBuffer.Get(), nullptr, rtvHandle);

            m_BackBuffers[i] = BackBuffer;

            rtvHandle.Offset(rtvDescriptorSize);
        }
    }
    bool D3D12Core::CheckTearingSupport()
    {
        BOOL allowTearing = FALSE;
        ComPtr<IDXGIFactory4> factory4;
        if (SUCCEEDED(CreateDXGIFactory1(IID_PPV_ARGS(&factory4))))
        {
            ComPtr<IDXGIFactory5> factory5;
            if (SUCCEEDED(factory4.As(&factory5)))
            {
                if (FAILED(factory5->CheckFeatureSupport(
                    DXGI_FEATURE_PRESENT_ALLOW_TEARING,
                    &allowTearing, sizeof(allowTearing))))
                {
                    allowTearing = FALSE;
                }
            }
        }
        return allowTearing == TRUE;
    }
    void D3D12Core::ParseCommandLineArguments()
    {
        int argc;
        wchar_t** argv = ::CommandLineToArgvW(::GetCommandLineW(), &argc);
        for (size_t i = 0; i < argc; ++i)
        {
            if (::wcscmp(argv[i], L"-w") == 0 || ::wcscmp(argv[i], L"--width") == 0)
            {
                m_ClientWidth = ::wcstol(argv[++i], nullptr, 10);
            }
            if (::wcscmp(argv[i], L"-h") == 0 || ::wcscmp(argv[i], L"--height") == 0)
            {
                m_ClientHeight = ::wcstol(argv[++i], nullptr, 10);
            }
            if (::wcscmp(argv[i], L"-warp") == 0 || ::wcscmp(argv[i], L"--warp") == 0)
            {
                m_UseWarp = true;
            }
        }
        ::LocalFree(argv);
    }