Pipeline.cpp

#include "Defines.h"
#include "Pipeline.h"


bool LoadShadersGbuffer(ID3D11Device* device, ID3D11PixelShader*& pShaderDeferred, ID3D11VertexShader*& vShaderDeferred, std::string& defVShaderByteCode)
{
	std::string shaderData;
	std::ifstream reader;

	reader.open(L"Debug/DeferredVS.cso", std::ios::binary | std::ios::ate);
	if (!reader.is_open())
	{
		std::cerr << "ERROR! COULD NOT OPEN VS FILE DEFERRED!" << std::endl;
		return false;
	}
	reader.seekg(0, std::ios::end);
	shaderData.reserve(static_cast<unsigned int>(reader.tellg()));
	reader.seekg(0, std::ios::beg);

	shaderData.assign((std::istreambuf_iterator<char>(reader)), std::istreambuf_iterator<char>());
	if (FAILED(device->CreateVertexShader(shaderData.c_str(), shaderData.length(), nullptr, &vShaderDeferred)))
	{
		std::cerr << "ERROR! COULT NOT CREATE VERTEX SHADER DEFERRED!" << std::endl;
		return false;
	}
	defVShaderByteCode = shaderData;
	shaderData.clear();
	reader.close();
	reader.open(L"Debug/DeferredPS.cso", std::ios::binary | std::ios::ate);
	if (!reader.is_open())
	{
		std::cerr << "ERROR! COULD NOT OPEN PS FILE DEFERRED!" << std::endl;
		return false;
	}

	reader.seekg(0, std::ios::end);
	shaderData.reserve(static_cast<unsigned int>(reader.tellg()));
	reader.seekg(0, std::ios::beg);

	shaderData.assign((std::istreambuf_iterator<char>(reader)), std::istreambuf_iterator<char>());

	if (FAILED(device->CreatePixelShader(shaderData.c_str(), shaderData.length(), nullptr, &pShaderDeferred)))
	{
		std::cerr << "ERROR! COULD NOT CREATE PIXEL SHADER DEFERRED" << std::endl;
		return false;
	}
	reader.close();
	return true;
}

bool LoadShadersLight(ID3D11Device* device, ID3D11PixelShader*& lightPShaderDeferred, ID3D11VertexShader*& lightVSShaderDeferred, std::string& lightVShaderByteCode)
{

	std::string shaderData;
	std::ifstream reader;
	// Clears the reader and shaderData and does the same thing for the PixelShader

	reader.open(L"Debug/DeferredLightVS.cso", std::ios::binary | std::ios::ate);
	if (!reader.is_open())
	{
		std::cerr << "ERROR! COULD NOT OPEN VERTEX SHADER LIGHT!" << std::endl;
		return false;
	}

	reader.seekg(0, std::ios::end);
	shaderData.reserve(static_cast<unsigned int>(reader.tellg()));
	reader.seekg(0, std::ios::beg);

	shaderData.assign((std::istreambuf_iterator<char>(reader)), std::istreambuf_iterator<char>());

	if (FAILED(device->CreateVertexShader(shaderData.c_str(), shaderData.length(), nullptr, &lightVSShaderDeferred)))
	{
		std::cerr << "ERROR! COULD NOT CREATE VERTEX SHADER LIGHT!" << std::endl;
		return false;
	}

	lightVShaderByteCode = shaderData;

	shaderData.clear();
	reader.close();
	reader.open(L"Debug/DeferredLightPS.cso", std::ios::binary | std::ios::ate);
	if (!reader.is_open())
	{
		std::cerr << "ERROR! COULD NOT OPEN PIXEL SHADER LIGHT!" << std::endl;
		return false;
	}

	reader.seekg(0, std::ios::end);
	shaderData.reserve(static_cast<unsigned int>(reader.tellg()));
	reader.seekg(0, std::ios::beg);

	shaderData.assign((std::istreambuf_iterator<char>(reader)), std::istreambuf_iterator<char>());

	if (FAILED(device->CreatePixelShader(shaderData.c_str(), shaderData.length(), nullptr, &lightPShaderDeferred)))
	{
		std::cerr << "ERROR! COULD NOT CREATE PIXEL SHADER LIGHT!" << std::endl;
		return false;
	}

	return true;

}

bool CreateRenderTargetMesh(ID3D11Device* device, ID3D11Buffer*& renderTargetMesh)
{
	screenQuad rtvMeshData[] =
	{
		// (x, y, z), UV, normals
		// 
		//top right
	   { {1.0f, 1.0f, 0.0f}, {1.0f, 0.0f}, {0, 0, -1} },
	   //bottom right
	   { {1.0f, -1.0f, 0.0f}, {1.0f, 1.0f}, {0, 0, -1}  },
	   // top left
	   { {-1.0f, 1.0f, 0.0f}, {0.0f, 0.0f}, {0, 0, -1}  },
	   //bottom left
	   { {-1.0f, -1.0f, 0.0f}, {0.0f, 1.0f}, {0, 0, -1}  }
	   
	};

	D3D11_BUFFER_DESC desc; //rtvMesh desc
	desc.ByteWidth = sizeof(rtvMeshData);//bytesize of vertices		
	desc.Usage = D3D11_USAGE_IMMUTABLE; //Only read by the GPU, not accessable by the CPU
	desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; // Binds buffer as vertex buffer. 
	desc.CPUAccessFlags = 0; // because immutable, NO need to write or read because no access
	desc.MiscFlags = 0; //nah we don't need more flags
	desc.StructureByteStride = 0;// Defines size of each element in buffer structure. we don't need this magic

	// Specifies data for initializing a subresource
	D3D11_SUBRESOURCE_DATA data;
	data.pSysMem = &rtvMeshData;// Pointer to the init data
	data.SysMemPitch = 0; // distance (in bytes) from the start of one line of a texture to the next line
	data.SysMemSlicePitch = 0; // distance (in bytes) from the start of one depth level to the next

	HRESULT hr = device->CreateBuffer(&desc, &data, &renderTargetMesh);

	return !FAILED(hr);
}

bool RenderMeshInputLayout(ID3D11Device* device, ID3D11InputLayout*& renderTargetMeshInputLayout, const std::string& lightVShaderByteCode)
{
	// Input layout for screen quad
	D3D11_INPUT_ELEMENT_DESC desc[] =
	{
		// Name, Index, Format, Slot, ByteOffset, InputSlotClass, StepRate
		{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
		{"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0},
	};

	HRESULT hr = device->CreateInputLayout(desc, ARRAYSIZE(desc), lightVShaderByteCode.c_str(), lightVShaderByteCode.length(), &renderTargetMeshInputLayout);

	return !FAILED(hr);
}

bool CreateSamplerState(ID3D11Device* device, ID3D11SamplerState*& wrapSampler, ID3D11SamplerState*& clampSampler)
{
	D3D11_SAMPLER_DESC desc;
	desc.Filter = D3D11_FILTER_ANISOTROPIC; // improves image quality by adding texture for each u, v for each intersection with integers
	// if u value is 3, the texture is repeated three times
	desc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
	desc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
	desc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
	desc.MipLODBias = 0; // No offset thank you
	desc.MaxAnisotropy = 16;// amount of samples which can be taken for improved quality
	desc.BorderColor[0] = desc.BorderColor[1] = desc.BorderColor[2] = desc.BorderColor[3] = 0; //nice little color for edge
	desc.MinLOD = 0; // Lower end of mipmap range to clamp access to, where 0 is largest and most detailed mipmap level 
	desc.MaxLOD = D3D11_FLOAT32_MAX; // Upper end of the mipmap range to clamp access to, 
	// where 0 is largest and most detailed mipmap level and any level above that is less detailed

	HRESULT hr = device->CreateSamplerState(&desc, &wrapSampler);
	if (FAILED(hr))
	{
		std::cerr << "ERROR! COULD NOT CREATE SAMPLERSTATE!" << std::endl;
		return false;
	}
	desc.Filter = D3D11_FILTER_ANISOTROPIC;
	desc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
	desc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
	desc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
	desc.MipLODBias = 0;
	desc.MaxAnisotropy = 16;
	desc.BorderColor[0] = desc.BorderColor[1] = desc.BorderColor[2] = desc.BorderColor[3] = 0;
	desc.MinLOD = 0;
	desc.MaxLOD = D3D11_FLOAT32_MAX;

	hr = device->CreateSamplerState(&desc, &clampSampler);
	if (FAILED(hr))
	{
		std::cerr << "ERROR! COULD NOT CREATE SAMPLERSTATE!" << std::endl;
		return false;
	}

	return !FAILED(hr);
}

bool SetUpRasterizer(ID3D11Device*& device, ID3D11RasterizerState*& rasterizerStateWireFrame, ID3D11RasterizerState*& rasterizerStateSolid)
{
	D3D11_RASTERIZER_DESC desc;
	ZeroMemory(&desc, sizeof(desc));
	desc.FillMode = D3D11_FILL_MODE::D3D11_FILL_WIREFRAME;
	desc.CullMode = D3D11_CULL_NONE;
	desc.FrontCounterClockwise = false;
	desc.DepthBias = 0;
	desc.DepthBiasClamp = 0;
	desc.SlopeScaledDepthBias = 0;
	desc.DepthClipEnable = true;
	desc.ScissorEnable = false;
	desc.MultisampleEnable = false;
	desc.AntialiasedLineEnable = false;
	HRESULT hr = device->CreateRasterizerState(&desc, &rasterizerStateWireFrame);
	if (FAILED(hr))
	{
		std::cout << "Failed to create wireframe" << std::endl;
	}

	desc.FillMode = D3D11_FILL_MODE::D3D11_FILL_SOLID;
	hr = device->CreateRasterizerState(&desc, &rasterizerStateSolid);
	if (FAILED(hr))
	{
		std::cout << "Failed to create fill solid" << std::endl;
	}


	return !FAILED(hr);
}

// Calls the various functions
bool SetupPipeline(ID3D11Device* device, ID3D11SamplerState*& sampler,
	ID3D11PixelShader*& pShaderDeferred, ID3D11VertexShader*& vShaderDeferred, ID3D11PixelShader*& lightPShaderDeferred,
	ID3D11VertexShader*& lightVShaderDeferred, ID3D11InputLayout*& renderTargetMesh, ID3D11Buffer*& screenQuadMesh,
	ID3D11RasterizerState*& rasterizerStateWireFrame, ID3D11RasterizerState*& rasterizerStateSolid, ID3D11SamplerState*& clampSampler)
{
	std::string vShaderByteCode;
	std::string defVShaderByteCode;
	std::string lightVShaderByteCode;

	if (!LoadShadersGbuffer(device, pShaderDeferred, vShaderDeferred, defVShaderByteCode))
	{
		std::cerr << "ERROR! COULD NOT LOAD GBUFFER!" << std::endl;
		return false;
	}

	if (!LoadShadersLight(device, lightPShaderDeferred, lightVShaderDeferred, lightVShaderByteCode))
	{
		std::cerr << "ERROR! COULD NOT LOAD LIGHT!" << std::endl;
		return false;
	}

	if (!CreateRenderTargetMesh(device, screenQuadMesh))
	{
		OutputDebugString(L"ERROR! COULD NOT CREATE RT MESH!");
		return false;
	}

	if (!RenderMeshInputLayout(device, renderTargetMesh, lightVShaderByteCode))
	{
		std::cerr << "ERROR! COULD NOT RENDER MESH!" << std::endl;
		return false;
	}

	if (!CreateSamplerState(device, sampler, clampSampler))
	{
		std::cerr << "ERROR! COULD NOT CREATE SAMPLER STATE! " << std::endl;
		return false;
	}

	if (!SetUpRasterizer(device, rasterizerStateWireFrame, rasterizerStateSolid))
	{
		std::cerr << "ERROR! COULD NOT SETUP RASTERIZER STATE! " << std::endl;
		return false;
	}
}