#include "stdafx.h"
#include "GlobalClassForStuff.h"


GlobalStuff::GlobalStuff(void)
{
}

GlobalStuff::~GlobalStuff(void)
{
}

bool GlobalStuff::initAll(void)
{
	CreateDXGIFactory1(__uuidof(IDXGIFactory1),reinterpret_cast<void**>(&mFactory));
	mFactory->EnumAdapters1(0,&mAdapter);

	IDXGIOutputPtr pOutput;
	mAdapter->EnumOutputs(0,&pOutput);

	UINT numModes;
	std::vector<DXGI_MODE_DESC> tempModes;
	pOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM,0,&numModes,0);
	tempModes.resize(numModes);
	pOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM,0,&numModes,tempModes.data());

	CString poop;
	for(auto i = tempModes.begin();i < tempModes.end();i++)
	{
		poop.Format(L"%ux%u@%u/%u",(*i).Width,(*i).Height,(*i).RefreshRate.Numerator,(*i).RefreshRate.Denominator);
		mModes.insert(std::make_pair(poop,(*i)));
	}

	D3D11CreateDevice(mAdapter,D3D_DRIVER_TYPE_UNKNOWN,0,0,0,0,D3D11_SDK_VERSION,&md3dDevice,0,&md3dDeviceContext);

	D3DX11CreateThreadPump(0,0,&mThreadPump);

	if(!initEffects())
	{
		return false;
	}

	initInputLayouts();

	return true;
}

bool GlobalStuff::initEffects(void)
{
	char tempString[MAX_PATH];
	std::vector<CString> shaderNames;
	std::vector<CComPtr<ID3DX11ThreadPump> > threadPumps;
	std::vector<ID3DBlobPtr> tempBlobs;
	std::vector<CComPtr<ID3DX11Effect> > tempEffects;
	std::ifstream input("./Shaders/ShaderList.txt",std::ios::in);

	input.getline(tempString,MAX_PATH);
	int shaderCount = atoi(tempString);

	shaderNames.resize(shaderCount);
	threadPumps.resize(shaderCount,CComPtr<ID3DX11ThreadPump>(nullptr));
	tempEffects.resize(shaderCount,CComPtr<ID3DX11Effect>(nullptr));
	tempBlobs.resize(shaderCount,ID3DBlobPtr(nullptr));

	std::vector<ID3DBlobPtr> errors(shaderCount,ID3DBlobPtr(nullptr));
	std::vector<HRESULT> asyncResult(shaderCount,S_OK);

	for(int i=0;i<shaderCount;i++)
	{
		input.getline(tempString,MAX_PATH);

		shaderNames[i] = CString(tempString);

		D3DX11CreateThreadPump(0,0,&(threadPumps[i]));
	}

	input.close();

	D3D_SHADER_MACRO macros[2] = {"CONTROL_POINT_SIZE","0",nullptr,nullptr};
	Concurrency::parallel_for(int(0),shaderCount,[&](int i){
		D3DX11CompileFromFile(shaderNames[i],macros,&mIncludeTool,nullptr,"fx_5_0",D3DCOMPILE_OPTIMIZATION_LEVEL3,0,threadPumps[i],
							  &(tempBlobs[i]),&(errors[i]),&(asyncResult[i]));
		threadPumps[i]->WaitForAllItems();
	});

	auto iterator = std::find(asyncResult.begin(),asyncResult.end(),E_FAIL);
	if(iterator != asyncResult.end())
	{
		CString poop;
		for(auto i=errors.begin();i!=errors.end();i++)
		{
			if(*i)
			{
				poop.Preallocate(static_cast<int>((*i)->GetBufferSize()));
				poop += static_cast<const char*>((*i)->GetBufferPointer());
				poop += "\n\n";
			}
		}
		AfxGetMainWnd()->GetTopLevelParent()->MessageBox(poop);

		return false;
	}

	Concurrency::parallel_for(int(0),shaderCount,[&](int i){
		D3DX11CreateEffectFromMemory(tempBlobs[i]->GetBufferPointer(),tempBlobs[i]->GetBufferSize(),0,md3dDevice,&(tempEffects[i]));
	});

	for(int i=0;i<shaderCount;i++)
	{
		mEffects.insert(std::make_pair(shaderNames[i],tempEffects[i]));
	}

	return true;
}

void GlobalStuff::initInputLayouts(void)
{
	D3DX11_PASS_DESC passDesc;

	std::vector<std::vector<D3D11_INPUT_ELEMENT_DESC> > vertexDesc;
	vertexDesc.resize(2);
	vertexDesc[0].resize(1);
	vertexDesc[1].resize(2);

	vertexDesc[0][0].SemanticName = "POSITION";
	vertexDesc[0][0].SemanticIndex = 0;
	vertexDesc[0][0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
	vertexDesc[0][0].AlignedByteOffset = 0;
	vertexDesc[0][0].InputSlot = 0;
	vertexDesc[0][0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
	vertexDesc[0][0].InstanceDataStepRate = 0;

	vertexDesc[1][0].SemanticName = "POSITION";
	vertexDesc[1][0].SemanticIndex = 0;
	vertexDesc[1][0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
	vertexDesc[1][0].AlignedByteOffset = 0;
	vertexDesc[1][0].InputSlot = 0;
	vertexDesc[1][0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
	vertexDesc[1][0].InstanceDataStepRate = 0;

	vertexDesc[1][1].SemanticName = "TEXCOORD";
	vertexDesc[1][1].SemanticIndex = 0;
	vertexDesc[1][1].Format = DXGI_FORMAT_R32G32_FLOAT;
	vertexDesc[1][1].AlignedByteOffset = 12;
	vertexDesc[1][1].InputSlot = 0;
	vertexDesc[1][1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
	vertexDesc[1][1].InstanceDataStepRate = 0;

	auto iterator = mEffects.find(L"./Shaders/UntexturedFillrate/UntexturedFillrate.fx");
	(*iterator).second->GetTechniqueByName("UntexturedFillrateSM50")->GetPassByIndex(0)->GetDesc(&passDesc);

	auto iterator1 = mInputLayouts.insert(std::make_pair(CString(L"Pos"),ID3D11InputLayoutPtr(nullptr)));
	md3dDevice->CreateInputLayout(vertexDesc[0].data(),1,passDesc.pIAInputSignature,passDesc.IAInputSignatureSize,&(iterator1.first->second));

	iterator = mEffects.find(L"./Shaders/TexturedFillrate/TexturedFillrate.fx");
	(*iterator).second->GetTechniqueByName("TexturedFillrateSM50")->GetPassByIndex(0)->GetDesc(&passDesc);

	iterator1 = mInputLayouts.insert(std::make_pair(CString(L"PosTex"),ID3D11InputLayoutPtr(nullptr)));
	md3dDevice->CreateInputLayout(vertexDesc[1].data(),2,passDesc.pIAInputSignature,passDesc.IAInputSignatureSize,&(iterator1.first->second));
}

const CComPtr<ID3DX11Effect>& GlobalStuff::getEffect(const CString& shader) const

{
	auto iterator = mEffects.find(shader);

	if(iterator != mEffects.end())
	{
		return (*iterator).second;
	}

	return nullptr;
}

const DXGI_MODE_DESC& GlobalStuff::getMode(const CString& mode) const

{
	auto iterator = mModes.find(mode);

	if(iterator != mModes.end())
	{
		return (*iterator).second;
	}

	DXGI_MODE_DESC failDesc;
	ZeroMemory(&failDesc,sizeof(DXGI_MODE_DESC));
	return failDesc;
}

const ID3D11InputLayoutPtr& GlobalStuff::getInputLayout(const CString& layout) const

{
	auto iterator = mInputLayouts.find(layout);

	if(iterator != mInputLayouts.end())
	{
		return (*iterator).second;
	}

	return nullptr;
}

bool GlobalStuff::recompileShader(const CString& shader,const D3D_SHADER_MACRO* macros = nullptr)
{
	auto iterator = mEffects.find(shader);

	if(iterator != mEffects.end())
	{
		ID3DBlobPtr shaderError, tempBlob;
		HRESULT asyncResult;

		D3DX11CompileFromFile(shader,macros,&mIncludeTool,nullptr,"fx_5_0",D3DCOMPILE_OPTIMIZATION_LEVEL3,0,mThreadPump,&tempBlob,&shaderError,&asyncResult);
		mThreadPump->WaitForAllItems();

		if(asyncResult == E_FAIL)
		{
			CString poop;
			if(shaderError)
			{
				poop.Preallocate(static_cast<int>(shaderError->GetBufferSize()) + 1);
				poop += static_cast<const char*>(shaderError->GetBufferPointer());
				poop += '\n';
			}
			AfxGetMainWnd()->GetTopLevelParent()->MessageBox(poop);

			return false;
		}

		D3DX11CreateEffectFromMemory(tempBlob->GetBufferPointer(),tempBlob->GetBufferSize(),0,md3dDevice,&(*iterator).second);
//		D3DX11CreateEffectFromMemory(tempBlob->GetBufferPointer(),tempBlob->GetBufferSize(),0,md3dDevice,&tempFX);
		return true;
	}

	return false;
}