ConstantBuffers implemented

Author: PR3C14D0

src/Shader/GBufferPass.hlsl

@@ -1,3 +1,10 @@
+cbuffer WVP : register(b0)
+{
+    matrix World;
+    matrix View;
+    matrix Projection;
+};
+
 struct VertexOutput
 {
     float4 position : SV_Position;
@@ -12,8 +19,10 @@ VertexOutput VertexMain(float4 position : POSITION0, float4 normal : NORMAL0, fl
 {
     VertexOutput output;
 
-    output.position = position;
-    output.normal = normal;
+    output.position = mul(position, World);
+    output.position = mul(output.position, View);
+    output.position = mul(output.position, Projection);
+    output.normal = mul(normal, World);
     output.uv = uv;
 
     return output;

src/private/Core/GameObject/Component/Mesh.cpp

@@ -14,6 +14,7 @@ Mesh::Mesh(std::string name, Transform& parentTransform) : Component::Component(
 	this->m_bMeshLoaded = false;
 	this->m_nTotalVertices = 0;
 	this->m_nSamplerIndex = -1; // I put -1 cuz 0 can actually be occupied.
+	this->m_nWvpIndex = -1;
 	this->m_nTotalVertices = 0;
 	this->m_shader = nullptr;
 
@@ -27,8 +28,8 @@ Mesh::Mesh(std::string name, Transform& parentTransform) : Component::Component(
 	this->m_wvp.World *= XMMatrixTranspose(XMMatrixRotationY(XMConvertToRadians(this->m_transform.rotation.y)));
 	this->m_wvp.World *= XMMatrixTranspose(XMMatrixRotationZ(XMConvertToRadians(this->m_transform.rotation.z)));
 
-	this->m_wvp.View = XMMatrixTranspose(XMMatrixIdentity());
-	this->m_wvp.Projection = XMMatrixTranspose(XMMatrixPerspectiveLH(XMConvertToRadians(90.f), static_cast<float>(nWidth) / static_cast<float>(nHeight), 0.01f, 3000.f));
+	this->m_wvp.View = XMMatrixTranspose(XMMatrixIdentity() * XMMatrixTranslation(0.f, 0.f, 2.f));
+	this->m_wvp.Projection = XMMatrixTranspose(XMMatrixPerspectiveFovLH(XMConvertToRadians(90.f), static_cast<float>(nWidth) / static_cast<float>(nHeight), 0.01f, 3000.f));
 }
 
 void Mesh::Init() {
@@ -80,17 +81,58 @@ void Mesh::UploadVertices() {
 	}
 }
 
+void Mesh::InitConstantBuffer() {
+	D3D12* d3d12 = dynamic_cast<D3D12*>(this->m_renderer);
+
+	UINT nWVPSize = (sizeof(this->m_wvp) + 255) & ~255;
+
+	d3d12->CreateBuffer(&this->m_wvp, nWVPSize, this->m_wvpRes);
+	this->m_wvpRes->SetName(L"Mesh WVP Constant buffer");
+
+	D3D12_CONSTANT_BUFFER_VIEW_DESC cbvDesc = { };
+	cbvDesc.BufferLocation = this->m_wvpRes->GetGPUVirtualAddress();
+	cbvDesc.SizeInBytes = nWVPSize;
+
+	this->m_cbv_srvHeap->Allocate(1);
+	this->m_nWvpIndex = this->m_cbv_srvHeap->GetLastDescriptorIndex();
+	Descriptor wvpDesc = this->m_cbv_srvHeap->GetDescriptor(this->m_nWvpIndex);
+
+	this->m_dev->CreateConstantBufferView(&cbvDesc, wvpDesc.cpuHandle);
+}
+
+void Mesh::UpdateConstantBuffer() {
+	UINT nWVPSize = (sizeof(this->m_wvp) + 255) & ~255;
+	this->m_wvp.World = XMMatrixTranspose(XMMatrixIdentity() * XMMatrixTranslation(this->m_transform.location.x, this->m_transform.location.y, this->m_transform.location.z));
+	this->m_wvp.World *= XMMatrixTranspose(XMMatrixRotationX(XMConvertToRadians(this->m_transform.rotation.x)));
+	this->m_wvp.World *= XMMatrixTranspose(XMMatrixRotationY(XMConvertToRadians(this->m_transform.rotation.y)));
+	this->m_wvp.World *= XMMatrixTranspose(XMMatrixRotationZ(XMConvertToRadians(this->m_transform.rotation.z)));
+
+	this->m_wvp.View = XMMatrixTranspose(XMMatrixIdentity() * XMMatrixTranslation(0.f, 0.f, 2.f));
+	//this->m_wvp.Projection = XMMatrixTranspose(XMMatrixPerspectiveLH(XMConvertToRadians(90.f), static_cast<float>(nWidth) / static_cast<float>(nHeight), 0.01f, 3000.f));
+
+	PVOID pData;
+	ThrowIfFailed(this->m_wvpRes->Map(0, nullptr, &pData));
+	memcpy(pData, &this->m_wvp, nWVPSize);
+	this->m_wvpRes->Unmap(0, nullptr);
+
+	return;
+}
+
 void Mesh::Update() {
 	Component::Update();
 
 }
 
 void Mesh::Render() {
+	this->UpdateConstantBuffer();
 	this->m_list->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
 	this->m_list->SetPipelineState(this->m_plState.Get());
 	this->m_list->SetGraphicsRootSignature(this->m_rootSig.Get());
 
+	Descriptor wvpDesc = this->m_cbv_srvHeap->GetDescriptor(this->m_nWvpIndex);
+
 	this->m_list->SetGraphicsRootDescriptorTable(0, this->m_samplerDescriptor.gpuHandle);
+	this->m_list->SetGraphicsRootDescriptorTable(2, wvpDesc.gpuHandle);
 
 	int i = 0;
 	for (D3D12_VERTEX_BUFFER_VIEW vbv : this->m_VBVs) {
@@ -114,17 +156,22 @@ void Mesh::InitPipeline() {
 
 	CD3DX12_DESCRIPTOR_RANGE albedoRange;
 	CD3DX12_DESCRIPTOR_RANGE samplerRange;
+	CD3DX12_DESCRIPTOR_RANGE wvpRange;
 	albedoRange.Init(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 1, 0);
 	samplerRange.Init(D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER, 1, 0);
+	wvpRange.Init(D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 1, 0);
 
 	CD3DX12_ROOT_PARAMETER albedoParam;
 	CD3DX12_ROOT_PARAMETER samplerParam;
+	CD3DX12_ROOT_PARAMETER wvpParam;
 	albedoParam.InitAsDescriptorTable(1, &albedoRange, D3D12_SHADER_VISIBILITY_PIXEL);
 	samplerParam.InitAsDescriptorTable(1, &samplerRange, D3D12_SHADER_VISIBILITY_PIXEL);
-	
+	wvpParam.InitAsDescriptorTable(1, &wvpRange, D3D12_SHADER_VISIBILITY_VERTEX);
+
 	D3D12_ROOT_PARAMETER rootParams[] = {
 		samplerParam,
-		albedoParam
+		albedoParam,
+		wvpParam
 	};
 
 	D3D12_ROOT_SIGNATURE_DESC rootDesc = { };
@@ -169,7 +216,7 @@ void Mesh::InitPipeline() {
 	plDesc.DSVFormat = DXGI_FORMAT_D24_UNORM_S8_UINT;
 	plDesc.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT);
 	plDesc.RasterizerState.CullMode = D3D12_CULL_MODE_BACK;
-	plDesc.RasterizerState.FrontCounterClockwise = TRUE;
+	plDesc.RasterizerState.FrontCounterClockwise = FALSE;
 	plDesc.RTVFormats[0] = DXGI_FORMAT_B8G8R8A8_UNORM;
 	plDesc.RTVFormats[1] = DXGI_FORMAT_B8G8R8A8_UNORM;
 	plDesc.RTVFormats[2] = DXGI_FORMAT_B8G8R8A8_UNORM;
@@ -194,6 +241,7 @@ void Mesh::D3D12Init(D3D12* renderer) {
 	this->UploadVertices();
 	this->InitPipeline();
 	this->InitSampler(renderer);
+	this->InitConstantBuffer();
 }
 
 void Mesh::InitSampler(D3D12* renderer) {

src/private/Core/GameObject/GameObject.cpp

@@ -6,6 +6,7 @@ GameObject::GameObject(std::string name) {
 }
 
 void GameObject::Init() {
+	//this->transform.Translate(0.f, 0.f, 0.f);
 	this->m_mesh = new Mesh("StaticMeshComponent", this->transform);
 	this->m_components.push_back(this->m_mesh);
 	this->m_mesh->LoadModel("f16.fbx");

src/private/Core/Renderer/ScreenQuad.cpp

@@ -125,39 +125,29 @@ void ScreenQuad::D3D12Init(D3D12* renderer) {
 		{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 24, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, NULL}
 	};
 
+	D3D12_INPUT_LAYOUT_DESC layout = { };
+	layout.pInputElementDescs = elements;
+	layout.NumElements = _countof(elements);
+
 	D3D12_GRAPHICS_PIPELINE_STATE_DESC plDesc = { };
+	plDesc.Flags = D3D12_PIPELINE_STATE_FLAG_NONE;
+	plDesc.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC(D3D12_DEFAULT);
+	plDesc.DepthStencilState.DepthEnable = TRUE;
+	plDesc.DepthStencilState.StencilEnable = FALSE;
+	plDesc.InputLayout = layout;
 	plDesc.VS.pShaderBytecode = vShader;
 	plDesc.VS.BytecodeLength = nVertexLength;
 	plDesc.PS.pShaderBytecode = pShader;
 	plDesc.PS.BytecodeLength = nPixelLength;
 	plDesc.pRootSignature = this->m_rootSig.Get();
-	plDesc.DepthStencilState.DepthEnable = FALSE;
-	plDesc.DepthStencilState.StencilEnable = FALSE;
-	plDesc.InputLayout.NumElements = _countof(elements);
-	plDesc.InputLayout.pInputElementDescs = elements;
-	plDesc.Flags = D3D12_PIPELINE_STATE_FLAG_NONE;
+	plDesc.BlendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT);
+	plDesc.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT);
+	plDesc.RasterizerState.CullMode = D3D12_CULL_MODE_BACK;
+	plDesc.RTVFormats[0] = DXGI_FORMAT_B8G8R8A8_UNORM;
+	plDesc.NumRenderTargets = 1;
 	plDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
-	plDesc.NodeMask = 0;
 	plDesc.SampleDesc.Count = 8;
 	plDesc.SampleMask = UINT32_MAX;
-	plDesc.NumRenderTargets = 1;
-	plDesc.RTVFormats[0] = DXGI_FORMAT_B8G8R8A8_UNORM;
-	plDesc.RasterizerState.FillMode = D3D12_FILL_MODE_SOLID;
-	plDesc.RasterizerState.CullMode = D3D12_CULL_MODE_BACK;
-	plDesc.RasterizerState.ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF;
-	plDesc.RasterizerState.FrontCounterClockwise = FALSE;
-	plDesc.RasterizerState.DepthClipEnable = TRUE;
-	
-	const D3D12_RENDER_TARGET_BLEND_DESC rtbDesc = {
-		FALSE, FALSE,
-		D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD,
-		D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD,
-		D3D12_LOGIC_OP_NOOP,
-		D3D12_COLOR_WRITE_ENABLE_ALL,
-	};
-
-	for (UINT i = 0; i < D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
-		plDesc.BlendState.RenderTarget[i] = rtbDesc;
 
 	ThrowIfFailed(this->m_dev->CreateGraphicsPipelineState(&plDesc, IID_PPV_ARGS(this->m_plState.GetAddressOf())));
 }

src/public/Core/GameObject/Component/Mesh.h

@@ -60,12 +60,16 @@ class Mesh : public Component {
 
 	UINT m_nTotalVertices;
 
+	ComPtr<ID3D12Resource> m_wvpRes;
+	WVP m_wvp;
+	UINT m_nWvpIndex;
+	void InitConstantBuffer();
+	void UpdateConstantBuffer();
+
 	void UploadVertices();
 	void InitPipeline();
 	void InitSampler(D3D12* renderer);
 
-	WVP m_wvp;
-
 	Transform m_transform;
 public:
 	Mesh(std::string name, Transform& parentTransform);