/////////////////////////////////////////////////////////////////////////////////////////////////////////
// SimpleGamePlugin
// MyGame.cpp
// 
// Code : Anael Seghezzi
/////////////////////////////////////////////////////////////////////////////////////////////////////////

#include "MyGame.h"


#define RESOL 256


// simple blur example
string vertShader = string(
"#ifdef GL_ES\n"
"precision highp float;\n"
"#endif\n"					   
						   
"varying vec2 texcoord;"						   
"attribute vec2 Vertex;"
"attribute vec2 TexCoord;"	
"uniform mat4 ProjModelViewMatrix;"						   
						   
"void main(void)"
"{"
	"texcoord = TexCoord;"
	"gl_Position = ProjModelViewMatrix * vec4(Vertex.x, Vertex.y, 0.0, 1.0);"
"}");

string fragShader = string(
"#ifdef GL_ES\n"
"precision highp float;\n"
"#endif\n"
						   
"varying vec2 texcoord;"
"uniform sampler2D Texture;"
							
"void main(void)"
"{"
	"vec3 color = vec3(0.0, 0.0, 0.0);"
	"float x, y;"
	"for(y=-0.5; y<=0.5; y+=0.5)"
	"for(x=-0.5; x<=0.5; x+=0.5)"
	"{"
		"color += texture2D(Texture, texcoord + vec2(x*0.02, y*0.02)).xyz;"
	"}"
							
	"color /= 9.0;"
							
	"gl_FragColor = vec4(color.x, color.y, color.z, 1.0);"
"}");



// constructor
MyGame::MyGame(void):
m_fx(0),
m_vertShad(0),
m_pixShad(0),
m_colorTextureId(0),
m_depthTextureId(0),
m_renderBufferId(0),
MGame()
{
	MRenderingContext * render = MEngine::getInstance()->getRenderingContext();
	
	unsigned int currentFrameBuffer = 0;
	render->getCurrentFrameBuffer(&currentFrameBuffer);
	
	// create shader
	render->createVertexShader(&m_vertShad);
	render->sendShaderSource(m_vertShad, vertShader.c_str());
	render->createPixelShader(&m_pixShad);
	render->sendShaderSource(m_pixShad, fragShader.c_str());
	render->createFX(&m_fx, m_vertShad, m_pixShad);
	
	// create frame buffer
	render->createFrameBuffer(&m_renderBufferId);
	
	// create render textures
	render->createTexture(&m_colorTextureId);
	render->bindTexture(m_colorTextureId);
	render->setTextureFilterMode(M_TEX_FILTER_LINEAR, M_TEX_FILTER_LINEAR);
	render->setTextureUWrapMode(M_WRAP_CLAMP);
	render->setTextureVWrapMode(M_WRAP_CLAMP);
	render->texImage(0, RESOL, RESOL, M_UBYTE, M_RGBA, 0);
	
	render->createTexture(&m_depthTextureId);
	render->bindTexture(m_depthTextureId);
	render->setTextureFilterMode(M_TEX_FILTER_NEAREST, M_TEX_FILTER_NEAREST);
	render->texImage(0, RESOL, RESOL, M_UBYTE, M_DEPTH, 0);
	
	render->bindFrameBuffer(m_renderBufferId);
	render->attachFrameBufferTexture(M_ATTACH_COLOR0, m_colorTextureId);
	render->attachFrameBufferTexture(M_ATTACH_DEPTH, m_depthTextureId);
	
	render->bindFrameBuffer(currentFrameBuffer);
}

// destructor
MyGame::~MyGame(void)
{
	MRenderingContext * render = MEngine::getInstance()->getRenderingContext();
	
	render->deleteTexture(&m_colorTextureId);
	render->deleteTexture(&m_depthTextureId);	
	render->deleteFrameBuffer(&m_renderBufferId);	
	render->deleteFX(&m_fx);
	render->deleteShader(&m_vertShad);
	render->deleteShader(&m_pixShad);
}


// custom functions
void MyGame::set2dMode(unsigned int width, unsigned int height)
{
	MRenderingContext * render = MEngine::getInstance()->getRenderingContext();
	render->setViewport(0, 0, width, height);
	
	// set ortho projection
	render->setMatrixMode(M_MATRIX_PROJECTION);
	render->loadIdentity();
	
	render->setOrthoView(0.0f, (float)width, (float)height, 0.0f, 1.0f, -1.0f);
	
	render->setMatrixMode(M_MATRIX_MODELVIEW);
	render->loadIdentity();
}

void MyGame::drawTexturedQuad(MVector2 scale)
{
	MRenderingContext * render = MEngine::getInstance()->getRenderingContext();
	
	int vertexAttrib;
	int texcoordAttrib;
	static MVector2 vertices[4];
	static MVector2 texCoords[4];
	
	vertices[0] = MVector2(0, 0);
	vertices[1] = MVector2(0, scale.y);
	vertices[3] = MVector2(scale.x, scale.y);
	vertices[2] = MVector2(scale.x, 0);
	
	texCoords[0] = MVector2(0, 1);
	texCoords[1] = MVector2(0, 0);
	texCoords[3] = MVector2(1, 0);
	texCoords[2] = MVector2(1, 1);
	
	// projmodelview matrix
	static MMatrix4x4 ProjMatrix;
	static MMatrix4x4 ModelViewMatrix;
	static MMatrix4x4 ProjModelViewMatrix;
	
	render->getProjectionMatrix(&ProjMatrix);
	render->getModelViewMatrix(&ModelViewMatrix);
	ProjModelViewMatrix = ProjMatrix * ModelViewMatrix;
	render->sendUniformMatrix(m_fx, "ProjModelViewMatrix", &ProjModelViewMatrix);
	
	// Texture
	int texId = 0;
	render->sendUniformInt(m_fx, "Texture", &texId);
						   
	// Vertex
	render->getAttribLocation(m_fx, "Vertex", &vertexAttrib);
	render->setAttribPointer(vertexAttrib, M_FLOAT, 2, vertices);
	render->enableAttribArray(vertexAttrib);
	
	// TexCoord
	render->getAttribLocation(m_fx, "TexCoord", &texcoordAttrib);
	render->setAttribPointer(texcoordAttrib, M_FLOAT, 2, texCoords);
	render->enableAttribArray(texcoordAttrib);
	
	// draw
	render->drawArray(M_PRIMITIVE_TRIANGLE_STRIP, 0, 4);
	
	render->disableAttribArray(vertexAttrib);
	render->disableAttribArray(texcoordAttrib);
}


// custom draw
void MyGame::draw(void)
{
	MEngine * engine = MEngine::getInstance(); // get the engine instance
	MRenderingContext * render = engine->getRenderingContext(); // get the rendering context
	MSystemContext * system = engine->getSystemContext();
	
	
	// get level
	MLevel * level = MEngine::getInstance()->getLevel();
	if(! level)
		return;
	
	// get current scene
	MScene * scene = level->getCurrentScene();
	if(! scene)
		return;
	

	// get current frame buffer
	unsigned int currentFrameBuffer = 0;
	render->getCurrentFrameBuffer(&currentFrameBuffer);
	
	// get current screen size
	unsigned int screenWidth = 0;
	unsigned int screenHeight = 0;
	system->getScreenSize(&screenWidth, &screenHeight);
	
	
	// bind render to texture frame buffer
	render->bindFrameBuffer(m_renderBufferId);
	
		
	// get camera
	MOCamera * camera = scene->getCameraByIndex(scene->getCurrentCamera());
	if(camera)
	{
		// enable camera with current screen ratio
		camera->enable();
		camera->updateListener();
		render->setClearColor(*camera->getClearColor());
	
		// change viewport
		render->setViewport(0, 0, RESOL, RESOL); 
	
		// draw the scene
		render->enableDepthTest();
		render->clear(M_BUFFER_COLOR | M_BUFFER_DEPTH);

		scene->draw(camera);
		scene->drawObjectsBehaviors();
	}
	
	
	// finish render to texture
	render->bindFrameBuffer(currentFrameBuffer);
	
	
	// draw the rendered textured with a shader effect
	render->setViewport(0, 0, screenWidth, screenHeight);
	render->setClearColor(MVector4(0, 0, 0, 1));
	render->clear(M_BUFFER_COLOR | M_BUFFER_DEPTH);

	set2dMode(screenWidth, screenHeight);
	
	render->bindFX(m_fx);
	render->bindTexture(m_colorTextureId);
	drawTexturedQuad(MVector2((float)screenWidth, (float)screenHeight));
	render->bindFX(0);
}