// stdafx.h

// ~ //

// DirectX Took Kit
#pragma comment(lib, "DirectXTK12.lib")
#include <SimpleMath.h>

// ~ //

// Utility.h

// ~ //

namespace Math = DirectX::SimpleMath;

dev-dx12-202308（プロジェクト名）
└─ Source
   ├─ Application
   │  ├─ Application.h
   │  └─ Application.cpp
   ├─ Graphics
   │  ├─ Mesh
   │  │  ├─ Mesh.h
   │  │  └─ Mesh.cpp
   │  ├─ 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:
	// ~ //

	ID3D12Device8* GetDevice()const {
		return m_pDevice.Get();
	}

	ID3D12GraphicsCommandList6* GetCmdList()const {
		return m_pCmdList.Get();
	}

	// ~ //

//Mesh.h

class Mesh {
public:
	void Create(GraphicsDevice* pGraphicsDevice);

	void DrawInstanced()const;

private:
	GraphicsDevice* m_pDevice = nullptr;
	ComPtr<ID3D12Resource>		m_pVBuffer = nullptr;
	ComPtr<ID3D12Resource>		m_pIBuffer = nullptr;
	D3D12_VERTEX_BUFFER_VIEW	m_vbView;
	D3D12_INDEX_BUFFER_VIEW		m_ibView;

	std::array<Math::Vector3, 3> m_vertices;
};

//Mesh.cpp

void Mesh::Create(GraphicsDevice* pGraphicsDevice) {
	m_pDevice = pGraphicsDevice;

	m_vertices[0] = { -0.75f, -0.75f, 0.0f };
	m_vertices[1] = {   0.0f,  0.75f, 0.0f };
	m_vertices[2] = {  0.75f, -0.75f, 0.0f };

	D3D12_HEAP_PROPERTIES heapProp = {};
	heapProp.Type = D3D12_HEAP_TYPE_UPLOAD;
	heapProp.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
	heapProp.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;

	D3D12_RESOURCE_DESC resDesc = {};
	resDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
	resDesc.Width = sizeof(Math::Vector3) * m_vertices.size();
	resDesc.Height = 1;
	resDesc.DepthOrArraySize = 1;
	resDesc.MipLevels = 1;
	resDesc.Format = DXGI_FORMAT_UNKNOWN;
	resDesc.SampleDesc.Count = 1;
	resDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
	resDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;

	auto hr = m_pDevice->GetDevice()->CreateCommittedResource(&heapProp, D3D12_HEAP_FLAG_NONE, &resDesc, D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&m_pVBuffer));

	if (FAILED(hr)) {
		assert(0 && "頂点バッファー作成失敗");
		return;
	}

	m_vbView.BufferLocation = m_pVBuffer->GetGPUVirtualAddress();
	m_vbView.SizeInBytes = (UINT)resDesc.Width;
	m_vbView.StrideInBytes = sizeof(Math::Vector3);

	Math::Vector3* vbMap = nullptr;
	{
		m_pVBuffer->Map(0, nullptr, (void**)&vbMap);
		std::copy(std::begin(m_vertices), std::end(m_vertices), vbMap);
		m_pVBuffer->Unmap(0, nullptr);
	}
}

//Mesh.cpp

void Mesh::DrawInstanced()const
{
	m_pDevice->GetCmdList()->IASetVertexBuffers(0, 1, &m_vbView);
	m_pDevice->GetCmdList()->DrawInstanced(3, 1, 0, 0);
}

//System.h

#include "Utility/Utility.h"

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

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

#include "../Graphics/Mesh/Mesh.h"

dev-dx12-202308（プロジェクト名）
├─ Asset
│  └─ Shader
│     ├─ SimpleShader_VS.hlsl
│     └─ SimpleShader_PS.hlsl
└─ Source
   ├─ Application
   │  ├─ Application.h
   │  └─ Application.cpp
   ├─ Graphics
   │  ├─ Mesh
   │  │  ├─ Mesh.h
   │  │  └─ Mesh.cpp
   │  ├─ Shader
   │  │  ├─ RootSignature
   │  │  │  ├─ RootSignature.h
   │  │  │  └─ RootSignature.cpp
   │  │  ├─ Pipeline
   │  │  │  ├─ Pipeline.h
   │  │  │  └─ Pipeline.cpp
   │  │  ├─ Shader.h
   │  │  └─ Shader.cpp
   │  ├─ GraphicsDevice.h
   │  └─ GraphicsDevice.cpp
   ├─ System
   │  ├─ Utility
   │  │  ├─ Utility.h
   │  │  └─ Utility.cpp
   │  ├─ Window
   │  │  ├─ Window.h
   │  │  └─ Window.cpp
   │  └─ System.h
   ├─ stdafx.h
   └─ stdafx.cpp

// SimpleShader_VS.hlsl

float4 main( float4 pos : POSITION ) : SV_POSITION {
	return pos;
}

// SimpleShader_PS.hlsl

float4 main(float4 pos : SV_POSITION) : SV_TARGET {
	return float4(1.0f, 1.0f, 1.0f, 1.0f);
}

// RootSignature.h

enum class RangeType {
	CBV,
	SRV,
	UAV,
};

// RootSignature.h

enum class TextureAddressMode {
	Wrap,
	Clamp,
};

// RootSignature.h

enum class D3D12Filter {
	Point,
	Linear,
};

// RootSignature.h

class RootSignature {
public:
	void Create(GraphicsDevice* pGraphicsDevice, const std::vector<RangeType>& rangeTypes);

	ID3D12RootSignature* GetRootSignature() { return m_pRootSignature.Get(); }

private:
	void CreateRange(D3D12_DESCRIPTOR_RANGE& pRange, RangeType type, int count);

	void CreateStaticSampler(D3D12_STATIC_SAMPLER_DESC& samplerDesc, TextureAddressMode mode, D3D12Filter filter, int count);

	GraphicsDevice* m_pDevice = nullptr;
	ComPtr<ID3DBlob> m_pRootBlob = nullptr;
	ComPtr<ID3D12RootSignature> m_pRootSignature = nullptr;
};

// RootSignature.cpp

void RootSignature::Create(GraphicsDevice* pGraphicsDevice, const std::vector<RangeType>& rangeTypes) {
	m_pDevice = pGraphicsDevice;

	D3D12_ROOT_SIGNATURE_DESC rootSignatureDesc = {};
	int rangeCount = (int)rangeTypes.size();

	std::vector<D3D12_ROOT_PARAMETER> rootParams(rangeCount);
	std::vector<D3D12_DESCRIPTOR_RANGE> ranges(rangeCount);

	int samplerCount = 0;

	for (int i = 0; i < (int)rangeTypes.size(); ++i) {
		if (rangeTypes[i] == RangeType::SRV) {
			++samplerCount;
		}
	}

	samplerCount = 0;
	bool bSampler = false;
	int cbvCount = 0;
	int uavCount = 0;

	for (int i = 0; i < rangeCount; ++i) {
		switch (rangeTypes[i]) {
		case RangeType::CBV:
			CreateRange(ranges[i], RangeType::CBV, cbvCount);
			rootParams[i].ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
			rootParams[i].DescriptorTable.pDescriptorRanges = &ranges[i];
			rootParams[i].DescriptorTable.NumDescriptorRanges = 1;
			rootParams[i].ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL;
			++cbvCount;
			break;
		case RangeType::SRV:
			CreateRange(ranges[i], RangeType::SRV, samplerCount);
			rootParams[i].ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
			rootParams[i].DescriptorTable.pDescriptorRanges = &ranges[i];
			rootParams[i].DescriptorTable.NumDescriptorRanges = 1;
			rootParams[i].ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL;
			++samplerCount;
			bSampler = true;
			break;
		case RangeType::UAV:
			CreateRange(ranges[i], RangeType::UAV, uavCount);
			rootParams[i].ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
			rootParams[i].DescriptorTable.pDescriptorRanges = &ranges[i];
			rootParams[i].DescriptorTable.NumDescriptorRanges = 1;
			rootParams[i].ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL;
			++uavCount;
			break;
		default:
			break;
		}
	}

	std::array<D3D12_STATIC_SAMPLER_DESC, 4> pStaticSamplerDescs = {};

	if (bSampler) {
		CreateStaticSampler(pStaticSamplerDescs[0], TextureAddressMode::Wrap, D3D12Filter::Point, 0);
		CreateStaticSampler(pStaticSamplerDescs[1], TextureAddressMode::Clamp, D3D12Filter::Point, 1);
		CreateStaticSampler(pStaticSamplerDescs[2], TextureAddressMode::Wrap, D3D12Filter::Linear, 2);
		CreateStaticSampler(pStaticSamplerDescs[3], TextureAddressMode::Clamp, D3D12Filter::Linear, 3);
	}

	rootSignatureDesc.pStaticSamplers = bSampler ? pStaticSamplerDescs.data() : nullptr;
	rootSignatureDesc.NumStaticSamplers = bSampler ? 4 : 0;
	rootSignatureDesc.Flags = D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT;
	rootSignatureDesc.pParameters = rootParams.data();
	rootSignatureDesc.NumParameters = (int)rangeTypes.size();

	ID3DBlob* pErrorBlob = nullptr;
	auto hr = D3D12SerializeRootSignature(&rootSignatureDesc, D3D_ROOT_SIGNATURE_VERSION_1_0, &m_pRootBlob, &pErrorBlob);

	if (FAILED(hr)) {
		assert(0 && "ルートシグネチャ初期化失敗");
	}

	hr = m_pDevice->GetDevice()->CreateRootSignature(0, m_pRootBlob->GetBufferPointer(), m_pRootBlob->GetBufferSize(), IID_PPV_ARGS(&m_pRootSignature));

	if (FAILED(hr)) {
		assert(0 && "ルートシグネチャ作成失敗");
	}
}

// RootSignature.cpp

void RootSignature::CreateRange(D3D12_DESCRIPTOR_RANGE& pRange, RangeType type, int count) {
	switch (type) {
	case RangeType::CBV:
		pRange = {};
		pRange.NumDescriptors = 1;
		pRange.RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_CBV;
		pRange.BaseShaderRegister = count;
		pRange.OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
		break;
	case RangeType::SRV:
		pRange = {};
		pRange.NumDescriptors = 1;
		pRange.RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV;
		pRange.BaseShaderRegister = count;
		pRange.OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
		break;
	case RangeType::UAV:
		pRange = {};
		pRange.NumDescriptors = 1;
		pRange.RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_UAV;
		pRange.BaseShaderRegister = count;
		pRange.OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
		break;
	default:
		break;
	}
}

// RootSignature.cpp

void RootSignature::CreateStaticSampler(D3D12_STATIC_SAMPLER_DESC& pSamplerDesc, TextureAddressMode mode, D3D12Filter filter, int count) {
	D3D12_TEXTURE_ADDRESS_MODE addressMode = mode == TextureAddressMode::Wrap ? D3D12_TEXTURE_ADDRESS_MODE_WRAP : D3D12_TEXTURE_ADDRESS_MODE_CLAMP;

	D3D12_FILTER samplingFilter = filter == D3D12Filter::Point ? D3D12_FILTER_MIN_MAG_MIP_POINT : D3D12_FILTER_MIN_MAG_MIP_LINEAR;

	pSamplerDesc = {};
	pSamplerDesc.AddressU = addressMode;
	pSamplerDesc.AddressV = addressMode;
	pSamplerDesc.AddressW = addressMode;
	pSamplerDesc.BorderColor = D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK;
	pSamplerDesc.Filter = samplingFilter;
	pSamplerDesc.MaxLOD = D3D12_FLOAT32_MAX;
	pSamplerDesc.MinLOD = 0.0f;
	pSamplerDesc.ComparisonFunc = D3D12_COMPARISON_FUNC_NEVER;
	pSamplerDesc.ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL;
	pSamplerDesc.MaxAnisotropy = 16;
	pSamplerDesc.ShaderRegister = count;
}

// Pipeline.h

enum class CullMode {
	None = D3D12_CULL_MODE_NONE,
	Front = D3D12_CULL_MODE_FRONT,
	Back = D3D12_CULL_MODE_BACK,
};

// Pipeline.h

enum class BlendMode {
	Add,
	Alpha,
};

// Pipeline.h

enum class InputLayout {
	POSITION,
	TEXCOORD,
	NORMAL,
	TANGENT,
	COLOR,
	SKININDEX,
	SKINWEIGHT
};

// Pipeline.h

enum class PrimitiveTopologyType {
	Undefined = D3D12_PRIMITIVE_TOPOLOGY_TYPE_UNDEFINED,
	Point = D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT,
	Line = D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE,
	Triangle = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE,
	Patch = D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH,
};

// Pipeline.h

class RootSignature;

// Pipeline.h

class Pipeline {
public:
	void SetRenderSettings(GraphicsDevice* pGraphicsDevice, RootSignature* pRootSignature, const std::vector<InputLayout>& inputLayouts, CullMode cullMode, BlendMode blendMode, PrimitiveTopologyType topologyType);

	void Create(std::vector<ID3DBlob*> pBlobs, const std::vector<DXGI_FORMAT> formats, bool isDepth, bool isDepthMask, int rtvCount, bool isWireFrame);

	ID3D12PipelineState* GetPipeline() { return m_pPipelineState.Get(); }

	PrimitiveTopologyType GetTopologyType() { return m_topologyType; }

private:
	void SetInputLayout(std::vector<D3D12_INPUT_ELEMENT_DESC>& inputElements, const std::vector<InputLayout>& inputLayouts);

	void SetBlendMode(D3D12_RENDER_TARGET_BLEND_DESC& blendDesc, BlendMode blendMode);

	GraphicsDevice* m_pDevice = nullptr;
	RootSignature* m_pRootSignature = nullptr;

	std::vector<InputLayout>	m_inputLayouts;
	CullMode					m_cullMode;
	BlendMode					m_blendMode;
	PrimitiveTopologyType		m_topologyType;

	ComPtr<ID3D12PipelineState> m_pPipelineState = nullptr;
};

// Pipeline.cpp

void Pipeline::SetRenderSettings(GraphicsDevice* pGraphicsDevice, RootSignature* pRootSignature, const std::vector<InputLayout>& inputLayouts, CullMode cullMode, BlendMode blendMode, PrimitiveTopologyType topologyType) {
	m_pDevice = pGraphicsDevice;
	m_pRootSignature = pRootSignature;
	m_inputLayouts = inputLayouts;
	m_cullMode = cullMode;
	m_blendMode = blendMode;
	m_topologyType = topologyType;
}

// Pipeline.cpp

void Pipeline::Create(std::vector<ID3DBlob*> pBlobs, const std::vector<DXGI_FORMAT> formats, bool bDepth, bool bDepthMask, int rtvCount, bool bWireFrame) {
	std::vector<D3D12_INPUT_ELEMENT_DESC> inputLayouts;
	SetInputLayout(inputLayouts, m_inputLayouts);

	D3D12_GRAPHICS_PIPELINE_STATE_DESC graphicsPipelineState = {};

	graphicsPipelineState.VS.pShaderBytecode = pBlobs[0]->GetBufferPointer();
	graphicsPipelineState.VS.BytecodeLength = pBlobs[0]->GetBufferSize();

	if (pBlobs[1]) {
		graphicsPipelineState.HS.pShaderBytecode = pBlobs[1]->GetBufferPointer();
		graphicsPipelineState.HS.BytecodeLength = pBlobs[1]->GetBufferSize();
	}

	if (pBlobs[2]) {
		graphicsPipelineState.DS.pShaderBytecode = pBlobs[2]->GetBufferPointer();
		graphicsPipelineState.DS.BytecodeLength = pBlobs[2]->GetBufferSize();
	}

	if (pBlobs[3]) {
		graphicsPipelineState.GS.pShaderBytecode = pBlobs[3]->GetBufferPointer();
		graphicsPipelineState.GS.BytecodeLength = pBlobs[3]->GetBufferSize();
	}

	graphicsPipelineState.PS.pShaderBytecode = pBlobs[4]->GetBufferPointer();
	graphicsPipelineState.PS.BytecodeLength = pBlobs[4]->GetBufferSize();

	graphicsPipelineState.SampleMask = D3D12_DEFAULT_SAMPLE_MASK;

	graphicsPipelineState.RasterizerState.CullMode = static_cast<D3D12_CULL_MODE>(m_cullMode);

	if (bWireFrame) {
		graphicsPipelineState.RasterizerState.FillMode = D3D12_FILL_MODE_WIREFRAME;
	}
	else {
		graphicsPipelineState.RasterizerState.FillMode = D3D12_FILL_MODE_SOLID;
	}

	if (bDepth) {
		graphicsPipelineState.RasterizerState.DepthClipEnable = true;
		graphicsPipelineState.DepthStencilState.DepthEnable = true;

		if (bDepthMask) {
			graphicsPipelineState.DepthStencilState.DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
		}
		else {
			graphicsPipelineState.DepthStencilState.DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ZERO;
		}
		graphicsPipelineState.DepthStencilState.DepthFunc = D3D12_COMPARISON_FUNC_LESS;
		graphicsPipelineState.DSVFormat = DXGI_FORMAT_D32_FLOAT;
	}
	else {
		graphicsPipelineState.RasterizerState.DepthClipEnable = false;
		graphicsPipelineState.DepthStencilState.DepthEnable = false;
	}

	graphicsPipelineState.BlendState.AlphaToCoverageEnable = false;

	graphicsPipelineState.BlendState.IndependentBlendEnable = false;

	D3D12_RENDER_TARGET_BLEND_DESC blendDesc = {};
	SetBlendMode(blendDesc, m_blendMode);

	graphicsPipelineState.BlendState.RenderTarget[0] = blendDesc;

	graphicsPipelineState.InputLayout.pInputElementDescs = inputLayouts.data();
	graphicsPipelineState.InputLayout.NumElements = (int)m_inputLayouts.size();

	graphicsPipelineState.PrimitiveTopologyType = (pBlobs[3] && pBlobs[4]) ? D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH : static_cast<D3D12_PRIMITIVE_TOPOLOGY_TYPE>(m_topologyType);

	graphicsPipelineState.NumRenderTargets = rtvCount;

	for (int i = 0; i < rtvCount; ++i) {
		graphicsPipelineState.RTVFormats[i] = formats[i];
	}

	graphicsPipelineState.SampleDesc.Count = 1;
	graphicsPipelineState.pRootSignature = m_pRootSignature->GetRootSignature();

	auto hr = m_pDevice->GetDevice()->CreateGraphicsPipelineState(&graphicsPipelineState, IID_PPV_ARGS(&m_pPipelineState));

	if (FAILED(hr)) {
		assert(0 && "パイプラインステートの作成に失敗しました");
		return;
	}
}

// Pipeline.cpp

void Pipeline::SetInputLayout(std::vector<D3D12_INPUT_ELEMENT_DESC>& inputElements, const std::vector<InputLayout>& inputLayouts) {
	for (int i = 0; i < (int)inputLayouts.size(); ++i) {
		if (inputLayouts[i] == InputLayout::POSITION) {
			inputElements.emplace_back(D3D12_INPUT_ELEMENT_DESC{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 });
		}
		else if (inputLayouts[i] == InputLayout::TEXCOORD) {
			inputElements.emplace_back(D3D12_INPUT_ELEMENT_DESC{ "TEXCOORD",0,DXGI_FORMAT_R32G32_FLOAT,0, D3D12_APPEND_ALIGNED_ELEMENT,D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA ,0 });
		}
		else if (inputLayouts[i] == InputLayout::NORMAL) {
			inputElements.emplace_back(D3D12_INPUT_ELEMENT_DESC{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 });
		}
		else if (inputLayouts[i] == InputLayout::COLOR) {
			inputElements.emplace_back(D3D12_INPUT_ELEMENT_DESC{ "COLOR", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 });
		}
		else if (inputLayouts[i] == InputLayout::TANGENT) {
			inputElements.emplace_back(D3D12_INPUT_ELEMENT_DESC{ "TANGENT", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 });
		}
		else if (inputLayouts[i] == InputLayout::SKININDEX) {
			inputElements.emplace_back(D3D12_INPUT_ELEMENT_DESC{ "SKININDEX", 0, DXGI_FORMAT_R16G16B16A16_UINT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 });
		}
		else if (inputLayouts[i] == InputLayout::SKINWEIGHT) {
			inputElements.emplace_back(D3D12_INPUT_ELEMENT_DESC{ "SKINWEIGHT", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 });
		}
	}
}

// Pipeline.cpp

void Pipeline::SetBlendMode(D3D12_RENDER_TARGET_BLEND_DESC& blendDesc, BlendMode blendMode) {
	blendDesc.RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL;
	blendDesc.BlendEnable = true;

	switch (blendMode) {
	case BlendMode::Add:
		blendDesc.BlendOp = D3D12_BLEND_OP_ADD;
		blendDesc.SrcBlend = D3D12_BLEND_SRC_ALPHA;
		blendDesc.DestBlend = D3D12_BLEND_ONE;

		blendDesc.BlendOpAlpha = D3D12_BLEND_OP_ADD;
		blendDesc.SrcBlendAlpha = D3D12_BLEND_ONE;
		blendDesc.DestBlendAlpha = D3D12_BLEND_INV_SRC_ALPHA;
		blendDesc.LogicOp = D3D12_LOGIC_OP_NOOP;
		break;
	case BlendMode::Alpha:
		blendDesc.BlendOp = D3D12_BLEND_OP_ADD;
		blendDesc.SrcBlend = D3D12_BLEND_SRC_ALPHA;
		blendDesc.DestBlend = D3D12_BLEND_INV_SRC_ALPHA;

		blendDesc.BlendOpAlpha = D3D12_BLEND_OP_ADD;
		blendDesc.SrcBlendAlpha = D3D12_BLEND_ONE;
		blendDesc.DestBlendAlpha = D3D12_BLEND_INV_SRC_ALPHA;
		blendDesc.LogicOp = D3D12_LOGIC_OP_NOOP;
		break;
	default:
		break;
	}
}

// Shader.h

struct RenderingSetting {
	std::vector<InputLayout> InputLayouts;
	std::vector<DXGI_FORMAT> Formats;
	CullMode CullMode = CullMode::Back;
	BlendMode BlendMode = BlendMode::Alpha;
	PrimitiveTopologyType PrimitiveTopologyType = PrimitiveTopologyType::Triangle;
	bool IsDepth = true;
	bool IsDepthMask = true;
	int RTVCount = 1;
	bool IsWireFrame = false;
};

// Shader.h

class Shader {
public:
	void Create(GraphicsDevice* pGraphicsDevice, const std::wstring& filePath, const RenderingSetting& renderingSetting, const std::vector<RangeType>& rangeTypes);

	void Begin(int w, int h);

	void DrawMesh(const Mesh& mesh);

private:
	void LoadShaderFile(const std::wstring& filePath);

	GraphicsDevice* m_pDevice = nullptr;

	std::unique_ptr<Pipeline>		m_upPipeline = nullptr;
	std::unique_ptr<RootSignature>	m_upRootSignature = nullptr;

	ID3DBlob* m_pVSBlob = nullptr;		// 頂点シェーダー
	ID3DBlob* m_pHSBlob = nullptr;		// ハルシェーダー
	ID3DBlob* m_pDSBlob = nullptr;		// ドメインシェーダー
	ID3DBlob* m_pGSBlob = nullptr;		// ジオメトリシェーダー
	ID3DBlob* m_pPSBlob = nullptr;		// ピクセルシェーダー
};

// Shader.cpp

void Shader::Create(GraphicsDevice* pGraphicsDevice, const std::wstring& filePath, const RenderingSetting& renderingSetting, const std::vector<RangeType>& rangeTypes) {
	m_pDevice = pGraphicsDevice;

	LoadShaderFile(filePath);

	m_upRootSignature = std::make_unique<RootSignature>();
	m_upRootSignature->Create(pGraphicsDevice, rangeTypes);

	m_upPipeline = std::make_unique<Pipeline>();
	m_upPipeline->SetRenderSettings(pGraphicsDevice, m_upRootSignature.get(), renderingSetting.InputLayouts, renderingSetting.CullMode, renderingSetting.BlendMode, renderingSetting.PrimitiveTopologyType);
	m_upPipeline->Create({ m_pVSBlob ,m_pHSBlob ,m_pDSBlob ,m_pGSBlob ,m_pPSBlob }, renderingSetting.Formats, renderingSetting.IsDepth, renderingSetting.IsDepthMask, renderingSetting.RTVCount, renderingSetting.IsWireFrame);
}

// Shader.cpp

void Shader::Begin(int w, int h) {
	m_pDevice->GetCmdList()->SetPipelineState(m_upPipeline->GetPipeline());

	m_pDevice->GetCmdList()->SetGraphicsRootSignature(m_upRootSignature->GetRootSignature());

	D3D12_PRIMITIVE_TOPOLOGY_TYPE topologyType = static_cast<D3D12_PRIMITIVE_TOPOLOGY_TYPE>(m_upPipeline->GetTopologyType());

	switch (topologyType) {
	case D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT:
		m_pDevice->GetCmdList()->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_POINTLIST);
		break;
	case D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE:
		m_pDevice->GetCmdList()->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_LINELIST);
		break;
	case D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE:
		m_pDevice->GetCmdList()->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
		break;
	case D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH:
		m_pDevice->GetCmdList()->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST);
		break;
	}

	D3D12_VIEWPORT viewport = {};
	D3D12_RECT rect = {};

	viewport.Width = static_cast<float>(w);
	viewport.Height = static_cast<float>(h);
	viewport.MinDepth = 0.0f;
	viewport.MaxDepth = 1.0f;

	rect.right = w;
	rect.bottom = h;

	GraphicsDevice::Instance().GetCmdList()->RSSetViewports(1, &viewport);
	GraphicsDevice::Instance().GetCmdList()->RSSetScissorRects(1, &rect);
}

// Shader.cpp

void Shader::DrawMesh(const Mesh& mesh) {
	mesh.DrawInstanced();
}

// Shader.cpp

void Shader::LoadShaderFile(const std::wstring& filePath) {
	ID3DInclude* include = D3D_COMPILE_STANDARD_FILE_INCLUDE;
	UINT flag = D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION;
	ID3DBlob* pErrorBlob = nullptr;

	std::wstring format = L".hlsl";
	std::wstring currentPath = L"Asset/Shader/";

	{
		std::wstring fullFilepath = currentPath + filePath + L"_VS" + format;
		auto hr = D3DCompileFromFile(fullFilepath.c_str(), nullptr, include, "main", "vs_5_0", flag, 0, &m_pVSBlob, &pErrorBlob);

		if (FAILED(hr)) {
			assert(0 && "頂点シェーダーのコンパイルに失敗しました");
			return;
		}
	}

	{
		std::wstring fullFilepath = currentPath + filePath + L"_HS" + format;
		auto hr = D3DCompileFromFile(fullFilepath.c_str(), nullptr, include, "main", "hs_5_0", flag, 0, &m_pHSBlob, &pErrorBlob);

		// ハルシェーダーはなくてもいい
	}

	{
		std::wstring fullFilepath = currentPath + filePath + L"_DS" + format;
		auto hr = D3DCompileFromFile(fullFilepath.c_str(), nullptr, include, "main", "ds_5_0", flag, 0, &m_pDSBlob, &pErrorBlob);

		// ドメインシェーダーはなくてもいい
	}

	// ジオメトリシェーダーのコンパイル
	{
		std::wstring fullFilepath = currentPath + filePath + L"_GS" + format;
		auto hr = D3DCompileFromFile(fullFilepath.c_str(), nullptr, include, "main", "gs_5_0", flag, 0, &m_pGSBlob, &pErrorBlob);

		// ジオメトリシェーダーはなくてもいい
	}

	// ピクセルシェーダーのコンパイル
	{
		std::wstring fullFilepath = currentPath + filePath + L"_PS" + format;
		auto hr = D3DCompileFromFile(fullFilepath.c_str(), nullptr, include, "main", "ps_5_0", flag, 0, &m_pPSBlob, &pErrorBlob);

		if (FAILED(hr)) {
			assert(0 && "ピクセルシェーダーのコンパイルに失敗しました");
			return;
		}
	}
}

// System.h

#include "Utility/Utility.h"

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

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

#include "../Graphics/Mesh/Mesh.h"

#include "../Graphics/Shader/Shader.h"

// GraphicsDevice.h

class GraphicsDevice {
public:
	// ~ //

	void Prepare();

	// ~ //

// GraphicsDevice.cpp

void GraphicsDevice::Prepare() {
	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);
}

// 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);
	*/

	auto bbIdx = m_pSwapChain->GetCurrentBackBufferIndex();

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

// Application.cpp

class GraphicsDevice {
public:
	// ~ //

void Application::Execute() {
	
	// ~ //

	Mesh mesh;
	mesh.Create(&GraphicsDevice::Instance());

	RenderingSetting renderingSetting = {};
	renderingSetting.InputLayouts = { InputLayout::POSITION };
	renderingSetting.Formats = { DXGI_FORMAT_R8G8B8A8_UNORM };
	renderingSetting.IsDepth = false;
	renderingSetting.IsDepthMask = false;

	Shader shader;
	shader.Create(&GraphicsDevice::Instance(), L"SimpleShader", renderingSetting, {});

	while (true) {
		if (!m_window.ProcessMessage()) {
			break;
		}

		GraphicsDevice::Instance().Prepare();

		shader.Begin(width, height);

		shader.DrawMesh(mesh);

		GraphicsDevice::Instance().ScreenFlip();
	}
}