#define VC_EXTRALEAN
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
#include <cstdlib>

#define D3D11_NO_HELPERS
#include <d3d11.h>
#include <dxgi.h>
#include <d3dcompiler.h>

#define ATOM_EDIT 0xC018
#define ATOM_STATIC 0xC019

#define WIDTH (1280)
#define HEIGHT (720)

#define _USE_PERFORMANCE_QUERIES
//#define CAMERA_FILENAME "convex.cam"
//#define CAMERA_FILENAME "city.cam"
#define CAMERA_FILENAME "jewels.cam"
#define _FULLSCREEN

#ifndef USE_PERFORMANCE_QUERIES
#define USE_POSTPROCESSING
#endif

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

#include "DXShaderManager.h"
#include "camera.h"

#define REGISTER_SHADER(F,E,P) g_shaderManager.AddComputeShader(device, F, E, P, &blob, NULL, D3DCOMPILE_OPTIMIZATION_LEVEL3)
#define REGISTER_SHADER_WITH_DEFINES(F,E,P,D) g_shaderManager.AddComputeShader(device, F, E, P, &blob, D, D3DCOMPILE_OPTIMIZATION_LEVEL3)
//#define REGISTER_SHADER_WITH_DEFINES g_shaderMangaer.A
#define CHECK_AND_RELOAD_SHADERS() \
	if (S_OK != g_shaderManager.CheckAndReload(device)) { \
		Sleep(500); \
		continue; \
	}

HWND hWnd;

typedef struct {
	// DXGI_MODE_DESC BufferDesc;
	UINT Width;
	UINT Height;
	//DXGI_RATIONAL RefreshRate;
	UINT Numerator;
	UINT Denominator;
	DXGI_FORMAT Format;
	DXGI_MODE_SCANLINE_ORDER ScanlineOrdering;
	DXGI_MODE_SCALING Scaling;

	// DXGI_SAMPLE_DESC SampleDesc;
	UINT Count;
	UINT Quality;

	DXGI_USAGE BufferUsage;
	UINT BufferCount;
	HWND OutputWindow;
	BOOL Windowed;
	DXGI_SWAP_EFFECT SwapEffect;
	UINT Flags;
} HG_DXGI_SWAP_CHAIN_DESC;

#ifdef FULLSCREEN
HG_DXGI_SWAP_CHAIN_DESC swapChainDesc = {
	WIDTH, HEIGHT, 0, 1, DXGI_FORMAT_R8G8B8A8_UNORM, //DXGI_FORMAT_R16G16B16A16_FLOAT,
	DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED, DXGI_MODE_SCALING_UNSPECIFIED,
	1, 0, DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_UNORDERED_ACCESS | DXGI_USAGE_SHADER_INPUT, 1, 0, 0, DXGI_SWAP_EFFECT_DISCARD, 0
};
#else
HG_DXGI_SWAP_CHAIN_DESC swapChainDesc = {
	WIDTH, HEIGHT, 0, 1, DXGI_FORMAT_R8G8B8A8_UNORM, //DXGI_FORMAT_R8G8B8A8_UNORM,// DXGI_FORMAT_R16G16B16A16_FLOAT
	DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED, DXGI_MODE_SCALING_UNSPECIFIED,
	1, 0, DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_UNORDERED_ACCESS | DXGI_USAGE_SHADER_INPUT, 1, 0, -1, DXGI_SWAP_EFFECT_DISCARD, 0
};
#endif

static bool keys[256];
static bool leftMouseButtonDown = false;
static bool leftMouseButtonDownInit = false;
static POINT mouseCursorPosition;
static float translationSpeed = 1.0f;

ID3D11Device* device;
ID3D11DeviceContext* context;
IDXGISwapChain* swapChain;
ID3D11Texture2D* backBufferTexture;
ID3D11UnorderedAccessView* backBufferUAV;

#ifdef USE_PERFORMANCE_QUERIES
ID3D11Query* disjointQuery;
ID3D11Query* beginFrameQuery;
ID3D11Query* endFrameQuery;
ID3D11Query* traceQuery;
ID3D11Query* postprocessingQuery;


void setupQueries() {
	D3D11_QUERY_DESC queryDescDisjoint = { D3D11_QUERY_TIMESTAMP_DISJOINT, 0 };
	D3D11_QUERY_DESC queryDesc = { D3D11_QUERY_TIMESTAMP, 0 };

	device->CreateQuery(&queryDescDisjoint, &disjointQuery);
	device->CreateQuery(&queryDesc, &beginFrameQuery);
	device->CreateQuery(&queryDesc, &endFrameQuery);
	device->CreateQuery(&queryDesc, &traceQuery);
	device->CreateQuery(&queryDesc, &postprocessingQuery);
}

void getPerformanceData() {
	while (context->GetData(disjointQuery, NULL, 0, 0)) {
		Sleep(1);
	}

	D3D11_QUERY_DATA_TIMESTAMP_DISJOINT timestampDisjoint;
	context->GetData(disjointQuery, &timestampDisjoint, sizeof(D3D11_QUERY_DATA_TIMESTAMP_DISJOINT), 0);
	if (timestampDisjoint.Disjoint)
		return;

	UINT64 timestampBeginFrame, timestampEndFrame;
	context->GetData(beginFrameQuery, &timestampBeginFrame, sizeof(UINT64), 0);
	context->GetData(endFrameQuery, &timestampEndFrame, sizeof(UINT64), 0);

	double msFrame = (double(timestampEndFrame - timestampBeginFrame) / double(timestampDisjoint.Frequency)) * 1000.0f;
	static int i = 0;
	if (i++ % 256 == 0) {
		std::cout << msFrame << " ms - "<< (1000.0f / msFrame) << " Hz" <<  std::endl;
	}

}

#endif

struct TEXTURE_2D_SRV_UAV_RTV {
	ID3D11Texture2D* TEX;
	ID3D11ShaderResourceView* SRV;
	ID3D11UnorderedAccessView* UAV;
	ID3D11RenderTargetView* RTV;
};

struct CONSTANT_BUFFER_STRUCT {
	float time;
	float d0, d1, d2;
	DirectX::XMFLOAT3 viewPosition;
	float d3;
	DirectX::XMFLOAT3 viewDirection;
	float d4;
	DirectX::XMFLOAT3 viewUp;
	float d5;
};

void createSRVUAVRTV(TEXTURE_2D_SRV_UAV_RTV* tex, int width, int height) {
	D3D11_TEXTURE2D_DESC texDesc = {
		width, height, 0, 1, DXGI_FORMAT_R16G16B16A16_FLOAT,
		{1, 0}, D3D11_USAGE_DEFAULT,
		D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS,
		0, D3D11_RESOURCE_MISC_GENERATE_MIPS
	};
	device->CreateTexture2D(&texDesc, NULL, &tex->TEX);
	device->CreateShaderResourceView(tex->TEX, NULL, &tex->SRV);
	device->CreateUnorderedAccessView(tex->TEX, NULL, &tex->UAV);
	device->CreateRenderTargetView(tex->TEX, NULL, &tex->RTV);
}

static LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
	switch (message) {
		case WM_KEYDOWN:
			if (wParam == VK_ESCAPE) {
				//ExitProcess(0);
				PostQuitMessage(0);
			} else {
				if (wParam < 256) keys[wParam] = true;
			}
		break;

		case WM_KEYUP:
			if (wParam < 256) keys[wParam] = false;
		break;

		case WM_LBUTTONDOWN:
			if (!leftMouseButtonDownInit) leftMouseButtonDownInit = true;
			leftMouseButtonDown = true;
		break;

		case WM_LBUTTONUP:
			leftMouseButtonDownInit = false;
			leftMouseButtonDown = false;
		break;
		
		case WM_MOUSEMOVE:
			mouseCursorPosition.x = LOWORD(lParam);
			mouseCursorPosition.y = HIWORD(lParam);
		break;

		case WM_MOUSEWHEEL:
			translationSpeed *= pow(2.f, short(HIWORD(wParam)) / WHEEL_DELTA);
		break;

		case WM_DESTROY:
			PostQuitMessage(0);
		break;

		default:
			return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return 0;
}

void setNullUAVSRV() {
		ID3D11UnorderedAccessView* nullUAV[] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
		ID3D11ShaderResourceView* nullSRV[] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
		context->CSSetUnorderedAccessViews(0, 8, nullUAV, NULL);
		context->CSSetShaderResources(0, 8, nullSRV);
}

int main(int argc, char** argv) {
	HINSTANCE hInstance = GetModuleHandle(0);
	LPSTR wndName = "Window";
	WNDCLASSEXA wc;
	wc.cbSize = sizeof(WNDCLASSEXA);
	wc.style = CS_HREDRAW | CS_VREDRAW;
	wc.lpfnWndProc = WndProc;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	wc.hInstance = hInstance;
	wc.hIcon = 0;
	wc.hCursor = LoadCursorA(NULL, IDC_ARROW);
	wc.hbrBackground = 0;
	wc.lpszMenuName = 0;
	wc.lpszClassName = wndName;
	wc.hIconSm = 0;

	if (!RegisterClassExA(&wc))
		return EXIT_FAILURE;

#ifdef FULLSCREEN
	HWND hWnd = CreateWindowA(wndName, wndName, WS_POPUP | WS_VISIBLE | WS_MAXIMIZE,
		CW_USEDEFAULT, CW_USEDEFAULT,
		WIDTH,
		HEIGHT,
		NULL, NULL, hInstance, NULL);
	//ShowCursor(FALSE);
#else
	RECT wndRect = {0, 0, WIDTH, HEIGHT};
	AdjustWindowRect(&wndRect, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MAXIMIZEBOX, FALSE);

	HWND hWnd = CreateWindowExA(0*WS_EX_TOPMOST, wndName, wndName, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
		CW_USEDEFAULT, CW_USEDEFAULT,
		wndRect.right - wndRect.left,
		wndRect.bottom - wndRect.top,
		NULL, NULL, hInstance, NULL);

	ShowWindow(hWnd, 1);
	UpdateWindow(hWnd);
#endif

	swapChainDesc.OutputWindow = hWnd;
	D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, D3D11_CREATE_DEVICE_DEBUG, NULL, 0, D3D11_SDK_VERSION, (DXGI_SWAP_CHAIN_DESC*)&swapChainDesc, &swapChain, &device, NULL, &context);
	swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferTexture);
	device->CreateUnorderedAccessView(backBufferTexture, NULL, &backBufferUAV);

	if (1) {
		ID3D11Debug* debug;
		device->QueryInterface(__uuidof(ID3D11Debug), (void**)&debug);
		ID3D11InfoQueue* infoQueue;
		device->QueryInterface(__uuidof(ID3D11InfoQueue), (void**)&infoQueue);
		infoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_CORRUPTION, true);
		infoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_ERROR, true);
		infoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_WARNING, true);
		infoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_INFO, true);
		infoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_MESSAGE, true);
		
		infoQueue->Release();
		debug->Release();
	}

#define NUM_INDIRECT_DISPATCHES 14
	int initialData[4 * NUM_INDIRECT_DISPATCHES] = {
		1, 1, 1, 0,
		0, 0, 0, 0,
		0, 0, 0, 0,
		0, 0, 0, 0,
		0, 0, 0, 0,

		0, 0, 0, 0,
		0, 0, 0, 0,
		0, 0, 0, 0,
		0, 0, 0, 0,
		0, 0, 0, 0,
	
		0, 0, 0, 0,
		0, 0, 0, 0,
		0, 0, 0, 0,
		0, 0, 0, 0 };

	D3D11_BUFFER_DESC indirectDispatchBufferDesc = { sizeof(initialData), D3D11_USAGE_DEFAULT, D3D11_BIND_UNORDERED_ACCESS, 0, D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS, 16 };
	D3D11_UNORDERED_ACCESS_VIEW_DESC indirectDispatchBufferUAVDesc = { DXGI_FORMAT_R32G32B32A32_UINT, D3D11_UAV_DIMENSION_BUFFER, 0, sizeof(initialData)/16, 0 };
	D3D11_SUBRESOURCE_DATA indirectDispatchBufferSubresourceData= { initialData, 0, 0 };
	ID3D11Buffer* indirectDispatchBuffer;
	ID3D11UnorderedAccessView* indirectDispatchBufferUAV;
	device->CreateBuffer(&indirectDispatchBufferDesc, &indirectDispatchBufferSubresourceData, &indirectDispatchBuffer);
	device->CreateUnorderedAccessView(indirectDispatchBuffer, &indirectDispatchBufferUAVDesc, &indirectDispatchBufferUAV);

	ID3DBlob *blob;
	//ShaderWrapper<ID3D11ComputeShader> csRT = REGISTER_SHADER("test.hlsl", "csTestSOR", "cs_5_0");
	//ShaderWrapper<ID3D11ComputeShader> csRT = REGISTER_SHADER("rt.hlsl", "csTrace", "cs_5_0");
	ShaderWrapper<ID3D11ComputeShader> csRT = REGISTER_SHADER("rt.hlsl", "csRT", "cs_5_0");
	D3D_SHADER_MACRO mcpID[] = { { "DEBUG_SHADER_ID", "0" }, { 0 } };
	D3D_SHADER_MACRO blurVID[] = { { "DEBUG_SHADER_ID", "1" }, { 0 } };
	D3D_SHADER_MACRO blurHID[] = { { "DEBUG_SHADER_ID", "2" }, { 0 } };
	D3D_SHADER_MACRO streaksID[] = { { "DEBUG_SHADER_ID", "3" }, { 0 } };
	D3D_SHADER_MACRO mergeID[] = { { "DEBUG_SHADER_ID", "4" }, { 0 } };
	ShaderWrapper<ID3D11ComputeShader> csMCP = REGISTER_SHADER_WITH_DEFINES("..\\gpu\\b288.hlsl", "_0", "cs_5_0", mcpID);
	ShaderWrapper<ID3D11ComputeShader> csBlurV = REGISTER_SHADER_WITH_DEFINES("..\\gpu\\b288.hlsl", "_0", "cs_5_0", blurVID);
	ShaderWrapper<ID3D11ComputeShader> csBlurH = REGISTER_SHADER_WITH_DEFINES("..\\gpu\\b288.hlsl", "_0", "cs_5_0", blurHID);
	ShaderWrapper<ID3D11ComputeShader> csStreaks = REGISTER_SHADER_WITH_DEFINES("..\\gpu\\b288.hlsl", "_0", "cs_5_0", streaksID);
	ShaderWrapper<ID3D11ComputeShader> csMerge = REGISTER_SHADER_WITH_DEFINES("..\\gpu\\b288.hlsl", "_0", "cs_5_0", mergeID);

	D3D_SHADER_MACRO scene0ID[] = { { "DEBUG_SHADER_ID", "5" }, { 0 } };
	D3D_SHADER_MACRO scene1ID[] = { { "DEBUG_SHADER_ID", "6" }, { 0 } };
	D3D_SHADER_MACRO scene2ID[] = { { "DEBUG_SHADER_ID", "7" }, { 0 } };
	D3D_SHADER_MACRO scene3ID[] = { { "DEBUG_SHADER_ID", "8" }, { 0 } };
	D3D_SHADER_MACRO scene4ID[] = { { "DEBUG_SHADER_ID", "9" }, { 0 } };
	ShaderWrapper<ID3D11ComputeShader> csScene0 = REGISTER_SHADER_WITH_DEFINES("..\\gpu\\b288.hlsl", "_0", "cs_5_0", scene0ID);
	ShaderWrapper<ID3D11ComputeShader> csScene1 = REGISTER_SHADER_WITH_DEFINES("..\\gpu\\b288.hlsl", "_0", "cs_5_0", scene1ID);
	ShaderWrapper<ID3D11ComputeShader> csScene2 = REGISTER_SHADER_WITH_DEFINES("..\\gpu\\b288.hlsl", "_0", "cs_5_0", scene2ID);
	ShaderWrapper<ID3D11ComputeShader> csScene3 = REGISTER_SHADER_WITH_DEFINES("..\\gpu\\b288.hlsl", "_0", "cs_5_0", scene3ID);
	ShaderWrapper<ID3D11ComputeShader> csScene4 = REGISTER_SHADER_WITH_DEFINES("..\\gpu\\b288.hlsl", "_0", "cs_5_0", scene4ID);


	//ShaderWrapper<ID3D11ComputeShader> csBlurV = REGISTER_SHADER("postprocessing.hlsl", "csBlurV", "cs_5_0");
	//ShaderWrapper<ID3D11ComputeShader> csBlurH = REGISTER_SHADER("postprocessing.hlsl", "csBlurH", "cs_5_0");
	//ShaderWrapper<ID3D11ComputeShader> csStreaks = REGISTER_SHADER("postprocessing.hlsl", "csStreaks", "cs_5_0");
	//ShaderWrapper<ID3D11ComputeShader> csMerge = REGISTER_SHADER("postprocessing.hlsl", "csMerge", "cs_5_0");

	//ShaderWrapper<ID3D11ComputeShader> csDistortChroma = REGISTER_SHADER("postprocessing.hlsl", "csDistortChroma", "cs_5_0");
	//ShaderWrapper<ID3D11ComputeShader> csRadialBlur = REGISTER_SHADER("postprocessing.hlsl", "csRadialBlur", "cs_5_0");
	//ShaderWrapper<ID3D11ComputeShader> csCircumferentialBlur = REGISTER_SHADER("postprocessing.hlsl", "csCircumferentialBlur", "cs_5_0");	
	//ShaderWrapper<ID3D11ComputeShader> csLensDirt = REGISTER_SHADER("postprocessing.hlsl", "csLensDirt", "cs_5_0");	
	//ShaderWrapper<ID3D11ComputeShader> csGhosts = REGISTER_SHADER("postprocessing.hlsl", "csGhosts", "cs_5_0");
	ShaderWrapper<ID3D11ComputeShader> csFXAA = REGISTER_SHADER("postprocessing.hlsl", "csFXAA", "cs_5_0");

	D3D11_SAMPLER_DESC samplerDesc = {
		D3D11_FILTER_MIN_MAG_MIP_LINEAR, //D3D11_FILTER_MIN_MAG_MIP_LINEAR, D3D11_FILTER_ANISOTROPIC, D3D11_FILTER_MIN_MAG_MIP_POINT
		D3D11_TEXTURE_ADDRESS_CLAMP,
		D3D11_TEXTURE_ADDRESS_CLAMP,
		D3D11_TEXTURE_ADDRESS_CLAMP,
		0.0f,
		1,
		D3D11_COMPARISON_ALWAYS,
		{0,0,0,0},
		0,
		D3D11_FLOAT32_MAX
	};

	ID3D11SamplerState* sampler;
	device->CreateSamplerState(&samplerDesc, &sampler);
	context->CSSetSamplers(0, 1, &sampler);

	TEXTURE_2D_SRV_UAV_RTV tex0;
	createSRVUAVRTV(&tex0, WIDTH, HEIGHT);

	TEXTURE_2D_SRV_UAV_RTV streaksTex4;
	createSRVUAVRTV(&streaksTex4, WIDTH/4, HEIGHT/4);

	TEXTURE_2D_SRV_UAV_RTV tmpTex1;
	TEXTURE_2D_SRV_UAV_RTV blurTex1;
	createSRVUAVRTV(&tmpTex1, WIDTH, HEIGHT);
	createSRVUAVRTV(&blurTex1, WIDTH, HEIGHT);

	TEXTURE_2D_SRV_UAV_RTV tmpTex8;
	TEXTURE_2D_SRV_UAV_RTV blurTex8;
	createSRVUAVRTV(&tmpTex8, WIDTH/8, HEIGHT/8);
	createSRVUAVRTV(&blurTex8, WIDTH/8, HEIGHT/8);

	TEXTURE_2D_SRV_UAV_RTV tmpTex32;
	TEXTURE_2D_SRV_UAV_RTV blurTex32;
	createSRVUAVRTV(&tmpTex32, WIDTH/32, HEIGHT/32);
	createSRVUAVRTV(&blurTex32, WIDTH/32, HEIGHT/32);

	ID3D11Buffer* constantBuffer;
	D3D11_BUFFER_DESC constantBufferDesc = {
		sizeof(CONSTANT_BUFFER_STRUCT),
		D3D11_USAGE_DYNAMIC,
		D3D11_BIND_CONSTANT_BUFFER,
		D3D11_CPU_ACCESS_WRITE,
		0,
		0
	};

	device->CreateBuffer(&constantBufferDesc, NULL, &constantBuffer);
	//OPENFILE
	//BOOL success = GetOpenFileName()

#ifdef USE_PERFORMANCE_QUERIES
	setupQueries();
#endif

	Camera camera;
	//camera.loadCamera(CAMERA_FILENAME);

	float prevX = 0.0f;
	float prevY = 0.0f;

	int startTime = GetTickCount();
	int previousTime = startTime;

	MSG msg = {0};
	while (msg.message != WM_QUIT) {
		if (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) {
			TranslateMessage(&msg);
			DispatchMessageA(&msg);
			continue;
		}
#ifndef USE_PERFORMANCE_QUERIES
		CHECK_AND_RELOAD_SHADERS();
#endif
		int currentTime = GetTickCount() - startTime;
		//if (currentTime / 1000 > 2) ExitProcess(0);
		{
			float timeDelta = (currentTime - previousTime) / 1000.0f;
			float translateDelta = translationSpeed * timeDelta * 10.0f;
			float rotationAngle = 2.0f * timeDelta * translationSpeed;

			if (keys['R']) { camera.reset(); translationSpeed = 1.0f;};
			if (keys['W']) camera.translate(0.0f, 0.0f, -translateDelta);
			if (keys['S']) camera.translate(0.0f, 0.0f, +translateDelta);
			if (keys['A']) camera.translate(-translateDelta, 0.0f, 0.0f);
			if (keys['D']) camera.translate(+translateDelta, 0.0f, 0.0f);
			if (keys['Q']) camera.translate(0.0f, -translateDelta, 0.0f);
			if (keys['E']) camera.translate(0.0f, +translateDelta, 0.0f);

			if (keys[VK_OEM_COMMA])  camera.rotateAroundW(+rotationAngle);
			if (keys[VK_OEM_PERIOD]) camera.rotateAroundW(-rotationAngle);
			if (keys[VK_LEFT])       camera.rotateAroundV(+rotationAngle);
			if (keys[VK_RIGHT])      camera.rotateAroundV(-rotationAngle);
			if (keys[VK_UP])         camera.rotateAroundU(+rotationAngle);
			if (keys[VK_DOWN])       camera.rotateAroundU(-rotationAngle);

			if (keys['G']) camera.storeCamera(CAMERA_FILENAME);
			if (keys['H']) camera.loadCamera(CAMERA_FILENAME);
			if (keys['J']) CHECK_AND_RELOAD_SHADERS();

			if (leftMouseButtonDown) {
				float x = -(((mouseCursorPosition.x + 0.5f) /  WIDTH) - 0.5f);
				float y = -(((mouseCursorPosition.y + 0.5f) / HEIGHT) - 0.5f);

				float thetaX = float(M_PI) * (x - prevX) * (float(HEIGHT)/float(WIDTH));
				float thetaY = float(M_PI) * (y - prevY) * 1.0f;
			
				if (!leftMouseButtonDownInit) {
					if (thetaX != 0.0f) camera.rotateAroundV(thetaX);
					if (thetaY != 0.0f) camera.rotateAroundU(thetaY);
				} else {
					leftMouseButtonDownInit = false;
				}

				prevX = x;
				prevY = y;
			}
		}

#ifdef USE_PERFORMANCE_QUERIES
	context->Begin(disjointQuery);
	context->End(beginFrameQuery);
#endif

		D3D11_MAPPED_SUBRESOURCE mappedResource;
		context->Map(constantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
			CONSTANT_BUFFER_STRUCT* cb = (CONSTANT_BUFFER_STRUCT*)mappedResource.pData;
			cb->time = currentTime / 1000.0f;
			cb->viewPosition = camera.getViewPosition();
			cb->viewDirection = camera.getViewDirection();
			cb->viewUp = camera.getViewUp();
		context->Unmap(constantBuffer, 0);

		context->CSSetConstantBuffers(0, 1, &constantBuffer);

		int DISPATCH = 0;

		ID3D11UnorderedAccessView* UAVs[] = { tex0.UAV, indirectDispatchBufferUAV };

		// CALL MCP
		context->CSSetUnorderedAccessViews(0, 2, UAVs, NULL);
		context->CSSetShader(csMCP, NULL, 0);
		context->DispatchIndirect(indirectDispatchBuffer, DISPATCH);
		DISPATCH += 16;

		// SCENE 0
		//context->CSSetUnorderedAccessViews(0, 1, &tex0.UAV, NULL);

		context->CSSetShader(csScene0, NULL, 0);
		context->DispatchIndirect(indirectDispatchBuffer, DISPATCH);
		DISPATCH += 16;

		// SCENE 1
		context->CSSetShader(csScene1, NULL, 0);
		context->DispatchIndirect(indirectDispatchBuffer, DISPATCH);
		DISPATCH += 16;

		// SCENE 2
		context->CSSetShader(csScene2, NULL, 0);
		context->DispatchIndirect(indirectDispatchBuffer, DISPATCH);
		DISPATCH += 16;

		// SCENE 3
		context->CSSetShader(csScene3, NULL, 0);
		context->DispatchIndirect(indirectDispatchBuffer, DISPATCH);
		DISPATCH += 16;

		// SCENE 4
		context->CSSetShader(csScene4, NULL, 0);
		context->DispatchIndirect(indirectDispatchBuffer, DISPATCH);
		DISPATCH += 16;

		//context->CSSetShader(csRT, NULL, 0);
		//context->Dispatch(80, 45, 1);

// PIPELINE:
/*
Standard shader:
0 - MCP
1 - Blur V
2 - Blur H
3 - Steaks
4 - Merge
5 - Scene0
6 - Scene1
7 - Scene2
8 - Scene3
9 - Scene4

MCP (1, 1, 1) Dispatch, writes to indirectDispatchBuffer
-- MCP SWITCH CASE VIA DISPATCH-- SCENE0 RESOLUTION/1
-- MCP SWITCH CASE VIA DISPATCH-- SCENE1 RESOLUTION/1
-- MCP SWITCH CASE VIA DISPATCH-- SCENE2 RESOLUTION/1
-- MCP SWITCH CASE VIA DISPATCH-- SCENE3 RESOLUTION/1
-- MCP SWITCH CASE VIA DISPATCH-- SCENE4 RESOLUTION/1
-> MipMap
Streaks RESOLUTION/4
BLURV RESOLUTION/1
BLURH RESOLUTION/1
-> MipMap
BLURV RESOLUTION/8
BLURH RESOLUTION/8
-> MipMap
BLURV RESOLUTION/32
BLURH RESOLUTION/32
-> MipMap
MERGE RESOLUTION/1

Dispatches in the indirect dispatch buffer:
0 -> MCP
1 -> scene1
2 -> scene2
3 -> scene3
4 -> scene4
5 -> scene5
6 -> streaks
7 -> blurh
8 -> blurv
9 -> blurh
10 -> blurv
11 -> blurh
12 -> blurv
13 -> merge

*/
		context->GenerateMips(tex0.SRV);
		// Streaks
		context->CSSetUnorderedAccessViews(0, 1, &streaksTex4.UAV, NULL);
		context->CSSetShaderResources(0, 1, &tex0.SRV);
		context->CSSetShader(csStreaks, NULL, 0);
		//context->Dispatch(20, 12, 1);
		context->DispatchIndirect(indirectDispatchBuffer, DISPATCH);
		DISPATCH += 16;


		// BlurV (1/1)
		context->CSSetUnorderedAccessViews(0, 1, &tmpTex1.UAV, NULL);
		context->CSSetShaderResources(0, 1, &tex0.SRV);
		context->CSSetShader(csBlurV, NULL, 0);
		//context->Dispatch(80, 45, 1);
		context->DispatchIndirect(indirectDispatchBuffer, DISPATCH);
		DISPATCH += 16;

		// BlurH (1/1) -> blurTex1
		context->CSSetUnorderedAccessViews(0, 1, &blurTex1.UAV, NULL);
		context->CSSetShaderResources(0, 1, &tmpTex1.SRV);
		context->CSSetShader(csBlurH, NULL, 0);
		//context->Dispatch(80, 45, 1);
		context->DispatchIndirect(indirectDispatchBuffer, DISPATCH);
		DISPATCH += 16;

		context->GenerateMips(blurTex1.SRV);

		// BlurV (1/8)
		context->CSSetUnorderedAccessViews(0, 1, &tmpTex8.UAV, NULL);
		context->CSSetShaderResources(0, 1, &blurTex1.SRV);
		context->CSSetShader(csBlurV, NULL, 0);
		//context->Dispatch(10, 6, 1);
		context->DispatchIndirect(indirectDispatchBuffer, DISPATCH);
		DISPATCH += 16;

		// BlurH (1/8) -> blurTex8 -> merge / ghosts
		context->CSSetUnorderedAccessViews(0, 1, &blurTex8.UAV, NULL);
		context->CSSetShaderResources(0, 1, &tmpTex8.SRV);
		context->CSSetShader(csBlurH, NULL, 0);
		//context->Dispatch(10, 6, 1);
		context->DispatchIndirect(indirectDispatchBuffer, DISPATCH);
		DISPATCH += 16;

		context->GenerateMips(blurTex8.SRV);

		// BlurV (1/32)
		context->CSSetUnorderedAccessViews(0, 1, &tmpTex32.UAV, NULL);
		context->CSSetShaderResources(0, 1, &blurTex8.SRV);
		context->CSSetShader(csBlurV, NULL, 0);
		//context->Dispatch(3, 2, 1);
		context->DispatchIndirect(indirectDispatchBuffer, DISPATCH);
		DISPATCH += 16;

		// BlurH (1/32) -> blurTex32 -> merge / lensDirt / smallDirt / ghosts
		context->CSSetUnorderedAccessViews(0, 1, &blurTex32.UAV, NULL);
		context->CSSetShaderResources(0, 1, &tmpTex32.SRV);
		context->CSSetShader(csBlurV, NULL, 0);
		//context->Dispatch(3, 2, 1);
		context->DispatchIndirect(indirectDispatchBuffer, DISPATCH);
		DISPATCH += 16;

		setNullUAVSRV();

		// Merge
		ID3D11ShaderResourceView* mergeSRV[] = { tex0.SRV, blurTex1.SRV, blurTex8.SRV, blurTex32.SRV, streaksTex4.SRV };
		context->CSSetUnorderedAccessViews(0, 1, &backBufferUAV, NULL);
		context->CSSetShaderResources(0, 5, mergeSRV);
		context->CSSetShader(csMerge, NULL, 0);
		//context->Dispatch(80, 45, 1);
		context->DispatchIndirect(indirectDispatchBuffer, DISPATCH);
		//DISPATCH += 16;

		//context->CSSetUnorderedAccessViews(0, 1, &tmpTex1.UAV, NULL);
		//context->CSSetShaderResources(0, 5, mergeSRV);
		//context->CSSetShader(csMerge, NULL, 0);
		//context->Dispatch(80, 45, 1);

		//context->CSSetUnorderedAccessViews(0, 1, &backBufferUAV, NULL);
		//context->CSSetShaderResources(0, 1, &tmpTex1.SRV);
		//context->CSSetShader(csFXAA, NULL, 0);
		//context->Dispatch(80, 45, 1);

		setNullUAVSRV();
		swapChain->Present(1, 0);
		//Sleep(100);
#ifdef USE_PERFORMANCE_QUERIES
	context->End(endFrameQuery);
	context->End(disjointQuery);

	getPerformanceData();
#endif

		previousTime = currentTime;
	}

	ExitProcess(0);
	return EXIT_SUCCESS;
}