// stdafx.h

// D3D12
#pragma comment(lib,"d3d12.lib")
#pragma comment(lib,"dxgi.lib")

#include <d3d12.h>
#include <dxgi1_6.h>

dev-dx12-202308（プロジェクト名）
└─ Source
   ├─ Application
   │  ├─ Application.h
   │  └─ Application.cpp
   ├─ Graphics
   │  ├─ GraphicsDevice.h
   │  └─ GraphicsDevice.cpp
   ├─ System
   │  ├─ Utility
   │  │  ├─ Utility.h
   │  │  └─ Utility.cpp
   │  ├─ Window
   │  │  ├─ Window.h
   │  │  └─ Window.cpp
   │  └─ System.h
   ├─ stdafx.h
   └─ stdafx.cpp

//GraphicsDevice.h

class GraphicsDevice {
public:
	bool Init();

	static GraphicsDevice& Instance() {
		static GraphicsDevice instance;
		return instance;
	}
private:
	bool CreateFactory();

	bool CreateDevice();

	enum class GPUTier {
		NVIDIA,
		Amd,
		Intel,
		Arm,
		Qualcomm,
		Kind,
	};

	ComPtr<ID3D12Device8>		m_pDevice = nullptr;
	ComPtr<IDXGIFactory6>		m_pDxgiFactory = nullptr;
	ComPtr<IDXGISwapChain4>		m_pSwapChain = nullptr;

	GraphicsDevice() {}
	~GraphicsDevice() {}
};

//GraphicsDevice.cpp

#include "GraphicsDevice.h"

bool GraphicsDevice::Init() {
	if (!CreateFactory()) {
		assert(0 && "ファクトリー作成失敗");
		return false;
	}

	if (!CreateDevice()) {
		assert(0 && "D3D12デバイス作成失敗");
		return false;
	}

	return true;
}

//GraphicsDevice.cpp

bool GraphicsDevice::CreateFactory() {
	UINT flagsDXGI = 0;
	flagsDXGI |= DXGI_CREATE_FACTORY_DEBUG;
	auto result = CreateDXGIFactory2(flagsDXGI, IID_PPV_ARGS(m_pDxgiFactory.GetAddressOf()));

	if (result) {
		return false;
	}

	return true;
}

//GraphicsDevice.cpp

bool GraphicsDevice::CreateDevice() {
	ComPtr<IDXGIAdapter> pSelectAdapter = nullptr;
	std::vector<ComPtr<IDXGIAdapter>> pAdapters;
	std::vector<DXGI_ADAPTER_DESC> descs;

	for (UINT index = 0; 1; ++index) {
		pAdapters.push_back(nullptr);
		HRESULT ret = m_pDxgiFactory->EnumAdapters(index, &pAdapters[index]);

		if (ret == DXGI_ERROR_NOT_FOUND) { break; }

		descs.push_back({});
		pAdapters[index]->GetDesc(&descs[index]);
	}

	GPUTier gpuTier = GPUTier::Kind;

	for (int i = 0; i < descs.size(); ++i) {
		if (std::wstring(descs[i].Description).find(L"NVIDIA") != std::wstring::npos) {
			pSelectAdapter = pAdapters[i];
			break;
		} else if (std::wstring(descs[i].Description).find(L"Amd") != std::wstring::npos) {
			if (gpuTier > GPUTier::Amd) {
				pSelectAdapter = pAdapters[i];
				gpuTier = GPUTier::Amd;
			}
		} else if (std::wstring(descs[i].Description).find(L"Intel") != std::wstring::npos) {
			if (gpuTier > GPUTier::Intel) {
				pSelectAdapter = pAdapters[i];
				gpuTier = GPUTier::Intel;
			}
		} else if (std::wstring(descs[i].Description).find(L"Arm") != std::wstring::npos) {
			if (gpuTier > GPUTier::Arm) {
				pSelectAdapter = pAdapters[i];
				gpuTier = GPUTier::Arm;
			}
		} else if (std::wstring(descs[i].Description).find(L"Qualcomm") != std::wstring::npos) {
			if (gpuTier > GPUTier::Qualcomm) {
				pSelectAdapter = pAdapters[i];
				gpuTier = GPUTier::Qualcomm;
			}
		}
	}

	D3D_FEATURE_LEVEL levels[] = {
		D3D_FEATURE_LEVEL_12_1,
		D3D_FEATURE_LEVEL_12_0,
		D3D_FEATURE_LEVEL_11_1,
		D3D_FEATURE_LEVEL_11_0,
	};

	D3D_FEATURE_LEVEL featureLevel;
	for (auto lv : levels) {
		if (D3D12CreateDevice(pSelectAdapter.Get(), lv, IID_PPV_ARGS(&m_pDevice)) == S_OK) {
			featureLevel = lv;
			break;
		}
	}

	return true;
}

// GraphicsDevice.h

class GraphicsDevice {
public:
	// ~ //

private:
	// ~ //
	bool CreateCommandList();
	// ~ //
	ComPtr<ID3D12CommandAllocator>			m_pCmdAllocator = nullptr;
	ComPtr<ID3D12GraphicsCommandList6>		m_pCmdList = nullptr;
	ComPtr<ID3D12CommandQueue>				m_pCmdQueue = nullptr;
	// ~ //
}

// GraphicsDevice.cpp

bool GraphicsDevice::Init() {
	// ~ //
	if (!CreateCommandList()) {
		assert(0 && "コマンドリストの作成失敗");
		return false;
	}
	// ~ //
}

// ~ //

bool GraphicsDevice::CreateCommandList() {
	auto hr = m_pDevice->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&m_pCmdAllocator));

	if (FAILED(hr)) {
		return false;
	}

	hr = m_pDevice->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, m_pCmdAllocator.Get(), nullptr, IID_PPV_ARGS(&m_pCmdList));

	if (FAILED(hr)) {
		return false;
	}

	D3D12_COMMAND_QUEUE_DESC cmdQueueDesc = {};
	cmdQueueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;				// タイムアウトなし
	cmdQueueDesc.NodeMask = 0;										// アダプターを1つしか使わないときは0でいい
	cmdQueueDesc.Priority = D3D12_COMMAND_QUEUE_PRIORITY_NORMAL;	// プライオリティは特に指定なし
	cmdQueueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;				// コマンドリストと合わせる

	// キュー生成
	hr = m_pDevice->CreateCommandQueue(&cmdQueueDesc, IID_PPV_ARGS(&m_pCmdQueue));

	if (FAILED(hr)) {
		return false;
	}

	return true;
}

// GraphicsDevice.h

class GraphicsDevice {
public:
	bool Init(HWND hWnd, int w, int h);
	// ~ //

private:
	// ~ //
	bool CreateSwaphcain(HWND hWnd, int width, int height);
	// ~ //
	ComPtr<IDXGISwapChain4>		m_pSwapChain = nullptr;
	// ~ //
}

// GraphicsDevice.cpp

bool GraphicsDevice::Init(HWND hWnd, int w, int h) {
	// ~ //
	if (!CreateSwapchain(hWnd, w, h)) {
		assert(0 && "スワップチェインの作成失敗");
		return false;
	}
	// ~ //
}

// ~ //

bool GraphicsDevice::CreateSwapchain(HWND hWnd, int width, int height) {
	DXGI_SWAP_CHAIN_DESC1 swapchainDesc = {};
	swapchainDesc.Width = width;
	swapchainDesc.Height = height;
	swapchainDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
	swapchainDesc.SampleDesc.Count = 1;
	swapchainDesc.BufferUsage = DXGI_USAGE_BACK_BUFFER;
	swapchainDesc.BufferCount = 2;
	swapchainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
	swapchainDesc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;

	auto hr = m_pDxgiFactory->CreateSwapChainForHwnd(m_pCmdQueue.Get(), hWnd, &swapchainDesc, nullptr, nullptr, (IDXGISwapChain1**)m_pSwapChain.GetAddressOf());

	if (FAILED(hr)) {
		return false;
	}

	return true;
}

// Application.cpp

void Application::Execute() {
	// ~ //
	if (!GraphicsDevice::Instance().Init(m_window.GetWndHandle(), width, height)) {
		assert(0 && "グラフィックスデバイス初期化失敗。");
		return;
	}
	// ~ //
}

// Window.h

class Window {
public:
	HWND GetWndHandle() const {
		return m_hWnd;
	}
	
	// ~ //

private:
	// ~ //
};

dev-dx12-202308（プロジェクト名）
└─ Source
   ├─ Application
   │  ├─ Application.h
   │  └─ Application.cpp
   ├─ Graphics
   │  ├─ GraphicsDevice.h
   │  ├─ GraphicsDevice.cpp
   │  └─ RTVHeap
   │     ├─ RTVHeap.h
   │     └─ RTVHeap.cpp
   ├─ System
   │  ├─ Utility
   │  │  ├─ Utility.h
   │  │  └─ Utility.cpp
   │  ├─ Window
   │  │  ├─ Window.h
   │  │  └─ Window.cpp
   │  └─ System.h
   ├─ stdafx.h
   └─ stdafx.cpp

// RTVHeap.h

class RTVHeap {
public:
	bool Create(ID3D12Device* pDevice, int useCount);
	int CreateRTV(ID3D12Resource* pBuffer);
	D3D12_CPU_DESCRIPTOR_HANDLE GetRTVCPUHandle(int number);

private:
	ID3D12Device* m_pDevice = nullptr;
	ComPtr<ID3D12DescriptorHeap> m_pHeap = nullptr;
	int m_useCount = 0;
	int m_incrementSize = 0;
	int m_nextRegistNumber = 0;
};

// RTVHeap.cpp

bool RTVHeap::Create(ID3D12Device* pDevice, int useCount) {
	D3D12_DESCRIPTOR_HEAP_DESC heapDesc = {};

	heapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
	heapDesc.NodeMask = 0;
	heapDesc.NumDescriptors = useCount;
	heapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;

	auto hr = pDevice->CreateDescriptorHeap(&heapDesc, IID_PPV_ARGS(&m_pHeap));

	if (FAILED(hr)) {
		return false;
	}

	m_useCount = useCount;
	m_incrementSize = pDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
	m_pDevice = pDevice;

	return true;
}

// RTVHeap.cpp

int RTVHeap::CreateRTV(ID3D12Resource* pBuffer) {
	if (m_useCount < m_nextRegistNumber) {
		assert(0 && "確保済みのヒープ領域を超えました。");
		return 0;
	}

	D3D12_CPU_DESCRIPTOR_HANDLE handle = m_pHeap->GetCPUDescriptorHandleForHeapStart();
	handle.ptr += (UINT64)m_nextRegistNumber * m_incrementSize;
	D3D12_RENDER_TARGET_VIEW_DESC rtvDesc = {};
	rtvDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
	rtvDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2D;
	m_pDevice->CreateRenderTargetView(pBuffer, &rtvDesc, handle);
	return m_nextRegistNumber++;
}

// RTVHeap.cpp

D3D12_CPU_DESCRIPTOR_HANDLE RTVHeap::GetRTVCPUHandle(int number) {
	D3D12_CPU_DESCRIPTOR_HANDLE handle = m_pHeap->GetCPUDescriptorHandleForHeapStart();
	handle.ptr += (UINT64)m_incrementSize * number;
	return handle;
}

// System.h
#pragma once

#include "Utility/Utility.h"

#include "../Graphics/RTVHeap/RTVHeap.h"	// GraphicsDevice.hよりも先にインクルード

#include "../Graphics/GraphicsDevice.h"

// GraphicsDevice.h

class GraphicsDevice {
public:
	// ~ //

private:
	// ~ //
	bool CreateSwapchainRTV();
	// ~ //
	std::array<ComPtr<ID3D12Resource>, 2>	m_pSwapchainBuffers;
	std::unique_ptr<RTVHeap>	m_pRTVHeap = nullptr;;
	// ~ //
}

// GraphicsDevice.cpp

bool GraphicsDevice::Init(HWND hWnd, int w, int h) {
	// ~ //
	m_pRTVHeap = std::make_unique<RTVHeap>();
	if (!m_pRTVHeap->Create(m_pDevice.Get(), 100)) {
		assert(0 && "RTVヒープの作成失敗");
		return false;
	}

	if (!CreateSwapchainRTV()) {
		assert(0 && "スワップチェーンRTVの作成失敗");
		return false;
	}
	// ~ //
}

// ~ //

bool GraphicsDevice::CreateSwapchainRTV() {
	for (int i = 0; i < (int)m_pSwapchainBuffers.size(); ++i) {
		auto hr = m_pSwapChain->GetBuffer(i, IID_PPV_ARGS(&m_pSwapchainBuffers[i]));

		if (FAILED(hr)) {
			return false;
		}

		m_pRTVHeap->CreateRTV(m_pSwapchainBuffers[i].Get());
	}

	return true;
}

// GraphicsDevice.h

class GraphicsDevice {
public:
	// ~ //

private:
	// ~ //
	void EnableDebugLayer();
	// ~ //
}

// GraphicsDevice.cpp

bool GraphicsDevice::Init(HWND hWnd, int w, int h) {
	// ~ //
		if (!CreateFactory()) {
		assert(0 && "ファクトリー作成失敗");
		return false;
	}

#ifdef _DEBUG
	EnableDebugLayer();
#endif

	if (!CreateDevice()) {
		assert(0 && "D3D12デバイス作成失敗");
		return false;
	}
	// ~ //
}

// GraphicsDevice.cpp

void GraphicsDevice::EnableDebugLayer() {
	ID3D12Debug* pDebugLayer = nullptr;

	D3D12GetDebugInterface(IID_PPV_ARGS(&pDebugLayer));
	pDebugLayer->EnableDebugLayer();		// デバッグレイヤーを有効にする
	pDebugLayer->Release();
}

// GraphicsDevice.h

class GraphicsDevice {
public:
	// ~ //
	void ScreenFlip();

	void WaitForCommandQueue();
	// ~ //

private:
	// ~ //
	bool CreateFence();

	void SetResourceBarrier(ID3D12Resource* pResource, D3D12_RESOURCE_STATES before, D3D12_RESOURCE_STATES after);
	// ~ //
	ComPtr<ID3D12Fence>		m_pFence = nullptr;
	UINT64		m_fenceVal = 0;
	// ~ //
}

// GraphicsDevice.cpp

bool GraphicsDevice::Init(HWND hWnd, int w, int h) {
	// ~ //
	if (!CreateFence()) {
		assert(0 && "フェンスの作成失敗");
		return false;
	}
	// ~ //
}

// GraphicsDevice.cpp

void GraphicsDevice::ScreenFlip() {
	auto bbIdx = m_pSwapChain->GetCurrentBackBufferIndex();
	SetResourceBarrier(m_pSwapchainBuffers[bbIdx].Get(),
		D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_RENDER_TARGET);

	auto rtvH = m_pRTVHeap->GetRTVCPUHandle(bbIdx);
	m_pCmdList->OMSetRenderTargets(1, &rtvH, false, nullptr);

	float clearColor[] = { 1.0f, 0.0f, 1.0f, 1.0f };
	m_pCmdList->ClearRenderTargetView(rtvH, clearColor, 0, nullptr);

	SetResourceBarrier(m_pSwapchainBuffers[bbIdx].Get(), D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT);

	m_pCmdList->Close();
	ID3D12CommandList* cmdlists[]{ m_pCmdList.Get() };
	m_pCmdQueue->ExecuteCommandLists(1, cmdlists);

	WaitForCommandQueue();

	m_pCmdAllocator->Reset();
	m_pCmdList->Reset(m_pCmdAllocator.Get(), nullptr);

	m_pSwapChain->Present(1, 0);
}

// GraphicsDevice.cpp

void GraphicsDevice::WaitForCommandQueue() {
	m_pCmdQueue->Signal(m_pFence.Get(), ++m_fenceVal);

	if (m_pFence->GetCompletedValue() != m_fenceVal) {
		auto event = CreateEvent(nullptr, false, false, nullptr);		// イベントハンドルの取得
		if (!event) {
			assert(0 && "イベントエラー、アプリケーションを終了します");
		}
		m_pFence->SetEventOnCompletion(m_fenceVal, event);
		WaitForSingleObject(event, INFINITE);		// イベントが発生するまで待ち続ける
		CloseHandle(event);							// イベントハンドルを閉じる
	}
}

// GraphicsDevice.cpp

bool GraphicsDevice::CreateFence() {
	auto hr = m_pDevice->CreateFence(m_fenceVal, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&m_pFence));

	if (FAILED(hr)) {
		return false;
	}

	return true;
}

// GraphicsDevice.cpp

void GraphicsDevice::SetResourceBarrier(ID3D12Resource* pResource, D3D12_RESOURCE_STATES before, D3D12_RESOURCE_STATES after) {
	D3D12_RESOURCE_BARRIER barrier = {};
	barrier.Transition.pResource = pResource;
	barrier.Transition.StateAfter = after;
	barrier.Transition.StateBefore = before;
	m_pCmdList->ResourceBarrier(1, &barrier);
}

// Application.cpp

void Application::Execute() {
	// ~ //
	while (true) {
		// ~ //
		GraphicsDevice::Instance().ScreenFlip();
	}
}