//========================================
//	Class to interface the VisualCAD specifications.
//	Nicolau Sunyer & Sergi Funtané (10/13/2005).
//	Universitat de Girona.
//========================================

#pragma warning(disable:4244)
// Includes
#include "glew.h"
#include <glut.h>
#include "stdlib.h"

// Includes
#include "CMesh.h"
#include "vcObscuranceMap.h"

//progress bar
#include <wx/progdlg.h>

#define ROUND(x) (floor(x+0.5))

#ifndef M_PI
	#define M_PI        3.14159265358979323846
#endif

// DepthPeeling Layers.
#define MAX_LAYERS	12

// To use Offsets in the PBOs.
#define BUFFER_OFFSET(i) ((char *)NULL + (i))

//GLSL
// Handlers
GLuint vProjection,fProjection,pProjection;
GLuint vReflect, fReflect, pReflect;
GLuint vCopy, fCopy, pCopy;
GLuint vTransfer, fTransfer, pTransfer;
GLuint vNormalize, fNormalize, pNormalize;

//Uniform Parameters
//Projection Step
GLint TexturaDepthProjection;
GLint SizeProjection;
GLint FirstProjection;

//Reflectivity texture generation Step.

//Texture Copy Step.
GLint TextureCopy;
GLint Texture2Copy;

//Energy Transfer Step.
GLint TexturaReflectTransfer;
GLint DirectionTransfer;
GLint DmaxTransfer;

//Lightmap Normalization Step.
GLint TexturaNormalize;

// Global variables
CVert Vertex, Direccio, Increment, Primer, Ultim, Origin;	

static GLuint texName[3];

static int ResX;		//Resolution
static int ResY;
static int Res2X;		//Resolution
static int Res2Y;		//Resolution


//RenderTexture *ob=NULL;								// RenderTexture for the Obscurances.

static GLuint texProjeccions[2]; //Texture name
static GLuint texTransfer[1];
static GLuint texReflect[1];
static GLuint texCopy[1];
static GLuint texNormalize[1];
static GLuint fb1; // Framebuffer Reflectivity
static GLuint fb2; // Framebuffer Projeccions
static GLuint fb3; // Framebuffer Transfer
static GLuint fb4; // Framebuffer Copy
static GLuint fb5; // Lightmap Normalization



GLenum glerror;

GLfloat *m_pTextureImage;// Texture of diferent colors.
GLfloat *m_pTextureReflect; //Texture of reflectivitat.
GLfloat *m_pBlau;
GLfloat *m_pNegre;
int obs_global_cancelar;

CMesh	g_pMesh;						// Mesh Data
static CSphere Esfera;

static GLuint	ProjectionsPBO[MAX_LAYERS+2];	// PBOs to store the projections.
static GLuint	ObscurancesPBO;					// PBOs to store the projections.
static GLuint	ztex;								//Texture with the depth.


// Function to use when the window is resized
void changeSize(int w, int h) 
{

	if(h == 0)
		h = 1;

	float ratio = 1.0 * (float)w / (float)h;

	//Camera Set up
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluOrtho2D(-w,w,-h,h);

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	glViewport(0, 0, w, h);

}


// Returns a random point in the surface of the sphere
CVert ranpoint(float r, CVert c)
{
	double ale1, ale2;
	CVert p;
	float alfa,beta;

	ale1= (float)rand()/(float)RAND_MAX; 
	ale2= (float)rand()/(float)RAND_MAX;
 
    alfa=1.0-2.0*ale1;	/* real between -1 and 1 */
    alfa=acos(alfa);	/* angle between 0 and PI */

    beta=2*M_PI*ale2;	/* angle between 0 and 2*PI */
   
    p.x=c.x+r*sin(alfa)*cos(beta);
    p.y=c.y+r*sin(alfa)*sin(beta);
    p.z=c.z+r*cos(alfa);
   
    return p;
}

// Function to find a point in the sphere in the direction that goes from the point in the surface of the sphere
// to the center of the sphere. First it gets the random point in the surface.
void BuscarDireccio()
{
	Esfera.center.x = 0.0;
	Esfera.center.y = 0.0;
	Esfera.center.z = 0.0;
	Esfera.radius = sqrt(12.0)/2.0;

	Primer = ranpoint(Esfera.radius,Esfera.center);
	Vertex.x = Primer.x + (Esfera.center.x-Primer.x) * ((float)rand()/(float)RAND_MAX)*2.0;
	Vertex.y = Primer.y + (Esfera.center.y-Primer.y) * ((float)rand()/(float)RAND_MAX)*2.0;
	Vertex.z = Primer.z + (Esfera.center.z-Primer.z) * ((float)rand()/(float)RAND_MAX)*2.0;
}

// Function that renders the depth peeling geometry planes and stores them in PBOs.
void RenderProjeccions(void)
{
		glUseProgram(pProjection);
		glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb2);

		int i, j, e;
		changeSize(ResX, ResY);
		glClearColor(0.0,0.0,1.0,1.0);
		glClearDepth(1.0);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		glEnable (GL_DEPTH_TEST);									// Enable Depth Testing
		glDepthFunc(GL_LESS);

		glDisable(GL_CULL_FACE);

		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		glOrtho(-Esfera.radius,Esfera.radius,-Esfera.radius,Esfera.radius,0,Esfera.radius * 2.0);	

		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();
		gluLookAt(Primer.x,Primer.y,Primer.z, 
			      Esfera.center.x,Esfera.center.y,Esfera.center.z,
				  0.0f,1.0f,0.0f);

		glViewport(0,0,ResX,ResY);

		glUniform1f(SizeProjection, (float)ResX);
		glUniform1f(FirstProjection, 1.0);

		// Enable Pointers
		glEnableClientState( GL_VERTEX_ARRAY );						// Enable Vertex Arrays
		glEnableClientState( GL_TEXTURE_COORD_ARRAY );				// Enable Texture Coord Arrays
		glEnableClientState( GL_NORMAL_ARRAY );				// Enable Texture Coord Arrays

		for(i=0; i<g_pMesh.m_pObject._numGeos;i++)
		{
			for(j=0; j<g_pMesh.m_pObject._geo[i]._numTriSets;j++)
			{
				// Set Pointers To Our Data
				glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOVertices );
				glVertexPointer( 3, GL_FLOAT, 0, (char *) NULL );		// Set The Vertex Pointer To The Vertex Buffer
				glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOTexCoords );
				glTexCoordPointer( 2, GL_FLOAT, 0, (char *) NULL );		// Set The TexCoord Pointer To The TexCoord Buffer
				glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBONormals );
				glNormalPointer( GL_FLOAT, 0, (char *) NULL );		// Set The TexCoord Pointer To The TexCoord Buffer
				glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOIndexs );

				// Render
				glDrawElements( GL_TRIANGLES, g_pMesh.m_pObject._geo[i]._triSet[j]._numTris*3,GL_UNSIGNED_INT,BUFFER_OFFSET(0) );	// Draw All Of The Quads At Once

			}
		}

		//Copy the color buffer to PBO.
		glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, ProjectionsPBO[1] );			// Bind The Buffer
		glReadPixels(0, 0, ResX, ResY, GL_RGBA, GL_FLOAT, BUFFER_OFFSET(0));
		glBindBufferARB(GL_PIXEL_PACK_BUFFER_EXT, 0);

		//Render the following layers.
		glUniform1f(FirstProjection, 0.0);

		e = 1;

		for(e = 1; e < MAX_LAYERS; e++)
		{
			glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, ProjectionsPBO[e] );			// Bind The Buffer
			glBindTexture(GL_TEXTURE_2D,texName[0]);
			glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, ResX, ResY);
			glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, 0 );			// Bind The Buffer
			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

			glActiveTexture(GL_TEXTURE0);
			glBindTexture(GL_TEXTURE_2D, texName[0]);
			glUniform1i(TexturaDepthProjection, 0);

			for(i=0; i<g_pMesh.m_pObject._numGeos;i++)
			{
				for(j=0; j<g_pMesh.m_pObject._geo[i]._numTriSets;j++)
				{
					// Set Pointers To Our Data
					glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOVertices );
					glVertexPointer( 3, GL_FLOAT, 0, (char *) NULL );		// Set The Vertex Pointer To The Vertex Buffer
					glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOTexCoords );
					glTexCoordPointer( 2, GL_FLOAT, 0, (char *) NULL );		// Set The TexCoord Pointer To The TexCoord Buffer
					glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBONormals );
					glNormalPointer( GL_FLOAT, 0, (char *) NULL );		// Set The TexCoord Pointer To The TexCoord Buffer
					glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOIndexs );

					glDrawElements( GL_TRIANGLES, g_pMesh.m_pObject._geo[i]._triSet[j]._numTris*3,GL_UNSIGNED_INT,BUFFER_OFFSET(0) );	// Draw All Of The Quads At Once
				}				
			}

			glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, ProjectionsPBO[e+1] );			// Bind The Buffer
			glReadPixels(0, 0, ResX, ResY, GL_RGBA, GL_FLOAT, BUFFER_OFFSET(0));
			glBindBufferARB(GL_PIXEL_PACK_BUFFER_EXT, 0);
		}

		glDisableClientState( GL_VERTEX_ARRAY );					// Disable Vertex Arrays
		glDisableClientState( GL_TEXTURE_COORD_ARRAY );				// Disable Texture Coord Arrays
		glDisableClientState( GL_NORMAL_ARRAY );				// Disable Texture Coord Arrays

		glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
		glUseProgram(0);
}

// Function that calculates the lightmap using the neighbouring projections.
void RenderTransfer(void)
{
	glUseProgram(pTransfer);
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb3);

		glBlendFunc(GL_ONE, GL_ONE);

		glEnable(GL_BLEND);

		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		gluOrtho2D(-1,1,-1,1);

		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();
		glPointSize(1.0);

		glViewport(0, 0, Res2X, Res2Y);

		glUniform1f(DmaxTransfer, (GLfloat)0.3);
		glUniform1f(DirectionTransfer, 0.0);
		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, texReflect[0]);
		glUniform1i(TexturaReflectTransfer, 0);
		
		//First Render
		glEnableClientState( GL_VERTEX_ARRAY );						// Enable Vertex Arrays
		glUniform1f(DirectionTransfer, 1.0);
		glBindBufferARB( GL_ARRAY_BUFFER_ARB, ProjectionsPBO[1] );
		glVertexPointer( 4, GL_FLOAT, 0, (char *) NULL );		// Set The Vertex Pointer To The Vertex Buffer

		glEnableClientState( GL_TEXTURE_COORD_ARRAY );				// Enable Texture Coord Arrays
		glBindBufferARB( GL_ARRAY_BUFFER_ARB, ProjectionsPBO[0] );
		glTexCoordPointer( 4, GL_FLOAT, 0, (char *) NULL );		// Set The TexCoord Pointer To The TexCoord Buffer

		glDrawArrays(GL_POINTS, 0, ResX*ResY );
		
		for(int e=0;e<MAX_LAYERS-1;e++)
		{
			glUniform1f(DirectionTransfer, 0.0);

			glBindBufferARB( GL_ARRAY_BUFFER_ARB, ProjectionsPBO[e+1] );
			glVertexPointer( 4, GL_FLOAT, 0, (char *) NULL );		// Set The Vertex Pointer To The Vertex Buffer

			glBindBufferARB( GL_ARRAY_BUFFER_ARB, ProjectionsPBO[e+2] );
			glTexCoordPointer( 4, GL_FLOAT, 0, (char *) NULL );		// Set The TexCoord Pointer To The TexCoord Buffer

			glDrawArrays(GL_POINTS, 0, ResX*ResY );

			glUniform1f(DirectionTransfer, 1.0);

			glBindBufferARB( GL_ARRAY_BUFFER_ARB, ProjectionsPBO[e+2] );
			glVertexPointer( 4, GL_FLOAT, 0, (char *) NULL );		// Set The Vertex Pointer To The Vertex Buffer

			glBindBufferARB( GL_ARRAY_BUFFER_ARB, ProjectionsPBO[e+1] );
			glTexCoordPointer( 4, GL_FLOAT, 0, (char *) NULL );		// Set The TexCoord Pointer To The TexCoord Buffer

			glDrawArrays(GL_POINTS, 0, ResX*ResY );
		}

		glUniform1f(DirectionTransfer, 0.0);
		glEnableClientState( GL_VERTEX_ARRAY );						// Enable Vertex Arrays
		glBindBufferARB( GL_ARRAY_BUFFER_ARB, ProjectionsPBO[MAX_LAYERS] );
		glVertexPointer( 4, GL_FLOAT, 0, (char *) NULL );		// Set The Vertex Pointer To The Vertex Buffer

		glEnableClientState( GL_TEXTURE_COORD_ARRAY );				// Enable Texture Coord Arrays
		glBindBufferARB( GL_ARRAY_BUFFER_ARB, ProjectionsPBO[MAX_LAYERS+1] );
		glTexCoordPointer( 4, GL_FLOAT, 0, (char *) NULL );		// Set The TexCoord Pointer To The TexCoord Buffer

		glDrawArrays(GL_POINTS, 0, ResX*ResY );


		glDisableClientState( GL_VERTEX_ARRAY );					// Disable Vertex Arrays
		glDisableClientState( GL_TEXTURE_COORD_ARRAY );				// Disable Texture Coord Arrays

		glDisable(GL_BLEND);
	glUseProgram(0);

	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

}

// Function that copies the 16-bit fp RGBA buffer of the lightmap to a 32-bit RGBA fb buffer.
void CopyTexture(void)
{
	glUseProgram(pCopy);
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb4);
		void *texturePBO;
	
		glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, ObscurancesPBO );			// Bind The Buffer
		texturePBO = glMapBuffer(GL_PIXEL_PACK_BUFFER_EXT, GL_READ_ONLY);
		glBindTexture(GL_TEXTURE_2D,texName[1]);
		glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, Res2X, Res2Y, GL_RGBA, GL_FLOAT, texturePBO);
		glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB);
		glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, 0 );			// Bind The Buffer

		glEnable(GL_CULL_FACE);

		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		gluOrtho2D(-Res2X,Res2Y,-Res2X,Res2Y);

		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();

		glViewport(0, 0, Res2X, Res2Y);

		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, texTransfer[0]);
		glUniform1i(TextureCopy, 0);
		glActiveTexture(GL_TEXTURE1);
		glBindTexture(GL_TEXTURE_2D, texName[1]);
		glUniform1i(Texture2Copy, 1);
		glActiveTexture(GL_TEXTURE0);


		//Draw the geometry. 
		glBegin(GL_QUADS);
		{
			glTexCoord2f(0,      0);       glVertex3f(-Res2X, -Res2Y, -0.5f);
			glTexCoord2f(1,0);       glVertex3f(Res2X, -Res2Y, -0.5f);
			glTexCoord2f(1,1); glVertex3f(Res2X, Res2Y, -0.5f);
			glTexCoord2f(0,      1); glVertex3f(-Res2X, Res2Y, -0.5f);
		}
		glEnd();

		//Copy Buffer to PBO.
		glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT,ObscurancesPBO );			// Bind The Buffer
		glReadPixels(0, 0, Res2X, Res2Y, GL_RGBA, GL_FLOAT, BUFFER_OFFSET(0));
		glBindBufferARB(GL_PIXEL_PACK_BUFFER_EXT, 0);

		glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb3);
		glClearColor(0.0,0.0,0.0,0.0);
		glClear(GL_COLOR_BUFFER_BIT);

	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
	glUseProgram(0);
}

// Function that calculates the reflectivity map from the scene data.
void RenderReflect(void)
{
	glUseProgram(pReflect);
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb1);

		int i, j;

		glClearColor(0.0,0.0,0.0,0.0);
		glClear(GL_COLOR_BUFFER_BIT);

		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		gluOrtho2D(0,1,0,1);

		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();

		glViewport(0, 0, Res2X, Res2Y);

		// Enable Pointers
		glEnableClientState( GL_VERTEX_ARRAY );						// Enable Vertex Arrays
		glEnableClientState( GL_COLOR_ARRAY );				// Enable Texture Coord Arrays

		for(i=0; i<g_pMesh.m_pObject._numGeos;i++)
		{
			for(j=0; j<g_pMesh.m_pObject._geo[i]._numTriSets;j++)
			{
				// Set Pointers To Our Data
				glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOTexCoords );
				glVertexPointer( 2, GL_FLOAT, 0, (char *) NULL );		// Set The Vertex Pointer To The Vertex Buffer
				glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOColors );
				glColorPointer( 3, GL_FLOAT, 0, (char *) NULL );		// Set The TexCoord Pointer To The TexCoord Buffer
				glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOIndexs );

				// Render
				glDrawElements( GL_TRIANGLES, g_pMesh.m_pObject._geo[i]._triSet[j]._numTris*3,GL_UNSIGNED_INT,BUFFER_OFFSET(0) );	// Draw All Of The Quads At Once

			}
		}

		glDisableClientState( GL_VERTEX_ARRAY );			// Enable Vertex Arrays
		glDisableClientState( GL_COLOR_ARRAY );				// Enable Texture Coord Arrays

	glUseProgram(0);
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
}

// Function that copies the 16-bit fp RGBA buffer of the lightmap to a 32-bit RGBA fb buffer.
void NormalizeLightmap(void)
{
	glUseProgram(pNormalize);
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb5);

		glEnable(GL_CULL_FACE);

		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		gluOrtho2D(-Res2X,Res2Y,-Res2X,Res2Y);

		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();

		glViewport(0, 0, Res2X, Res2Y);

		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, texCopy[0]);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glUniform1i(TextureCopy, 0);

		//Draw the geometry. 
		glBegin(GL_QUADS);
		{
			glTexCoord2f(0,      0);       glVertex3f(-Res2X, -Res2Y, -0.5f);
			glTexCoord2f(1,0);       glVertex3f(Res2X, -Res2Y, -0.5f);
			glTexCoord2f(1,1); glVertex3f(Res2X, Res2Y, -0.5f);
			glTexCoord2f(0,      1); glVertex3f(-Res2X, Res2Y, -0.5f);
		}
		glEnd();

	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
	glUseProgram(0);
}

// Function that updates the lightmap. 
// The number of directions used to calculate the lightmap is iterations * steps
void UpdateTexture(int iterations, int steps)
{
	const int range = ((steps * 100) / steps) + ((iterations) * 100)/(steps * iterations);

	//progress bar
	wxProgressDialog dialog(wxT("Calculating GPUObscurances"),
							wxT("Progress..."),
							range,		//range
							0,		//parent
							wxPD_APP_MODAL|wxPD_AUTO_HIDE|
							wxPD_ELAPSED_TIME|wxPD_ESTIMATED_TIME|wxPD_REMAINING_TIME|wxPD_CAN_ABORT);

	bool cont = true;
	
	printf("\nIteracions: %d => Steps: %d\n", iterations, steps);
	for(int i = 0; (i < steps) && cont; i++)
	{
		for(int j = 0; (j < iterations) && cont; j++)
		{
			cont = dialog.Update(i*100/steps + j*100/(steps*iterations));
			BuscarDireccio();				// Find a random direction
			RenderProjeccions();
			RenderTransfer();
		}
		CopyTexture();
	}
	printf("\r100%% Done!!!!");
	NormalizeLightmap();
}

// Function that generates the VBOs with the geometric data of the scene.
// It also initializes the constant textures used.
void InitGeometry(void)
{
	int i, j;
	m_pBlau = new float[ResX * ResY * 4];
	//Initialize a blue buffer.
	for(i = 0; i<ResX; i++)
	{
		for(j = 0; j<ResY; j++)
		{
			m_pBlau[4 * (i * ResY + j)] = 0.0;
			m_pBlau[4 * (i * ResY + j) + 1] = 0.0;
			m_pBlau[4 * (i * ResY + j) + 2] = 1.0;
			m_pBlau[4 * (i * ResY + j) + 3] = 1.0;
		}
	}

	//Initialize a black buffer
	for(i = 0; i<Res2X; i++)
	{
		for(j = 0; j<Res2Y; j++)
		{
			m_pNegre[4*(i*Res2Y+j)] = 0.0;
			m_pNegre[4*(i*Res2Y+j)+1] = 0.0;
			m_pNegre[4*(i*Res2Y+j)+2] = 0.0;
			m_pNegre[4*(i*Res2Y+j)+3] = 0.0;
		}
	}

	for(i = 0; i<g_pMesh.m_pObject._numGeos;i++)
	{
		for(j = 0; j<g_pMesh.m_pObject._geo[i]._numTriSets;j++)
		{
			//Aqui creeem els VBOs.

			g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOIndexs = 0;
			// Generate And Bind The Index Buffer
			glGenBuffersARB( 1,  (unsigned int *)&g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOIndexs );					// Get A Valid Name
			glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOIndexs );			// Bind The Buffer
			// Load The Data
			glBufferDataARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j]._numTris * 3 * sizeof(int), g_pMesh.m_pObject._geo[i]._triSet[j]._index, GL_STATIC_DRAW_ARB );

			g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOVertices = 0;
			// Generate And Bind The Vertex Buffer
			glGenBuffersARB( 1, &g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOVertices );			// Get A Valid Name
			glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOVertices );			// Bind The Buffer
			// Load The Data
			glBufferDataARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j]._numVer * 3 * sizeof(float), g_pMesh.m_pObject._geo[i]._triSet[j]._ver, GL_STATIC_DRAW_ARB );

			g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBONormals = 0;
			// Generate And Bind The Normal Buffer
			glGenBuffersARB( 1, &g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBONormals );			// Get A Valid Name
			glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBONormals );			// Bind The Buffer
			// Load The Data
			glBufferDataARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j]._numVer * 3 * sizeof(float), g_pMesh.m_pObject._geo[i]._triSet[j]._nor, GL_STATIC_DRAW_ARB );

			g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOTexCoords = 0;
			// Generate And Bind The TexCoord Buffer
			glGenBuffersARB( 1, &g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOTexCoords );			// Get A Valid Name
			glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOTexCoords );			// Bind The Buffer
			// Load The Data
			glBufferDataARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j]._numVer * 2 * sizeof(float), g_pMesh.m_pObject._geo[i]._triSet[j]._tex, GL_STATIC_DRAW_ARB );

			g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOColors = 0;
			// Generate And Bind The Color Buffer
			glGenBuffersARB( 1, &g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOColors );			// Get A Valid Name
			glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOColors );			// Bind The Buffer
			// Load The Data
																										//*12
			glBufferDataARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j]._numVer * 3 * sizeof(float), g_pMesh.m_pObject._geo[i]._triSet[j]._refl, GL_STATIC_DRAW_ARB );
		}
	}	
	glBindBufferARB( GL_ARRAY_BUFFER_ARB, 0 );			// Bind The Buffer
}

// Functions that initializes the RenderTextures, the shaders and so on...
void init2(char *argv)
{	
	g_pMesh.LoadMesh(argv);

	m_pTextureImage = new float[Res2X*Res2Y*4];// Texture of diferent colors.
	m_pTextureReflect = new float[Res2X*Res2Y*4]; //Texture of reflectivitat.
	m_pNegre = new float[Res2X*Res2Y*4];

	//Create Textures.
	glGenTextures(3, &texName[0]);					// Create The Textures

	InitGeometry();

	//Texture
	// Binding
	glBindTexture( GL_TEXTURE_2D, texName[0] );
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA_FLOAT32_ATI, ResX, ResY, 0, GL_RGBA, GL_FLOAT, NULL);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

	//Texture
	// Binding
	glBindTexture( GL_TEXTURE_2D, texName[1] );
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA_FLOAT32_ATI, Res2X, Res2Y, 0, GL_RGBA, GL_FLOAT, NULL);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);


	//Texture
	// Binding
	glBindTexture( GL_TEXTURE_2D, texName[2] );
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA_FLOAT32_ATI, Res2X, Res2Y, 0, GL_RGBA, GL_FLOAT, m_pTextureReflect);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

	//FBOs
	glGenFramebuffersEXT(1, &fb1);
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb1);

	glGenTextures(1,&texReflect[0]);

	glBindTexture( GL_TEXTURE_2D, texReflect[0] );
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA_FLOAT32_ATI, Res2X, Res2Y, 0, GL_RGBA, GL_FLOAT, 0);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texReflect[0],0);
	glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0);

	glGenFramebuffersEXT(1, &fb2);
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb2);

	glGenTextures(1,&texProjeccions[0]);

	glBindTexture( GL_TEXTURE_2D, texProjeccions[0] );
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA_FLOAT32_ATI, ResX, ResY, 0, GL_RGBA, GL_FLOAT, 0);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texProjeccions[0],0);

	glGenRenderbuffersEXT(1, &texProjeccions[1]);
	glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, texProjeccions[1]);
	glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, ResX, ResY );
	glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, texProjeccions[1]);

	glGenFramebuffersEXT(1, &fb3);
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb3);

	glGenTextures(1,&texTransfer[0]);

	glBindTexture( GL_TEXTURE_2D, texTransfer[0] );
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA_FLOAT16_ATI, Res2X, Res2Y, 0, GL_RGBA, GL_FLOAT, 0);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texTransfer[0],0);
	glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0);

	glClearColor(0.0,0.0,0.0,0.0);
	glClear(GL_COLOR_BUFFER_BIT);

	glGenFramebuffersEXT(1, &fb4);
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb4);

	glGenTextures(1,&texCopy[0]);

	glBindTexture( GL_TEXTURE_2D, texCopy[0] );
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA_FLOAT32_ATI, Res2X, Res2Y, 0, GL_RGBA, GL_FLOAT, 0);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texCopy[0],0);
	glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0);

	glGenFramebuffersEXT(1, &fb5);
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb5);

	glGenTextures(1,&texNormalize[0]);

	glBindTexture( GL_TEXTURE_2D, texNormalize[0] );
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA_FLOAT32_ATI, Res2X, Res2Y, 0, GL_RGBA, GL_FLOAT, 0);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texNormalize[0],0);
	glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0);

	//Create PBO
	glGenBuffersARB( MAX_LAYERS+2, &ProjectionsPBO[0] );
		glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, ProjectionsPBO[0] );			// Bind The Buffer
		glBufferDataARB( GL_PIXEL_PACK_BUFFER_EXT, ResX*ResY*4*sizeof(float), m_pBlau, GL_STREAM_COPY );
		glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, ProjectionsPBO[MAX_LAYERS+1] );			// Bind The Buffer
		glBufferDataARB( GL_PIXEL_PACK_BUFFER_EXT, ResX*ResY*4*sizeof(float), m_pBlau, GL_STREAM_COPY );
	for (int e = 1; e < MAX_LAYERS+1; e++ )
	{
		glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, ProjectionsPBO[e] );			// Bind The Buffer
		glBufferDataARB( GL_PIXEL_PACK_BUFFER_EXT, ResX*ResY*4*sizeof(float), NULL, GL_STREAM_COPY );
	}

	glGenBuffersARB( 1, &ObscurancesPBO );
		glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, ObscurancesPBO );			// Bind The Buffer
		glBufferDataARB( GL_PIXEL_PACK_BUFFER_EXT, Res2X*Res2Y*4*sizeof(float), m_pNegre, GL_STREAM_COPY );
	glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, 0 );			// Bind The Buffer

	//GLSL
	//Projection Shaders
	
	vProjection = glCreateShader(GL_VERTEX_SHADER);
	fProjection = glCreateShader(GL_FRAGMENT_SHADER);

	static const char *vvProjection =
	"																				\n"
	"	varying float cosine;														\n"
	"	varying vec2 texCoord;														\n"
	"																				\n"
	"	void main()																	\n"
	"	{																			\n"
	"		gl_Position = ftransform();												\n"
	"		texCoord = gl_MultiTexCoord0.st;										\n"
	"																				\n"
	"		cosine = (gl_ModelViewMatrixInverseTranspose * vec4(gl_Normal,1.0)).z;	\n"
	"	}																			\n"
	"																				\n";

	static const char *ffProjection =
	"																				\n"
	"	uniform float res;															\n"
	"	uniform float first;														\n"	
	"	uniform sampler2D ztex;														\n"
	"																				\n"
	"	varying float cosine;														\n"
	"	varying vec2 texCoord;														\n"
	"																				\n"
	"	void main()																	\n"
	"	{																			\n"
	"		if( first == 0.0)														\n"
	"		{																		\n"
	"			float depth = tex2D(ztex,gl_FragCoord.xy/res).a;					\n"
	"			if (gl_FragCoord.z < (depth + 0.000001)) discard;					\n"
	"		}																		\n"
	"		gl_FragColor.rg = texCoord+0.5/512.0;									\n"
	"		gl_FragColor.b = cosine;												\n"
	"		gl_FragColor.a = gl_FragCoord.z;										\n"
	"	}																			\n";


	glShaderSource(vProjection, 1, &vvProjection, NULL);
	glShaderSource(fProjection, 1, &ffProjection, NULL);

	glCompileShader(vProjection);
	glCompileShader(fProjection);

	pProjection = glCreateProgram();
	glAttachShader(pProjection, vProjection);
	glAttachShader(pProjection, fProjection);

	glLinkProgram(pProjection);

	glUseProgram(pProjection);
	TexturaDepthProjection = glGetUniformLocation(pProjection, "ztex");
	SizeProjection = glGetUniformLocation(pProjection, "res");
	FirstProjection = glGetUniformLocation(pProjection, "first");

	glUseProgram(0);


	//Reflect Shaders
	
	vReflect = glCreateShader(GL_VERTEX_SHADER);
	fReflect = glCreateShader(GL_FRAGMENT_SHADER);

	static const char *vvReflect =
	"																\n"
	"	varying vec4 color;											\n"
	"																\n"
	"	void main()													\n"
	"	{															\n"
	"		vec4 posicio = vec4(gl_Vertex.xy, -0.5, 1.0);			\n"
	"		gl_Position = gl_ModelViewProjectionMatrix * posicio;	\n"
	"																\n"
	"		color = vec4(gl_Color.xyz,1.0);							\n"
	"	}															\n";

	static const char *ffReflect =
	"								\n"
	"	varying vec4 color;			\n"
	"								\n"
	"	void main()					\n"
	"	{							\n"
	"		gl_FragColor = color;	\n"
	"	}							\n"
	"								\n";

	glShaderSource(vReflect, 1, &vvReflect, NULL);
	glShaderSource(fReflect, 1, &ffReflect, NULL);

	glCompileShader(vReflect);
	glCompileShader(fReflect);

	pReflect = glCreateProgram();
	glAttachShader(pReflect, vReflect);
	glAttachShader(pReflect, fReflect);

	glLinkProgram(pReflect);

	glUseProgram(0);

	//Texture Copy Shaders
	
	vCopy = glCreateShader(GL_VERTEX_SHADER);
	fCopy = glCreateShader(GL_FRAGMENT_SHADER);

	static const char *vvCopy =
	"																\n"
	"	varying vec2 texCoord;										\n"
	"																\n"
	"	void main()													\n"
	"	{															\n"
	"		vec4 posicio = vec4(gl_Vertex.xyz, 1.0);				\n"
	"		gl_Position = gl_ModelViewProjectionMatrix * posicio;	\n"
	"																\n"
	"		texCoord = gl_MultiTexCoord0.st;						\n"
	"	}															\n";

	static const char *ffCopy =
	"																			\n"
	"	uniform sampler2D texture;												\n"
	"	uniform sampler2D texture2;												\n"
	"																			\n"
	"	varying vec2 texCoord;													\n"
	"																			\n"
	"	void main()																\n"
	"	{																		\n"
	"		gl_FragColor = tex2D(texture,texCoord) + tex2D(texture2,texCoord);	\n"
	"	}																		\n";

	glShaderSource(vCopy, 1, &vvCopy, NULL);
	glShaderSource(fCopy, 1, &ffCopy, NULL);

	glCompileShader(vCopy);
	glCompileShader(fCopy);

	pCopy = glCreateProgram();
	glAttachShader(pCopy, vCopy);
	glAttachShader(pCopy, fCopy);

	glLinkProgram(pCopy);

	glUseProgram(pCopy);
	TextureCopy = glGetUniformLocation(pCopy, "texture");
	Texture2Copy = glGetUniformLocation(pCopy, "texture2");
	glUseProgram(0);

	//Lightmap Normalization Shaders
	
	vNormalize = glCreateShader(GL_VERTEX_SHADER);
	fNormalize = glCreateShader(GL_FRAGMENT_SHADER);

	static const char *vvNormalize =
	"																\n"
	"	varying vec2 texCoord;										\n"
	"																\n"
	"	void main()													\n"
	"	{															\n"
	"		vec4 posicio = vec4(gl_Vertex.xyz, 1.0);				\n"
	"		gl_Position = gl_ModelViewProjectionMatrix * posicio;	\n"
	"																\n"
	"		texCoord = gl_MultiTexCoord0.st;						\n"
	"	}															\n";

	static const char *ffNormalize =
	"																			\n"
	"	uniform sampler2D texture;												\n"
	"																			\n"
	"	varying vec2 texCoord;													\n"
	"																			\n"
	"	void main()																\n"
	"	{																		\n"
	"		float res = 256.0;													\n"
	"		float dif = 1.0/res;												\n"
	"		vec4 aux1 = tex2D(texture,texCoord);								\n"
	"		vec4 aux2 = tex2D(texture,vec2(texCoord.r+dif,texCoord.g));			\n"
	"		vec4 aux3 = tex2D(texture,vec2(texCoord.r+dif,texCoord.g+dif));		\n"
	"		vec4 aux4 = tex2D(texture,vec2(texCoord.r,texCoord.g+dif));			\n"
	"		float counter = 0.0;												\n"
	"		vec4 aux = vec4(0.0,0.0,0.0,0.0);									\n"
	"		if(aux1.a>0.0)														\n"
	"		{																	\n"
	"			aux += vec4(aux1.rgb/aux1.a,1.0);								\n"
	"			counter += 1.0;													\n"
	"		}																	\n"
	"		if(aux2.a>0.0)														\n"
	"		{																	\n"
	"			aux += vec4(aux2.rgb/aux2.a,1.0);								\n"
	"			counter += 1.0;													\n"
	"		}																	\n"
	"		if(aux3.a>0.0)														\n"
	"		{																	\n"
	"			aux += vec4(aux3.rgb/aux3.a,1.0);								\n"
	"			counter += 1.0;													\n"
	"		}																	\n"
	"		if(aux4.a>0.0)														\n"
	"		{																	\n"
	"			aux += vec4(aux4.rgb/aux4.a,1.0);								\n"
	"			counter += 1.0;													\n"
	"		}																	\n"
	"		if(counter < 1.0) gl_FragColor = vec4(0.0,0.0,0.0,0.0);				\n"
	"		else																\n"
	"		{																	\n"
	"			aux /= counter;													\n"
	"			gl_FragColor = aux;												\n"
	"		}																	\n"
	"	}																		\n";

	glShaderSource(vNormalize, 1, &vvNormalize, NULL);
	glShaderSource(fNormalize, 1, &ffNormalize, NULL);

	glCompileShader(vNormalize);
	glCompileShader(fNormalize);

	pNormalize = glCreateProgram();
	glAttachShader(pNormalize, vNormalize);
	glAttachShader(pNormalize, fNormalize);

	glLinkProgram(pNormalize);

	glUseProgram(pNormalize);
	TexturaNormalize = glGetUniformLocation(pNormalize, "texture");
	glUseProgram(0);

	//Energy Transfer Shaders
	
	vTransfer = glCreateShader(GL_VERTEX_SHADER);
	fTransfer = glCreateShader(GL_FRAGMENT_SHADER);

	static const char *vvTransfer =
	"																															\n"
	"	uniform float direction;																								\n"
	"																															\n"
	"	varying vec2 p1;																										\n"
	"	varying vec2 p2;																										\n"
	"	varying float factor;																									\n"
	"																															\n"
	"	void main()																												\n"
	"	{																														\n"
	"		vec4 position = gl_Vertex;																							\n"
	"		vec4 texCoord = gl_MultiTexCoord0;																					\n"
	"		if(((direction == 0) && (position.b != 1.0) && (position.b < 0.0) && ((texCoord.b > 0.0) || (texCoord.b == 1)))		\n"
	"		|| ((direction == 1) && (position.b != 1.0) && (position.b > 0.0) && ((texCoord.b < 0.0) || (texCoord.b == 1))))	\n"
	"		{																													\n"
	"																															\n"
	"			p1 = vec2(position.r, position.g);																				\n"
	"																															\n"
	"			p2 = vec2(texCoord.r, texCoord.g);																				\n"
	"																															\n"
	"			gl_Position = vec4((p1 * 2.0) - vec2(1.0,1.0), 0.0,1.0);														\n"
	"																															\n"
	"			if (texCoord.b == 1) factor = 1;																				\n"
	"			else factor = abs(texCoord.a - position.a);																		\n"
	"		}																													\n"
	"		else																												\n"
	"		{																													\n"
	"			gl_Position = vec4( 0.0,0.0, 2.0, 1.0 );																		\n"
	"			p1 = p2 = vec2(1.0,1.0);																						\n"
	"			factor = 0.5;																									\n"
	"		}																													\n"
	"	}																														\n";

	static const char *ffTransfer =
	"																				\n"
	"	uniform sampler2D reflectivity;												\n"
	"	uniform float dmax;															\n"
	"																				\n"
	"	varying vec2 p1;															\n"
	"	varying vec2 p2;															\n"
	"	varying float factor;														\n"
	"																				\n"
	"	void main()																	\n"
	"	{																			\n"
	"		if(factor>=dmax) gl_FragColor.rgb = vec3(0.5,0.5,0.5);					\n"
	"		else gl_FragColor.rgb = tex2D(reflectivity,p2).rgb * sqrt(factor/dmax);	\n"
	"		gl_FragColor.a = 1.0;													\n"
	"	}																			\n";

	glShaderSource(vTransfer, 1, &vvTransfer, NULL);
	glShaderSource(fTransfer, 1, &ffTransfer, NULL);

	glCompileShader(vTransfer);
	glCompileShader(fTransfer);

	pTransfer = glCreateProgram();
	glAttachShader(pTransfer, vTransfer);
	glAttachShader(pTransfer, fTransfer);

	glLinkProgram(pTransfer);

	glUseProgram(pTransfer);
	TexturaReflectTransfer = glGetUniformLocation(pTransfer, "reflectivity");
	DirectionTransfer = glGetUniformLocation(pTransfer, "direction");
	DmaxTransfer = glGetUniformLocation(pTransfer, "dmax");

	glUseProgram(0);

	// Setup GL States
	glEnable (GL_DEPTH_TEST);									// Enable Depth Testing

	//Generate the reflectivity texture.
	RenderReflect();

	UpdateTexture(60,3);	

}

// Function that interfaces with the VisualCAD.
int vcObscurerGenerateImage(CMesh &geom, char *argv, int quality, int *imgUsize, int *imgVsize, float **imgRgbBuffer)
{
//	float divisor;
	int *DadesTemp = new int[4];
	float	*dadesf=NULL;
	int		*dadesi=NULL;
	int qual;
	float aux[4];
	float a;


	glutCreateWindow("T");
	
	glerror = glewInit();

	FILE *file = NULL;

	file = fopen("tmp.txt", "w");

	if (glerror != GLEW_OK) fprintf(file, "\nError initializing glew library, %s", glewGetErrorString(glerror));
	else fprintf(file, "\nTot Correcte!\n");

	fclose(file);

	memset(&aux, 0.0, 4);

	qual = quality;

	if (qual < 1) qual = 1;

	switch (qual)
	{
		case 1: *imgVsize = *imgUsize = 256;
			break;
		case 2: *imgVsize = *imgUsize = 512;
			break;
		case 3: *imgVsize = *imgUsize = 1024;
			break;
		case 4: *imgVsize = *imgUsize = 2048;
			break;
		default: printf("\nResolution not supported");
	};

	Res2X = *imgUsize;
	Res2Y = *imgVsize;

	ResX = Res2X * 2.0; 
	ResY = Res2Y * 2.0;

	if(ResX == 4096) ResX = 2048;
	if(ResY == 4096) ResY = 2048;

	printf("\nRes(Plans de projeccio): ResolucioX = %d , ResolucioY = %d", ResX, ResY);
	printf("\nRes2(Lightmap): ResolucioX = %d , ResolucioY = %d", Res2X, Res2Y);
	dadesf = new float[Res2X*Res2Y*4];
	dadesi = new int[Res2X*Res2Y*4];

	init2(argv);
 
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb5);
	glReadPixels(0,0,Res2X,Res2Y,GL_RGBA,GL_FLOAT,dadesf);
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

	*imgRgbBuffer = dadesf;

	geom = g_pMesh;

	return 0;

}