#include "ecglrenderer.h"

#include "GL/glew.h"

#include "glshaderprogram.h"
#include "cjblog.h"

void ECGLRenderer::preLoop()
{
	m_stateManager = new GLStateManager();
	m_stateManager->init();

	IECRenderer::preLoop();
}

void ECGLRenderer::shutdown()
{
	if (m_stateManager)
	{
		delete m_stateManager;
		m_stateManager = NULL;
	}

	IECRenderer::shutdown();
}

void ECGLRenderer::clearBuffers(CJB_UINT32 buffers) 
{
	GLuint clearBuffers = 0;

	clearBuffers |= (clearBuffers & CJB_COLOR_BUFFER) ? 0 : GL_COLOR_BUFFER_BIT;
	clearBuffers |= (clearBuffers & CJB_DEPTH_BUFFER) ? 0 : GL_DEPTH_BUFFER_BIT;
	clearBuffers |= (clearBuffers & CJB_STENCIL_BUFFER) ? 0 : GL_STENCIL_BUFFER_BIT;

	glClear(clearBuffers);
}

void ECGLRenderer::setClearColor(float red, float green, float blue, float alpha)
{
	glClearColor(red,green,blue,alpha);
}

ITexture* ECGLRenderer::createTextureWithImage(const char* imageFile)
{
	GLTexture* newTexture = new GLTexture(imageFile);

	return newTexture;
}

void ECGLRenderer::bindTexture(ITexture* texture)
{
	glBindTexture(GL_TEXTURE_2D,((GLTexture*)texture)->getTextureID());
}

IShaderProgram* ECGLRenderer::createShaderProgram(const char* vertexShader, const char* fragmentShader)
{
	GLShaderProgram* ret = new GLShaderProgram(vertexShader,fragmentShader);

	if (ret == NULL)
	{
		CJBLOG_WARNING("Failed to create shader program with %s %s\n",vertexShader, fragmentShader);
		return NULL;
	}

	return ret;
}

void ECGLRenderer::deleteShaderProgram(IShaderProgram* program)
{
	glDeleteProgram(((GLShaderProgram*)program)->getProgramID());
}

void ECGLRenderer::useShaderProgram(IShaderProgram* program)
{
	glUseProgram(((GLShaderProgram*)program)->getProgramID());
}

IVertexBufferObject* ECGLRenderer::generateVBO()
{
	GLVertexBufferObject* newVBO = new GLVertexBufferObject;
	glGenBuffers(1,&newVBO->bufferID);
	return newVBO;
}

IVertexArrayObject* ECGLRenderer::generateVAO()
{
	GLVertexArrayObject* newVAO = new GLVertexArrayObject;
	glGenVertexArrays(1,&newVAO->arrayID);
	return newVAO;
}

void ECGLRenderer::bindVBO(CJB_UINT32 bufferType, IVertexBufferObject* pVBO)
{
	if (bufferType == VBO_ARRAY)
		glBindBuffer(GL_ARRAY_BUFFER,((GLVertexBufferObject*)pVBO)->bufferID);
	else
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,((GLVertexBufferObject*)pVBO)->bufferID);
}

void ECGLRenderer::bindVAO(IVertexArrayObject* pVAO)
{
	glBindVertexArray(((GLVertexArrayObject*)pVAO)->arrayID);
}

void ECGLRenderer::deleteVBO(IVertexBufferObject*& pVBO)
{
	glDeleteBuffers(1,&((GLVertexBufferObject*)pVBO)->bufferID);
	delete pVBO;
	pVBO = NULL;
}

void ECGLRenderer::deleteVAO(IVertexArrayObject*& pVAO)
{
	glDeleteVertexArrays(1,&((GLVertexArrayObject*)pVAO)->arrayID);
	delete pVAO;
	pVAO = NULL;
}

void ECGLRenderer::setBufferData(CJB_UINT32 target,size_t size, void* data, CJB_UINT32 usage)
{
	CJB_UINT32 glTarget = (target == VBO_ARRAY) ? GL_ARRAY_BUFFER : GL_ELEMENT_ARRAY_BUFFER;
	CJB_UINT32 glUsage = (usage == VBO_STATIC_DRAW) ? GL_STATIC_DRAW : GL_DYNAMIC_DRAW;

	glBufferData(glTarget,size,data,glUsage);
}

void ECGLRenderer::enableVertexAttributeArray(CJB_UINT32 attributeIndex)
{
	glEnableVertexAttribArray(attributeIndex);
}

void ECGLRenderer::setVertexAttributePointer(CJB_UINT32 attributeIndex, CJB_UINT32 size, CJB_UINT32 type, bool isNormalized, size_t stride, void* pointer)
{
	glVertexAttribPointer(attributeIndex,size,convertTypeToGLType(type),isNormalized,stride,pointer);
}

CJB_UINT32 ECGLRenderer::convertTypeToGLType(CJB_UINT32 elementType)
{
	switch(elementType)
	{
	case ET_FLOAT:
		return GL_FLOAT;
	case ET_USHORT:
		return GL_UNSIGNED_SHORT;
	case ET_UINT32:
		return GL_UNSIGNED_INT;
	}
}

void ECGLRenderer::unbindVBO(CJB_UINT32 bufferType)
{
	CJB_UINT32 glTarget = (bufferType == VBO_ARRAY) ? GL_ARRAY_BUFFER : GL_ELEMENT_ARRAY_BUFFER;
	glBindBuffer(glTarget,0);
}

void ECGLRenderer::unbindVAO()
{
	glBindVertexArray(0);
}

void ECGLRenderer::drawElements(CJB_UINT32 mode, size_t triCount, CJB_UINT32 type, void* INDICES )
{
	CJB_UINT32 glMode = (mode == DRAW_MODE_TRIANGLES) ? GL_TRIANGLES : GL_TRIANGLE_STRIP; 

	glDrawElements(glMode,triCount*3,convertTypeToGLType(type),INDICES);
}