shader3/main.cpp

#include <windows.h>
#include "glew.h"
#include <stdio.h>
#include <math.h>
#include "utils.h"
#include "GPUProgram.h"
#include "ObjModel.h"
#include "FBO.h"
#include "FullScreenQuad.h"
#include "Glm/glm.hpp"
#include "Glm/ext.hpp"
#pragma comment(lib,"opengl32.lib")
#pragma comment(lib,"glew32.lib")

LRESULT CALLBACK GLWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch (msg)
	{
	case WM_CLOSE:
		PostQuitMessage(0);
		break;
	}
	return DefWindowProc(hwnd,msg,wParam,lParam);
}


INT WINAPI WinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPSTR lpCmdLine, _In_ int nShowCmd)
{
	WNDCLASSEX wndClass;
	wndClass.cbClsExtra = 0;
	wndClass.cbSize = sizeof(WNDCLASSEX);
	wndClass.cbWndExtra = 0;
	wndClass.hbrBackground = NULL;
	wndClass.hCursor = LoadCursor(NULL,IDC_ARROW);
	wndClass.hIcon = NULL;
	wndClass.hIconSm = NULL;
	wndClass.hInstance = hInstance;
	wndClass.lpfnWndProc=GLWindowProc;
	wndClass.lpszClassName = "OpenGL";
	wndClass.lpszMenuName = NULL;
	wndClass.style = CS_VREDRAW | CS_HREDRAW;
	ATOM atom = RegisterClassEx(&wndClass);

	RECT rect;
	rect.left = 0;
	rect.top = 0;
	rect.right = 800;
	rect.bottom = 600;
	AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW, FALSE);

	HWND hwnd = CreateWindowEx(NULL, "OpenGL", "RenderWindow", WS_OVERLAPPEDWINDOW, 100, 100, rect.right - rect.left, rect.bottom - rect.top, NULL, NULL, hInstance, NULL);
	HDC dc = GetDC(hwnd);
	PIXELFORMATDESCRIPTOR pfd;
	memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
	pfd.nVersion = 1;
	pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_TYPE_RGBA | PFD_DOUBLEBUFFER;
	pfd.iLayerType = PFD_MAIN_PLANE;
	pfd.iPixelType = PFD_TYPE_RGBA;
	pfd.cColorBits = 32;
	pfd.cDepthBits = 24;
	pfd.cStencilBits = 8;

	int pixelFormatID = ChoosePixelFormat(dc, &pfd);

	SetPixelFormat(dc,pixelFormatID,&pfd);

	HGLRC rc = wglCreateContext(dc);
	wglMakeCurrent(dc, rc);

	GetClientRect(hwnd, &rect);
	int viewportWidth = rect.right - rect.left, viewportHeight = rect.bottom - rect.top;

	glewInit();

	//init fsqgpu program
	GPUProgram originalProgram;
	originalProgram.AttachShader(GL_VERTEX_SHADER, "res/shader/fullscreenquad.vs");
	originalProgram.AttachShader(GL_FRAGMENT_SHADER, "res/shader/fullscreenquad.fs");
	originalProgram.Link();
	originalProgram.DetectAttribute("pos");
	originalProgram.DetectAttribute("texcoord");
	originalProgram.DetectUniform("U_MainTexture");

	//init hdr program
	GPUProgram hdrProgram;
	hdrProgram.AttachShader(GL_VERTEX_SHADER, "res/shader/fullscreenquad.vs");
	hdrProgram.AttachShader(GL_FRAGMENT_SHADER, "res/shader/hdrrender.fs");
	hdrProgram.Link();
	hdrProgram.DetectAttribute("pos");
	hdrProgram.DetectAttribute("texcoord");
	hdrProgram.DetectUniform("U_MainTexture");

	//��˹ģ��
	GPUProgram gaussianProgram;
	gaussianProgram.AttachShader(GL_VERTEX_SHADER, "res/shader/fullscreenquad.vs");
	gaussianProgram.AttachShader(GL_FRAGMENT_SHADER, "res/shader/fullscreenquad_gaussian.fs");
	gaussianProgram.Link();
	gaussianProgram.DetectAttribute("pos");
	gaussianProgram.DetectAttribute("texcoord");
	gaussianProgram.DetectUniform("U_MainTexture");

	//combine program
	GPUProgram combineProgram;
	combineProgram.AttachShader(GL_VERTEX_SHADER, "res/shader/fullscreenquad.vs");
	combineProgram.AttachShader(GL_FRAGMENT_SHADER, "res/shader/combine.fs");
	combineProgram.Link();
	combineProgram.DetectAttribute("pos");
	combineProgram.DetectAttribute("texcoord");
	combineProgram.DetectUniform("U_MainTexture");
	combineProgram.DetectUniform("U_HDRTexture");


	//init light source program
	GPUProgram lightSourceProgram;
	lightSourceProgram.AttachShader(GL_VERTEX_SHADER, "res/shader/lightSource.vs");
	lightSourceProgram.AttachShader(GL_FRAGMENT_SHADER, "res/shader/lightSource.fs");
	lightSourceProgram.Link();
	lightSourceProgram.DetectAttribute("pos");
	lightSourceProgram.DetectUniform("M");
	lightSourceProgram.DetectUniform("V");
	lightSourceProgram.DetectUniform("P");


	//init gpu program
	GPUProgram gpuProgram;
	gpuProgram.AttachShader(GL_VERTEX_SHADER, "res/shader/test.vs");
	gpuProgram.AttachShader(GL_FRAGMENT_SHADER, "res/shader/hdr.fs");
	gpuProgram.Link();

	gpuProgram.DetectAttribute("pos");
	gpuProgram.DetectAttribute("texcoord");
	gpuProgram.DetectAttribute("normal");
	gpuProgram.DetectUniform("M");
	gpuProgram.DetectUniform("V");
	gpuProgram.DetectUniform("P");
	gpuProgram.DetectUniform("NM");
	gpuProgram.DetectUniform("U_AmbientLightColor");
	gpuProgram.DetectUniform("U_AmbientMaterial");
	gpuProgram.DetectUniform("U_DiffuseLightColor");
	gpuProgram.DetectUniform("U_DiffuseMaterial");
	gpuProgram.DetectUniform("U_DiffuseIntensity");
	gpuProgram.DetectUniform("U_LightPos");
	gpuProgram.DetectUniform("U_LightDirection");
	gpuProgram.DetectUniform("U_Cutoff");
	gpuProgram.DetectUniform("U_SpecularLightColor");
	gpuProgram.DetectUniform("U_SpecularMaterial");
	gpuProgram.DetectUniform("U_EyePos");

	//init 3d model
	ObjModel obj,quad,sphere;
	obj.Init("res/model/Cube.obj");
	quad.Init("res/model/Quad.obj");
	sphere.Init("res/model/Sphere.obj");

	float identity[] = {
		1.0f,0,0,0,
		0,1.0f,0,0,
		0,0,1.0f,0,
		0,0,0,1.0f
	};

	float ambientLightColor[] = { 0.4f,0.4f,0.4f,1.0f };
	float ambientMaterial[] = { 0.2f,0.2f,0.2f,1.0f };
	float diffuseLightColor[] = { 1.0f,1.0f,1.0f,1.0f };
	float diffuseMaterial[] = { 0.8f, 0.8f, 0.8f, 1.0f };
	float lightPos[] = { 0.1f,3.0f, -2.2f,1.0f };
	float diffuseIntensity = 3.0f;

	float spotLightDirection[] = { 0.0f, -1.0f, 0.0f, 128.0f };//������һλ�ij�......
	float spotLightCutoff = 0.0f;


	float specularLightColor[] = { 1.0f,1.0f,1.0f,1.0f };
	float specularMaterial[] = { 1.0f,1.0f,1.0f,1.0f };
	float eyePos[] = { 0.0f, 0.0f, 0.0f };


	glm::mat4 model = glm::translate<float>(0.0f, 0.0f, -2.0f) * glm::rotate(-60.0f, 1.0f, 1.0f, 1.0f);
	glm::mat4 normalMatrix = glm::inverseTranspose(model);

	glm::mat4 quadModel = glm::translate<float>(0.0f, 0.0f, -2.0f) * glm::rotate(-90.0f, 1.0f, 0.0f, 0.0f) * glm::scale(8.0f, 8.0f, 8.0f);
	glm::mat4 quadNormalMatrix = glm::inverseTranspose(quadModel);

	glm::mat4 sphereModel = glm::translate<float>(0.1f, 3.0f, -2.2f) * glm::scale(0.2f, 0.2f, 0.2f);
	glm::mat4 sphereNormalMatrix = glm::inverseTranspose(sphereModel);


	glm::mat4 viewMatrix = glm::lookAt(glm::vec3(1.0f, 0.5f, -10.0f), glm::vec3(0.0f, 0.0f, -1.0f), glm::vec3(0.0f, 1.0f, 0.0f));
	glm::mat4 projectionMatrix = glm::perspective(50.0f, 800.0f / 600.0f, 0.1f, 1000.0f);
	

	//��ʼ��fsq
	FullScreenQuad fsq;
	fsq.Init();

	//��ʼ��FBO
	FBO fbo[2];
	fbo[0].AttachColorBuffer("color", GL_COLOR_ATTACHMENT0, GL_RGBA, viewportWidth, viewportHeight);
	fbo[0].AttachDepthBuffer("depth", viewportWidth, viewportHeight);
	fbo[1].AttachColorBuffer("color", GL_COLOR_ATTACHMENT0, GL_RGBA, viewportWidth, viewportHeight);
	fbo[1].AttachDepthBuffer("depth", viewportWidth, viewportHeight);


	FBO HDRfbo;
	HDRfbo.AttachColorBuffer("color", GL_COLOR_ATTACHMENT0, GL_RGBA, viewportWidth, viewportHeight);
	HDRfbo.AttachColorBuffer("hdrcolor", GL_COLOR_ATTACHMENT1, GL_RGBA16F, viewportWidth, viewportHeight);
	HDRfbo.AttachDepthBuffer("depth", viewportWidth, viewportHeight);
	HDRfbo.Finish();

	ShowWindow(hwnd, SW_SHOW);
	UpdateWindow(hwnd);

	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
	MSG msg;
	while (true)
	{
		if (PeekMessage(&msg,NULL,NULL,NULL,PM_REMOVE))
		{
			if (msg.message==WM_QUIT)
			{
				break;
			}
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
		glEnable(GL_DEPTH_TEST);
		

		HDRfbo.Bind();
		glUseProgram(gpuProgram.mProgram);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		glUniform4fv(gpuProgram.GetLocation("U_AmbientLightColor"), 1, ambientLightColor);
		glUniform4fv(gpuProgram.GetLocation("U_AmbientMaterial"), 1, ambientMaterial);
		glUniform4fv(gpuProgram.GetLocation("U_DiffuseLightColor"), 1, diffuseLightColor);
		glUniform4fv(gpuProgram.GetLocation("U_DiffuseMaterial"), 1, diffuseMaterial);
		glUniform1f(gpuProgram.GetLocation("U_DiffuseIntensity"), diffuseIntensity);
		glUniform4fv(gpuProgram.GetLocation("U_LightDirection"), 1, spotLightDirection);
		glUniform4fv(gpuProgram.GetLocation("U_SpecularLightColor"), 1, specularLightColor);
		glUniform4fv(gpuProgram.GetLocation("U_SpecularMaterial"), 1, specularMaterial);
		glUniform4fv(gpuProgram.GetLocation("U_LightPos"), 1, lightPos);
		glUniform3fv(gpuProgram.GetLocation("U_EyePos"), 1, eyePos);
		glUniform1f(gpuProgram.GetLocation("U_Cutoff"), spotLightCutoff);
		glUniformMatrix4fv(gpuProgram.GetLocation("M"), 1, GL_FALSE, glm::value_ptr(model));
		glUniformMatrix4fv(gpuProgram.GetLocation("V"), 1, GL_FALSE, glm::value_ptr(viewMatrix));
		glUniformMatrix4fv(gpuProgram.GetLocation("P"), 1, GL_FALSE, glm::value_ptr(projectionMatrix));
		glUniformMatrix4fv(gpuProgram.GetLocation("NM"), 1, GL_FALSE, glm::value_ptr(normalMatrix));
		obj.Bind(gpuProgram.GetLocation("pos"), gpuProgram.GetLocation("texcoord"), gpuProgram.GetLocation("normal"));
		obj.Draw();

		glUniformMatrix4fv(gpuProgram.GetLocation("M"), 1, GL_FALSE, glm::value_ptr(quadModel));
		glUniformMatrix4fv(gpuProgram.GetLocation("NM"), 1, GL_FALSE, glm::value_ptr(quadNormalMatrix));
		quad.Bind(gpuProgram.GetLocation("pos"), gpuProgram.GetLocation("texcoord"), gpuProgram.GetLocation("normal"));
		quad.Draw();


		glUseProgram(lightSourceProgram.mProgram);
		glUniformMatrix4fv(lightSourceProgram.GetLocation("M"), 1, GL_FALSE, glm::value_ptr(sphereModel));
		glUniformMatrix4fv(lightSourceProgram.GetLocation("V"), 1, GL_FALSE, glm::value_ptr(viewMatrix));
		glUniformMatrix4fv(lightSourceProgram.GetLocation("P"), 1, GL_FALSE, glm::value_ptr(projectionMatrix));
		sphere.Bind(lightSourceProgram.GetLocation("pos"), lightSourceProgram.GetLocation("texcoord"), lightSourceProgram.GetLocation("normal"));
		sphere.Draw();

		glUseProgram(0);
		HDRfbo.Unbind();

		/* blur start */
		fbo[0].Bind();
		glUseProgram(gaussianProgram.mProgram);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, HDRfbo.GetBuffer("hdrcolor"));
		glUniform1i(gaussianProgram.GetLocation("U_MainTexture"), 0);
		fsq.Draw(gaussianProgram.GetLocation("pos"), gaussianProgram.GetLocation("texcoord"));
		fbo[0].Unbind();

		fbo[1].Bind();
		glUseProgram(gaussianProgram.mProgram);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, fbo[0].GetBuffer("color"));
		glUniform1i(gaussianProgram.GetLocation("U_MainTexture"), 0);
		fsq.Draw(gaussianProgram.GetLocation("pos"), gaussianProgram.GetLocation("texcoord"));
		fbo[1].Unbind();

		fbo[0].Bind();
		glUseProgram(gaussianProgram.mProgram);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, fbo[1].GetBuffer("color"));
		glUniform1i(gaussianProgram.GetLocation("U_MainTexture"), 0);
		fsq.Draw(gaussianProgram.GetLocation("pos"), gaussianProgram.GetLocation("texcoord"));
		fbo[0].Unbind();

		fbo[1].Bind();
		glUseProgram(gaussianProgram.mProgram);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, fbo[0].GetBuffer("color"));
		glUniform1i(gaussianProgram.GetLocation("U_MainTexture"), 0);
		fsq.Draw(gaussianProgram.GetLocation("pos"), gaussianProgram.GetLocation("texcoord"));
		fbo[1].Unbind();
		/* blur end */

		glFlush();
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		glActiveTexture(GL_TEXTURE0);

		glUseProgram(originalProgram.mProgram);
		glBindTexture(GL_TEXTURE_2D, HDRfbo.GetBuffer("color"));
		glUniform1i(originalProgram.GetLocation("U_MainTexture"), 0);
		fsq.DrawToLeftTop(originalProgram.GetLocation("pos"), originalProgram.GetLocation("texcoord"));
		
		glUseProgram(hdrProgram.mProgram);
		glBindTexture(GL_TEXTURE_2D, HDRfbo.GetBuffer("hdrcolor"));
		glUniform1i(hdrProgram.GetLocation("U_MainTexture"), 0);
		fsq.DrawToRightTop(hdrProgram.GetLocation("pos"), hdrProgram.GetLocation("texcoord"));

		glUseProgram(gaussianProgram.mProgram);
		glBindTexture(GL_TEXTURE_2D, fbo[1].GetBuffer("color"));
		glUniform1i(gaussianProgram.GetLocation("U_MainTexture"), 0);
		fsq.DrawToLeftBottom(gaussianProgram.GetLocation("pos"), gaussianProgram.GetLocation("texcoord"));

		glUseProgram(combineProgram.mProgram);
		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, HDRfbo.GetBuffer("color"));
		glUniform1i(combineProgram.GetLocation("U_MainTexture"), 0);
		glActiveTexture(GL_TEXTURE1);
		glBindTexture(GL_TEXTURE_2D, fbo[1].GetBuffer("color"));
		glUniform1i(combineProgram.GetLocation("U_HDRTexture"), 1);
		fsq.DrawToRightBottom(combineProgram.GetLocation("pos"), combineProgram.GetLocation("texcoord"));

		SwapBuffers(dc);
	}
	return 0;
}