/*
 *  Renderer.cpp
 *  DerpFort
 *
 *  Created by Justin Li on 11-03-25.
 *  Copyright 2011 Frustra Software Design. All rights reserved.
 *
 */

#include "Renderer.h"
#include "DerpFort.h"

Renderer::Renderer()
{

}

Renderer::~Renderer()
{
}

#include <iostream>
void Renderer::initFramebuffers()
{
	if (gl.shaderManager.getShaderVersion() < 2) return; // only used for shaders anyways

	gBufferFBO.init(2, 1);
	postProcessingFBO[0].init(1, 1);
	postProcessingFBO[1].init(1, 1);
}

void Renderer::initShadowBuffers()
{
	int shadowMapWidth = gl.width * config.r_lightdetail.val / 4.0;
	int shadowMapHeight = gl.height * config.r_lightdetail.val / 4.0;

	//GLfloat borderColor[4] = {0,0,0,0};

	GLenum FBOstatus;

	// Try to use a texture depth component
	glGenTextures(1, &depthTextureId);
	glBindTexture(GL_TEXTURE_2D, depthTextureId);

	// GL_LINEAR does not make sense for depth texture. However, next tutorial shows usage of GL_LINEAR and PCF. Using GL_NEAREST
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

	// Remove artefact on the edges of the shadowmap
	glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
	glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );

	// This is to allow usage of shadow2DProj function in the shader
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
	glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_INTENSITY);


	// No need to force GL_DEPTH_COMPONENT24, drivers usually give you the max precision if available
	glTexImage2D( GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, shadowMapWidth, shadowMapHeight, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, 0);


    GLuint tmpTextureId;

	glGenTextures(1, &tmpTextureId);
	glBindTexture(GL_TEXTURE_2D, tmpTextureId);

	glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA16F, shadowMapWidth, shadowMapHeight, 0, GL_RGBA, GL_FLOAT, 0);
	glBindTexture(GL_TEXTURE_2D, 0);

	// create a framebuffer object
	glGenFramebuffersEXT(1, &fboId);
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboId);

	// Instruct openGL that we won't bind a color texture with the currently binded FBO
	glDrawBuffer(GL_NONE);
	glReadBuffer(GL_NONE);

	// attach the texture to FBO depth attachment point
	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D, depthTextureId, 0);
	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D, tmpTextureId, 0);

	// check FBO status
	FBOstatus = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
	if(FBOstatus != GL_FRAMEBUFFER_COMPLETE_EXT)
		printf("GL_FRAMEBUFFER_COMPLETE_EXT failed, CANNOT use FBO: %x\n", FBOstatus);

	// switch back to window-system-provided framebuffer
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
}

void Renderer::render()
{
	m_lastModelViewMatrix = m_modelViewMatrix;

	GLfloat projection[16];
	glGetFloatv(GL_PROJECTION_MATRIX, projection);
	m_projectionMatrix = glh::matrix4f(projection);

	GLfloat modelview[16];
	glGetFloatv(GL_MODELVIEW_MATRIX, modelview);
	m_modelViewMatrix = glh::matrix4f(modelview);

	m_inverseProjectionMatrix = (m_projectionMatrix * m_modelViewMatrix).inverse().transpose();

	gl.shaderManager.getShader("gBuffer")->use();
	glUniformMatrix4fv(gl.shaderManager.getShader("gBuffer")->getUniformLocation("m_lastModelViewMatrix"), 1, GL_FALSE, m_lastModelViewMatrix.m);
	gl.shaderManager.unUseProgram();

	renderWorld(true);
	renderPostProcessing();
}

void Renderer::renderWorld(bool shaders)
{
	glPushMatrix();
	glEnableClientState(GL_VERTEX_ARRAY);
	glEnableClientState(GL_COLOR_ARRAY);
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
	glEnable(GL_TEXTURE_2D);

	maps[0].tex.bind();
	if (gl.shaderManager.getShaderVersion() > 1 && shaders)// && config.r_ssao.val)
	{
		gBufferFBO.bind();

		GLenum mrt[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 };
		glDrawBuffers(2, mrt);

		glClearColor(0, 0, 0, 0);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		gl.shaderManager.getShader("gBuffer")->use();

		maps[0].renderMapArrays();

		gl.shaderManager.unUseProgram();

		glBindFramebuffer(GL_FRAMEBUFFER, 0);
		int err = glGetError();
		if (err) printf("OpenGL Error: %d\n", err);
	} else {
		glClearColor(0, 0, 0, 0);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		maps[0].renderMapArrays();
    }

	glDisable(GL_TEXTURE_2D);
	glDisableClientState(GL_COLOR_ARRAY);
	glDisableClientState(GL_VERTEX_ARRAY);
	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
	glPopMatrix();
}

void Renderer::renderPostProcessing()
{
	if (gl.shaderManager.getShaderVersion() < 2) return;

	// Set up ortho view
	glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT | GL_TRANSFORM_BIT);
	glMatrixMode(GL_PROJECTION);
	glPushMatrix();
	glLoadIdentity();
	gluOrtho2D(m_pViewport.viewport[0], m_pViewport.viewport[2], m_pViewport.viewport[1], m_pViewport.viewport[3]);
	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();
	glLoadIdentity();
	glDisable(GL_DEPTH_TEST);
	glDisable(GL_TEXTURE_2D);
	glDisable(GL_LIGHTING);

	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, gBufferFBO.getTargets()[0]);

	if (config.r_postprocessing.val)
	{
		glActiveTexture(GL_TEXTURE1);
		glBindTexture(GL_TEXTURE_2D, gBufferFBO.getTargets()[1]);
		glActiveTexture(GL_TEXTURE2);
		glBindTexture(GL_TEXTURE_2D, gBufferFBO.getDepthTex());
		glActiveTexture(GL_TEXTURE0);

		std::list<std::string> effectList = gl.effectManager.getEnabledEffects();
		std::list<std::string>::iterator effectIterator = effectList.begin();

		bool whichFBO = 0, effected;

		while (effectIterator != effectList.end())
		{
			BaseEffect *ef = gl.effectManager.getEffect(*effectIterator);

			postProcessingFBO[whichFBO].bind();

			effected = ef->process(gl.width, gl.height);

			if (effected)
			{
				glActiveTexture(GL_TEXTURE0);
				glBindTexture(GL_TEXTURE_2D, postProcessingFBO[whichFBO].getTargets()[0]);
				whichFBO = !whichFBO;
			}
			++effectIterator;
		}

		postProcessingFBO[0].unBind();
	}

	//glBindTexture(GL_TEXTURE_2D, gBufferFBO.getTargets()[1]);
	glEnable(GL_TEXTURE_2D);
	gl.drawOrthoQuad(gl.width, gl.height);

	// Revert modes
	glActiveTexture(GL_TEXTURE0);
	glPopMatrix();
	glMatrixMode(GL_PROJECTION);
	glPopMatrix();
	glPopAttrib();
}