Context Navigation

source: GTP/trunk/Lib/Illum/GPUObscurancesGT/src/vcObscuranceMap.cpp @ 930

Revision 930, 38.4 KB checked in by igarcia, 19 years ago (diff)

Rev	Line
[930]	1	//========================================
	2	// Class to interface the VisualCAD specifications.
	3	// Nicolau Sunyer & Sergi Funtané (10/13/2005).
	4	// Universitat de Girona.
	5	//========================================
	6
	7	#pragma warning(disable:4244)
	8	// Includes
	9	#include "glew.h"
	10	#include <glut.h>
	11	#include "stdlib.h"
	12
	13	// Includes
	14	#include "CMesh.h"
	15	#include "vcObscuranceMap.h"
	16
	17	//progress bar
	18	#include <wx/progdlg.h>
	19
	20	#define ROUND(x) (floor(x+0.5))
	21
	22	#ifndef M_PI
	23	#define M_PI 3.14159265358979323846
	24	#endif
	25
	26	// DepthPeeling Layers.
	27	#define MAX_LAYERS 12
	28
	29	// To use Offsets in the PBOs.
	30	#define BUFFER_OFFSET(i) ((char *)NULL + (i))
	31
	32	//GLSL
	33	// Handlers
	34	GLuint vProjection,fProjection,pProjection;
	35	GLuint vReflect, fReflect, pReflect;
	36	GLuint vCopy, fCopy, pCopy;
	37	GLuint vTransfer, fTransfer, pTransfer;
	38	GLuint vNormalize, fNormalize, pNormalize;
	39
	40	//Uniform Parameters
	41	//Projection Step
	42	GLint TexturaDepthProjection;
	43	GLint SizeProjection;
	44	GLint FirstProjection;
	45
	46	//Reflectivity texture generation Step.
	47
	48	//Texture Copy Step.
	49	GLint TextureCopy;
	50	GLint Texture2Copy;
	51
	52	//Energy Transfer Step.
	53	GLint TexturaReflectTransfer;
	54	GLint DirectionTransfer;
	55	GLint DmaxTransfer;
	56
	57	//Lightmap Normalization Step.
	58	GLint TexturaNormalize;
	59
	60	// Global variables
	61	CVert Vertex, Direccio, Increment, Primer, Ultim, Origin;
	62
	63	static GLuint texName[3];
	64
	65	static int ResX; //Resolution
	66	static int ResY;
	67	static int Res2X; //Resolution
	68	static int Res2Y; //Resolution
	69
	70
	71	//RenderTexture *ob=NULL; // RenderTexture for the Obscurances.
	72
	73	static GLuint texProjeccions[2]; //Texture name
	74	static GLuint texTransfer[1];
	75	static GLuint texReflect[1];
	76	static GLuint texCopy[1];
	77	static GLuint texNormalize[1];
	78	static GLuint fb1; // Framebuffer Reflectivity
	79	static GLuint fb2; // Framebuffer Projeccions
	80	static GLuint fb3; // Framebuffer Transfer
	81	static GLuint fb4; // Framebuffer Copy
	82	static GLuint fb5; // Lightmap Normalization
	83
	84
	85
	86	GLenum glerror;
	87
	88	GLfloat *m_pTextureImage;// Texture of diferent colors.
	89	GLfloat *m_pTextureReflect; //Texture of reflectivitat.
	90	GLfloat *m_pBlau;
	91	GLfloat *m_pNegre;
	92	int obs_global_cancelar;
	93
	94	CMesh g_pMesh; // Mesh Data
	95	static CSphere Esfera;
	96
	97	static GLuint ProjectionsPBO[MAX_LAYERS+2]; // PBOs to store the projections.
	98	static GLuint ObscurancesPBO; // PBOs to store the projections.
	99	static GLuint ztex; //Texture with the depth.
	100
	101
	102	// Function to use when the window is resized
	103	void changeSize(int w, int h)
	104	{
	105
	106	if(h == 0)
	107	h = 1;
	108
	109	float ratio = 1.0 * (float)w / (float)h;
	110
	111	//Camera Set up
	112	glMatrixMode(GL_PROJECTION);
	113	glLoadIdentity();
	114	gluOrtho2D(-w,w,-h,h);
	115
	116	glMatrixMode(GL_MODELVIEW);
	117	glLoadIdentity();
	118
	119	glViewport(0, 0, w, h);
	120
	121	}
	122
	123
	124	// Returns a random point in the surface of the sphere
	125	CVert ranpoint(float r, CVert c)
	126	{
	127	double ale1, ale2;
	128	CVert p;
	129	float alfa,beta;
	130
	131	ale1= (float)rand()/(float)RAND_MAX;
	132	ale2= (float)rand()/(float)RAND_MAX;
	133
	134	alfa=1.0-2.0ale1; / real between -1 and 1 */
	135	alfa=acos(alfa); /* angle between 0 and PI */
	136
	137	beta=2M_PIale2; /* angle between 0 and 2PI /
	138
	139	p.x=c.x+rsin(alfa)cos(beta);
	140	p.y=c.y+rsin(alfa)sin(beta);
	141	p.z=c.z+r*cos(alfa);
	142
	143	return p;
	144	}
	145
	146	// Function to find a point in the sphere in the direction that goes from the point in the surface of the sphere
	147	// to the center of the sphere. First it gets the random point in the surface.
	148	void BuscarDireccio()
	149	{
	150	Esfera.center.x = 0.0;
	151	Esfera.center.y = 0.0;
	152	Esfera.center.z = 0.0;
	153	Esfera.radius = sqrt(12.0)/2.0;
	154
	155	Primer = ranpoint(Esfera.radius,Esfera.center);
	156	Vertex.x = Primer.x + (Esfera.center.x-Primer.x) * ((float)rand()/(float)RAND_MAX)*2.0;
	157	Vertex.y = Primer.y + (Esfera.center.y-Primer.y) * ((float)rand()/(float)RAND_MAX)*2.0;
	158	Vertex.z = Primer.z + (Esfera.center.z-Primer.z) * ((float)rand()/(float)RAND_MAX)*2.0;
	159	}
	160
	161	// Function that renders the depth peeling geometry planes and stores them in PBOs.
	162	void RenderProjeccions(void)
	163	{
	164	glUseProgram(pProjection);
	165	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb2);
	166
	167	int i, j, e;
	168	changeSize(ResX, ResY);
	169	glClearColor(0.0,0.0,1.0,1.0);
	170	glClearDepth(1.0);
	171	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
	172	glEnable (GL_DEPTH_TEST); // Enable Depth Testing
	173	glDepthFunc(GL_LESS);
	174
	175	glDisable(GL_CULL_FACE);
	176
	177	glMatrixMode(GL_PROJECTION);
	178	glLoadIdentity();
	179	glOrtho(-Esfera.radius,Esfera.radius,-Esfera.radius,Esfera.radius,0,Esfera.radius * 2.0);
	180
	181	glMatrixMode(GL_MODELVIEW);
	182	glLoadIdentity();
	183	gluLookAt(Primer.x,Primer.y,Primer.z,
	184	Esfera.center.x,Esfera.center.y,Esfera.center.z,
	185	0.0f,1.0f,0.0f);
	186
	187	glViewport(0,0,ResX,ResY);
	188
	189	glUniform1f(SizeProjection, (float)ResX);
	190	glUniform1f(FirstProjection, 1.0);
	191
	192	// Enable Pointers
	193	glEnableClientState( GL_VERTEX_ARRAY ); // Enable Vertex Arrays
	194	glEnableClientState( GL_TEXTURE_COORD_ARRAY ); // Enable Texture Coord Arrays
	195	glEnableClientState( GL_NORMAL_ARRAY ); // Enable Texture Coord Arrays
	196
	197	for(i=0; i<g_pMesh.m_pObject._numGeos;i++)
	198	{
	199	for(j=0; j<g_pMesh.m_pObject._geo[i]._numTriSets;j++)
	200	{
	201	// Set Pointers To Our Data
	202	glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOVertices );
	203	glVertexPointer( 3, GL_FLOAT, 0, (char *) NULL ); // Set The Vertex Pointer To The Vertex Buffer
	204	glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOTexCoords );
	205	glTexCoordPointer( 2, GL_FLOAT, 0, (char *) NULL ); // Set The TexCoord Pointer To The TexCoord Buffer
	206	glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBONormals );
	207	glNormalPointer( GL_FLOAT, 0, (char *) NULL ); // Set The TexCoord Pointer To The TexCoord Buffer
	208	glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOIndexs );
	209
	210	// Render
	211	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
	212
	213	}
	214	}
	215
	216	//Copy the color buffer to PBO.
	217	glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, ProjectionsPBO[1] ); // Bind The Buffer
	218	glReadPixels(0, 0, ResX, ResY, GL_RGBA, GL_FLOAT, BUFFER_OFFSET(0));
	219	glBindBufferARB(GL_PIXEL_PACK_BUFFER_EXT, 0);
	220
	221	//Render the following layers.
	222	glUniform1f(FirstProjection, 0.0);
	223
	224	e = 1;
	225
	226	for(e = 1; e < MAX_LAYERS; e++)
	227	{
	228	glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, ProjectionsPBO[e] ); // Bind The Buffer
	229	glBindTexture(GL_TEXTURE_2D,texName[0]);
	230	glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, ResX, ResY);
	231	glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, 0 ); // Bind The Buffer
	232	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
	233
	234	glActiveTexture(GL_TEXTURE0);
	235	glBindTexture(GL_TEXTURE_2D, texName[0]);
	236	glUniform1i(TexturaDepthProjection, 0);
	237
	238	for(i=0; i<g_pMesh.m_pObject._numGeos;i++)
	239	{
	240	for(j=0; j<g_pMesh.m_pObject._geo[i]._numTriSets;j++)
	241	{
	242	// Set Pointers To Our Data
	243	glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOVertices );
	244	glVertexPointer( 3, GL_FLOAT, 0, (char *) NULL ); // Set The Vertex Pointer To The Vertex Buffer
	245	glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOTexCoords );
	246	glTexCoordPointer( 2, GL_FLOAT, 0, (char *) NULL ); // Set The TexCoord Pointer To The TexCoord Buffer
	247	glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBONormals );
	248	glNormalPointer( GL_FLOAT, 0, (char *) NULL ); // Set The TexCoord Pointer To The TexCoord Buffer
	249	glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOIndexs );
	250
	251	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
	252	}
	253	}
	254
	255	glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, ProjectionsPBO[e+1] ); // Bind The Buffer
	256	glReadPixels(0, 0, ResX, ResY, GL_RGBA, GL_FLOAT, BUFFER_OFFSET(0));
	257	glBindBufferARB(GL_PIXEL_PACK_BUFFER_EXT, 0);
	258	}
	259
	260	glDisableClientState( GL_VERTEX_ARRAY ); // Disable Vertex Arrays
	261	glDisableClientState( GL_TEXTURE_COORD_ARRAY ); // Disable Texture Coord Arrays
	262	glDisableClientState( GL_NORMAL_ARRAY ); // Disable Texture Coord Arrays
	263
	264	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
	265	glUseProgram(0);
	266	}
	267
	268	// Function that calculates the lightmap using the neighbouring projections.
	269	void RenderTransfer(void)
	270	{
	271	glUseProgram(pTransfer);
	272	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb3);
	273
	274	glBlendFunc(GL_ONE, GL_ONE);
	275
	276	glEnable(GL_BLEND);
	277
	278	glMatrixMode(GL_PROJECTION);
	279	glLoadIdentity();
	280	gluOrtho2D(-1,1,-1,1);
	281
	282	glMatrixMode(GL_MODELVIEW);
	283	glLoadIdentity();
	284	glPointSize(1.0);
	285
	286	glViewport(0, 0, Res2X, Res2Y);
	287
	288	glUniform1f(DmaxTransfer, (GLfloat)0.3);
	289	glUniform1f(DirectionTransfer, 0.0);
	290	glActiveTexture(GL_TEXTURE0);
	291	glBindTexture(GL_TEXTURE_2D, texReflect[0]);
	292	glUniform1i(TexturaReflectTransfer, 0);
	293
	294	//First Render
	295	glEnableClientState( GL_VERTEX_ARRAY ); // Enable Vertex Arrays
	296	glUniform1f(DirectionTransfer, 1.0);
	297	glBindBufferARB( GL_ARRAY_BUFFER_ARB, ProjectionsPBO[1] );
	298	glVertexPointer( 4, GL_FLOAT, 0, (char *) NULL ); // Set The Vertex Pointer To The Vertex Buffer
	299
	300	glEnableClientState( GL_TEXTURE_COORD_ARRAY ); // Enable Texture Coord Arrays
	301	glBindBufferARB( GL_ARRAY_BUFFER_ARB, ProjectionsPBO[0] );
	302	glTexCoordPointer( 4, GL_FLOAT, 0, (char *) NULL ); // Set The TexCoord Pointer To The TexCoord Buffer
	303
	304	glDrawArrays(GL_POINTS, 0, ResX*ResY );
	305
	306	for(int e=0;e<MAX_LAYERS-1;e++)
	307	{
	308	glUniform1f(DirectionTransfer, 0.0);
	309
	310	glBindBufferARB( GL_ARRAY_BUFFER_ARB, ProjectionsPBO[e+1] );
	311	glVertexPointer( 4, GL_FLOAT, 0, (char *) NULL ); // Set The Vertex Pointer To The Vertex Buffer
	312
	313	glBindBufferARB( GL_ARRAY_BUFFER_ARB, ProjectionsPBO[e+2] );
	314	glTexCoordPointer( 4, GL_FLOAT, 0, (char *) NULL ); // Set The TexCoord Pointer To The TexCoord Buffer
	315
	316	glDrawArrays(GL_POINTS, 0, ResX*ResY );
	317
	318	glUniform1f(DirectionTransfer, 1.0);
	319
	320	glBindBufferARB( GL_ARRAY_BUFFER_ARB, ProjectionsPBO[e+2] );
	321	glVertexPointer( 4, GL_FLOAT, 0, (char *) NULL ); // Set The Vertex Pointer To The Vertex Buffer
	322
	323	glBindBufferARB( GL_ARRAY_BUFFER_ARB, ProjectionsPBO[e+1] );
	324	glTexCoordPointer( 4, GL_FLOAT, 0, (char *) NULL ); // Set The TexCoord Pointer To The TexCoord Buffer
	325
	326	glDrawArrays(GL_POINTS, 0, ResX*ResY );
	327	}
	328
	329	glUniform1f(DirectionTransfer, 0.0);
	330	glEnableClientState( GL_VERTEX_ARRAY ); // Enable Vertex Arrays
	331	glBindBufferARB( GL_ARRAY_BUFFER_ARB, ProjectionsPBO[MAX_LAYERS] );
	332	glVertexPointer( 4, GL_FLOAT, 0, (char *) NULL ); // Set The Vertex Pointer To The Vertex Buffer
	333
	334	glEnableClientState( GL_TEXTURE_COORD_ARRAY ); // Enable Texture Coord Arrays
	335	glBindBufferARB( GL_ARRAY_BUFFER_ARB, ProjectionsPBO[MAX_LAYERS+1] );
	336	glTexCoordPointer( 4, GL_FLOAT, 0, (char *) NULL ); // Set The TexCoord Pointer To The TexCoord Buffer
	337
	338	glDrawArrays(GL_POINTS, 0, ResX*ResY );
	339
	340
	341	glDisableClientState( GL_VERTEX_ARRAY ); // Disable Vertex Arrays
	342	glDisableClientState( GL_TEXTURE_COORD_ARRAY ); // Disable Texture Coord Arrays
	343
	344	glDisable(GL_BLEND);
	345	glUseProgram(0);
	346
	347	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
	348
	349	}
	350
	351	// Function that copies the 16-bit fp RGBA buffer of the lightmap to a 32-bit RGBA fb buffer.
	352	void CopyTexture(void)
	353	{
	354	glUseProgram(pCopy);
	355	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb4);
	356	void *texturePBO;
	357
	358	glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, ObscurancesPBO ); // Bind The Buffer
	359	texturePBO = glMapBuffer(GL_PIXEL_PACK_BUFFER_EXT, GL_READ_ONLY);
	360	glBindTexture(GL_TEXTURE_2D,texName[1]);
	361	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, Res2X, Res2Y, GL_RGBA, GL_FLOAT, texturePBO);
	362	glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB);
	363	glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, 0 ); // Bind The Buffer
	364
	365	glEnable(GL_CULL_FACE);
	366
	367	glMatrixMode(GL_PROJECTION);
	368	glLoadIdentity();
	369	gluOrtho2D(-Res2X,Res2Y,-Res2X,Res2Y);
	370
	371	glMatrixMode(GL_MODELVIEW);
	372	glLoadIdentity();
	373
	374	glViewport(0, 0, Res2X, Res2Y);
	375
	376	glActiveTexture(GL_TEXTURE0);
	377	glBindTexture(GL_TEXTURE_2D, texTransfer[0]);
	378	glUniform1i(TextureCopy, 0);
	379	glActiveTexture(GL_TEXTURE1);
	380	glBindTexture(GL_TEXTURE_2D, texName[1]);
	381	glUniform1i(Texture2Copy, 1);
	382	glActiveTexture(GL_TEXTURE0);
	383
	384
	385	//Draw the geometry.
	386	glBegin(GL_QUADS);
	387	{
	388	glTexCoord2f(0, 0); glVertex3f(-Res2X, -Res2Y, -0.5f);
	389	glTexCoord2f(1,0); glVertex3f(Res2X, -Res2Y, -0.5f);
	390	glTexCoord2f(1,1); glVertex3f(Res2X, Res2Y, -0.5f);
	391	glTexCoord2f(0, 1); glVertex3f(-Res2X, Res2Y, -0.5f);
	392	}
	393	glEnd();
	394
	395	//Copy Buffer to PBO.
	396	glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT,ObscurancesPBO ); // Bind The Buffer
	397	glReadPixels(0, 0, Res2X, Res2Y, GL_RGBA, GL_FLOAT, BUFFER_OFFSET(0));
	398	glBindBufferARB(GL_PIXEL_PACK_BUFFER_EXT, 0);
	399
	400	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb3);
	401	glClearColor(0.0,0.0,0.0,0.0);
	402	glClear(GL_COLOR_BUFFER_BIT);
	403
	404	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
	405	glUseProgram(0);
	406	}
	407
	408	// Function that calculates the reflectivity map from the scene data.
	409	void RenderReflect(void)
	410	{
	411	glUseProgram(pReflect);
	412	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb1);
	413
	414	int i, j;
	415
	416	glClearColor(0.0,0.0,0.0,0.0);
	417	glClear(GL_COLOR_BUFFER_BIT);
	418
	419	glMatrixMode(GL_PROJECTION);
	420	glLoadIdentity();
	421	gluOrtho2D(0,1,0,1);
	422
	423	glMatrixMode(GL_MODELVIEW);
	424	glLoadIdentity();
	425
	426	glViewport(0, 0, Res2X, Res2Y);
	427
	428	// Enable Pointers
	429	glEnableClientState( GL_VERTEX_ARRAY ); // Enable Vertex Arrays
	430	glEnableClientState( GL_COLOR_ARRAY ); // Enable Texture Coord Arrays
	431
	432	for(i=0; i<g_pMesh.m_pObject._numGeos;i++)
	433	{
	434	for(j=0; j<g_pMesh.m_pObject._geo[i]._numTriSets;j++)
	435	{
	436	// Set Pointers To Our Data
	437	glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOTexCoords );
	438	glVertexPointer( 2, GL_FLOAT, 0, (char *) NULL ); // Set The Vertex Pointer To The Vertex Buffer
	439	glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOColors );
	440	glColorPointer( 3, GL_FLOAT, 0, (char *) NULL ); // Set The TexCoord Pointer To The TexCoord Buffer
	441	glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOIndexs );
	442
	443	// Render
	444	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
	445
	446	}
	447	}
	448
	449	glDisableClientState( GL_VERTEX_ARRAY ); // Enable Vertex Arrays
	450	glDisableClientState( GL_COLOR_ARRAY ); // Enable Texture Coord Arrays
	451
	452	glUseProgram(0);
	453	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
	454	}
	455
	456	// Function that copies the 16-bit fp RGBA buffer of the lightmap to a 32-bit RGBA fb buffer.
	457	void NormalizeLightmap(void)
	458	{
	459	glUseProgram(pNormalize);
	460	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb5);
	461
	462	glEnable(GL_CULL_FACE);
	463
	464	glMatrixMode(GL_PROJECTION);
	465	glLoadIdentity();
	466	gluOrtho2D(-Res2X,Res2Y,-Res2X,Res2Y);
	467
	468	glMatrixMode(GL_MODELVIEW);
	469	glLoadIdentity();
	470
	471	glViewport(0, 0, Res2X, Res2Y);
	472
	473	glActiveTexture(GL_TEXTURE0);
	474	glBindTexture(GL_TEXTURE_2D, texCopy[0]);
	475	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	476	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	477	glUniform1i(TextureCopy, 0);
	478
	479	//Draw the geometry.
	480	glBegin(GL_QUADS);
	481	{
	482	glTexCoord2f(0, 0); glVertex3f(-Res2X, -Res2Y, -0.5f);
	483	glTexCoord2f(1,0); glVertex3f(Res2X, -Res2Y, -0.5f);
	484	glTexCoord2f(1,1); glVertex3f(Res2X, Res2Y, -0.5f);
	485	glTexCoord2f(0, 1); glVertex3f(-Res2X, Res2Y, -0.5f);
	486	}
	487	glEnd();
	488
	489	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
	490	glUseProgram(0);
	491	}
	492
	493	// Function that updates the lightmap.
	494	// The number of directions used to calculate the lightmap is iterations * steps
	495	void UpdateTexture(int iterations, int steps)
	496	{
	497	const int range = ((steps * 100) / steps) + ((iterations) * 100)/(steps * iterations);
	498
	499	//progress bar
	500	wxProgressDialog dialog(wxT("Calculating GPUObscurances"),
	501	wxT("Progress..."),
	502	range, //range
	503	0, //parent
	504	wxPD_APP_MODAL\|wxPD_AUTO_HIDE\|
	505	wxPD_ELAPSED_TIME\|wxPD_ESTIMATED_TIME\|wxPD_REMAINING_TIME\|wxPD_CAN_ABORT);
	506
	507	bool cont = true;
	508
	509	printf("\nIteracions: %d => Steps: %d\n", iterations, steps);
	510	for(int i = 0; (i < steps) && cont; i++)
	511	{
	512	for(int j = 0; (j < iterations) && cont; j++)
	513	{
	514	cont = dialog.Update(i100/steps + j100/(steps*iterations));
	515	BuscarDireccio(); // Find a random direction
	516	RenderProjeccions();
	517	RenderTransfer();
	518	}
	519	CopyTexture();
	520	}
	521	printf("\r100%% Done!!!!");
	522	NormalizeLightmap();
	523	}
	524
	525	// Function that generates the VBOs with the geometric data of the scene.
	526	// It also initializes the constant textures used.
	527	void InitGeometry(void)
	528	{
	529	int i, j;
	530	m_pBlau = new float[ResX * ResY * 4];
	531	//Initialize a blue buffer.
	532	for(i = 0; i<ResX; i++)
	533	{
	534	for(j = 0; j<ResY; j++)
	535	{
	536	m_pBlau[4 * (i * ResY + j)] = 0.0;
	537	m_pBlau[4 * (i * ResY + j) + 1] = 0.0;
	538	m_pBlau[4 * (i * ResY + j) + 2] = 1.0;
	539	m_pBlau[4 * (i * ResY + j) + 3] = 1.0;
	540	}
	541	}
	542
	543	//Initialize a black buffer
	544	for(i = 0; i<Res2X; i++)
	545	{
	546	for(j = 0; j<Res2Y; j++)
	547	{
	548	m_pNegre[4(iRes2Y+j)] = 0.0;
	549	m_pNegre[4(iRes2Y+j)+1] = 0.0;
	550	m_pNegre[4(iRes2Y+j)+2] = 0.0;
	551	m_pNegre[4(iRes2Y+j)+3] = 0.0;
	552	}
	553	}
	554
	555	for(i = 0; i<g_pMesh.m_pObject._numGeos;i++)
	556	{
	557	for(j = 0; j<g_pMesh.m_pObject._geo[i]._numTriSets;j++)
	558	{
	559	//Aqui creeem els VBOs.
	560
	561	g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOIndexs = 0;
	562	// Generate And Bind The Index Buffer
	563	glGenBuffersARB( 1, (unsigned int *)&g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOIndexs ); // Get A Valid Name
	564	glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOIndexs ); // Bind The Buffer
	565	// Load The Data
	566	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 );
	567
	568	g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOVertices = 0;
	569	// Generate And Bind The Vertex Buffer
	570	glGenBuffersARB( 1, &g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOVertices ); // Get A Valid Name
	571	glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOVertices ); // Bind The Buffer
	572	// Load The Data
	573	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 );
	574
	575	g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBONormals = 0;
	576	// Generate And Bind The Normal Buffer
	577	glGenBuffersARB( 1, &g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBONormals ); // Get A Valid Name
	578	glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBONormals ); // Bind The Buffer
	579	// Load The Data
	580	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 );
	581
	582	g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOTexCoords = 0;
	583	// Generate And Bind The TexCoord Buffer
	584	glGenBuffersARB( 1, &g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOTexCoords ); // Get A Valid Name
	585	glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOTexCoords ); // Bind The Buffer
	586	// Load The Data
	587	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 );
	588
	589	g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOColors = 0;
	590	// Generate And Bind The Color Buffer
	591	glGenBuffersARB( 1, &g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOColors ); // Get A Valid Name
	592	glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh.m_pObject._geo[i]._triSet[j].m_nVBOColors ); // Bind The Buffer
	593	// Load The Data
	594	//*12
	595	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 );
	596	}
	597	}
	598	glBindBufferARB( GL_ARRAY_BUFFER_ARB, 0 ); // Bind The Buffer
	599	}
	600
	601	// Functions that initializes the RenderTextures, the shaders and so on...
	602	void init2(char *argv)
	603	{
	604	g_pMesh.LoadMesh(argv);
	605
	606	m_pTextureImage = new float[Res2XRes2Y4];// Texture of diferent colors.
	607	m_pTextureReflect = new float[Res2XRes2Y4]; //Texture of reflectivitat.
	608	m_pNegre = new float[Res2XRes2Y4];
	609
	610	//Create Textures.
	611	glGenTextures(3, &texName[0]); // Create The Textures
	612
	613	InitGeometry();
	614
	615	//Texture
	616	// Binding
	617	glBindTexture( GL_TEXTURE_2D, texName[0] );
	618	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA_FLOAT32_ATI, ResX, ResY, 0, GL_RGBA, GL_FLOAT, NULL);
	619	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	620	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	621
	622	//Texture
	623	// Binding
	624	glBindTexture( GL_TEXTURE_2D, texName[1] );
	625	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA_FLOAT32_ATI, Res2X, Res2Y, 0, GL_RGBA, GL_FLOAT, NULL);
	626	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	627	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	628	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	629	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	630
	631
	632	//Texture
	633	// Binding
	634	glBindTexture( GL_TEXTURE_2D, texName[2] );
	635	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA_FLOAT32_ATI, Res2X, Res2Y, 0, GL_RGBA, GL_FLOAT, m_pTextureReflect);
	636	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	637	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	638	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	639	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	640
	641	//FBOs
	642	glGenFramebuffersEXT(1, &fb1);
	643	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb1);
	644
	645	glGenTextures(1,&texReflect[0]);
	646
	647	glBindTexture( GL_TEXTURE_2D, texReflect[0] );
	648	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA_FLOAT32_ATI, Res2X, Res2Y, 0, GL_RGBA, GL_FLOAT, 0);
	649	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	650	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	651	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	652	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	653
	654	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texReflect[0],0);
	655	glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0);
	656
	657	glGenFramebuffersEXT(1, &fb2);
	658	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb2);
	659
	660	glGenTextures(1,&texProjeccions[0]);
	661
	662	glBindTexture( GL_TEXTURE_2D, texProjeccions[0] );
	663	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA_FLOAT32_ATI, ResX, ResY, 0, GL_RGBA, GL_FLOAT, 0);
	664	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	665	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	666	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	667	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	668
	669	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texProjeccions[0],0);
	670
	671	glGenRenderbuffersEXT(1, &texProjeccions[1]);
	672	glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, texProjeccions[1]);
	673	glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, ResX, ResY );
	674	glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, texProjeccions[1]);
	675
	676	glGenFramebuffersEXT(1, &fb3);
	677	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb3);
	678
	679	glGenTextures(1,&texTransfer[0]);
	680
	681	glBindTexture( GL_TEXTURE_2D, texTransfer[0] );
	682	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA_FLOAT16_ATI, Res2X, Res2Y, 0, GL_RGBA, GL_FLOAT, 0);
	683	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	684	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	685	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	686	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	687
	688	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texTransfer[0],0);
	689	glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0);
	690
	691	glClearColor(0.0,0.0,0.0,0.0);
	692	glClear(GL_COLOR_BUFFER_BIT);
	693
	694	glGenFramebuffersEXT(1, &fb4);
	695	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb4);
	696
	697	glGenTextures(1,&texCopy[0]);
	698
	699	glBindTexture( GL_TEXTURE_2D, texCopy[0] );
	700	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA_FLOAT32_ATI, Res2X, Res2Y, 0, GL_RGBA, GL_FLOAT, 0);
	701	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	702	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	703	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	704	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	705
	706	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texCopy[0],0);
	707	glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0);
	708
	709	glGenFramebuffersEXT(1, &fb5);
	710	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb5);
	711
	712	glGenTextures(1,&texNormalize[0]);
	713
	714	glBindTexture( GL_TEXTURE_2D, texNormalize[0] );
	715	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA_FLOAT32_ATI, Res2X, Res2Y, 0, GL_RGBA, GL_FLOAT, 0);
	716	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	717	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	718	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	719	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	720
	721	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texNormalize[0],0);
	722	glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0);
	723
	724	//Create PBO
	725	glGenBuffersARB( MAX_LAYERS+2, &ProjectionsPBO[0] );
	726	glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, ProjectionsPBO[0] ); // Bind The Buffer
	727	glBufferDataARB( GL_PIXEL_PACK_BUFFER_EXT, ResXResY4*sizeof(float), m_pBlau, GL_STREAM_COPY );
	728	glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, ProjectionsPBO[MAX_LAYERS+1] ); // Bind The Buffer
	729	glBufferDataARB( GL_PIXEL_PACK_BUFFER_EXT, ResXResY4*sizeof(float), m_pBlau, GL_STREAM_COPY );
	730	for (int e = 1; e < MAX_LAYERS+1; e++ )
	731	{
	732	glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, ProjectionsPBO[e] ); // Bind The Buffer
	733	glBufferDataARB( GL_PIXEL_PACK_BUFFER_EXT, ResXResY4*sizeof(float), NULL, GL_STREAM_COPY );
	734	}
	735
	736	glGenBuffersARB( 1, &ObscurancesPBO );
	737	glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, ObscurancesPBO ); // Bind The Buffer
	738	glBufferDataARB( GL_PIXEL_PACK_BUFFER_EXT, Res2XRes2Y4*sizeof(float), m_pNegre, GL_STREAM_COPY );
	739	glBindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, 0 ); // Bind The Buffer
	740
	741	//GLSL
	742	//Projection Shaders
	743
	744	vProjection = glCreateShader(GL_VERTEX_SHADER);
	745	fProjection = glCreateShader(GL_FRAGMENT_SHADER);
	746
	747	static const char *vvProjection =
	748	" \n"
	749	" varying float cosine; \n"
	750	" varying vec2 texCoord; \n"
	751	" \n"
	752	" void main() \n"
	753	" { \n"
	754	" gl_Position = ftransform(); \n"
	755	" texCoord = gl_MultiTexCoord0.st; \n"
	756	" \n"
	757	" cosine = (gl_ModelViewMatrixInverseTranspose * vec4(gl_Normal,1.0)).z; \n"
	758	" } \n"
	759	" \n";
	760
	761	static const char *ffProjection =
	762	" \n"
	763	" uniform float res; \n"
	764	" uniform float first; \n"
	765	" uniform sampler2D ztex; \n"
	766	" \n"
	767	" varying float cosine; \n"
	768	" varying vec2 texCoord; \n"
	769	" \n"
	770	" void main() \n"
	771	" { \n"
	772	" if( first == 0.0) \n"
	773	" { \n"
	774	" float depth = tex2D(ztex,gl_FragCoord.xy/res).a; \n"
	775	" if (gl_FragCoord.z < (depth + 0.000001)) discard; \n"
	776	" } \n"
	777	" gl_FragColor.rg = texCoord+0.5/512.0; \n"
	778	" gl_FragColor.b = cosine; \n"
	779	" gl_FragColor.a = gl_FragCoord.z; \n"
	780	" } \n";
	781
	782
	783	glShaderSource(vProjection, 1, &vvProjection, NULL);
	784	glShaderSource(fProjection, 1, &ffProjection, NULL);
	785
	786	glCompileShader(vProjection);
	787	glCompileShader(fProjection);
	788
	789	pProjection = glCreateProgram();
	790	glAttachShader(pProjection, vProjection);
	791	glAttachShader(pProjection, fProjection);
	792
	793	glLinkProgram(pProjection);
	794
	795	glUseProgram(pProjection);
	796	TexturaDepthProjection = glGetUniformLocation(pProjection, "ztex");
	797	SizeProjection = glGetUniformLocation(pProjection, "res");
	798	FirstProjection = glGetUniformLocation(pProjection, "first");
	799
	800	glUseProgram(0);
	801
	802
	803	//Reflect Shaders
	804
	805	vReflect = glCreateShader(GL_VERTEX_SHADER);
	806	fReflect = glCreateShader(GL_FRAGMENT_SHADER);
	807
	808	static const char *vvReflect =
	809	" \n"
	810	" varying vec4 color; \n"
	811	" \n"
	812	" void main() \n"
	813	" { \n"
	814	" vec4 posicio = vec4(gl_Vertex.xy, -0.5, 1.0); \n"
	815	" gl_Position = gl_ModelViewProjectionMatrix * posicio; \n"
	816	" \n"
	817	" color = vec4(gl_Color.xyz,1.0); \n"
	818	" } \n";
	819
	820	static const char *ffReflect =
	821	" \n"
	822	" varying vec4 color; \n"
	823	" \n"
	824	" void main() \n"
	825	" { \n"
	826	" gl_FragColor = color; \n"
	827	" } \n"
	828	" \n";
	829
	830	glShaderSource(vReflect, 1, &vvReflect, NULL);
	831	glShaderSource(fReflect, 1, &ffReflect, NULL);
	832
	833	glCompileShader(vReflect);
	834	glCompileShader(fReflect);
	835
	836	pReflect = glCreateProgram();
	837	glAttachShader(pReflect, vReflect);
	838	glAttachShader(pReflect, fReflect);
	839
	840	glLinkProgram(pReflect);
	841
	842	glUseProgram(0);
	843
	844	//Texture Copy Shaders
	845
	846	vCopy = glCreateShader(GL_VERTEX_SHADER);
	847	fCopy = glCreateShader(GL_FRAGMENT_SHADER);
	848
	849	static const char *vvCopy =
	850	" \n"
	851	" varying vec2 texCoord; \n"
	852	" \n"
	853	" void main() \n"
	854	" { \n"
	855	" vec4 posicio = vec4(gl_Vertex.xyz, 1.0); \n"
	856	" gl_Position = gl_ModelViewProjectionMatrix * posicio; \n"
	857	" \n"
	858	" texCoord = gl_MultiTexCoord0.st; \n"
	859	" } \n";
	860
	861	static const char *ffCopy =
	862	" \n"
	863	" uniform sampler2D texture; \n"
	864	" uniform sampler2D texture2; \n"
	865	" \n"
	866	" varying vec2 texCoord; \n"
	867	" \n"
	868	" void main() \n"
	869	" { \n"
	870	" gl_FragColor = tex2D(texture,texCoord) + tex2D(texture2,texCoord); \n"
	871	" } \n";
	872
	873	glShaderSource(vCopy, 1, &vvCopy, NULL);
	874	glShaderSource(fCopy, 1, &ffCopy, NULL);
	875
	876	glCompileShader(vCopy);
	877	glCompileShader(fCopy);
	878
	879	pCopy = glCreateProgram();
	880	glAttachShader(pCopy, vCopy);
	881	glAttachShader(pCopy, fCopy);
	882
	883	glLinkProgram(pCopy);
	884
	885	glUseProgram(pCopy);
	886	TextureCopy = glGetUniformLocation(pCopy, "texture");
	887	Texture2Copy = glGetUniformLocation(pCopy, "texture2");
	888	glUseProgram(0);
	889
	890	//Lightmap Normalization Shaders
	891
	892	vNormalize = glCreateShader(GL_VERTEX_SHADER);
	893	fNormalize = glCreateShader(GL_FRAGMENT_SHADER);
	894
	895	static const char *vvNormalize =
	896	" \n"
	897	" varying vec2 texCoord; \n"
	898	" \n"
	899	" void main() \n"
	900	" { \n"
	901	" vec4 posicio = vec4(gl_Vertex.xyz, 1.0); \n"
	902	" gl_Position = gl_ModelViewProjectionMatrix * posicio; \n"
	903	" \n"
	904	" texCoord = gl_MultiTexCoord0.st; \n"
	905	" } \n";
	906
	907	static const char *ffNormalize =
	908	" \n"
	909	" uniform sampler2D texture; \n"
	910	" \n"
	911	" varying vec2 texCoord; \n"
	912	" \n"
	913	" void main() \n"
	914	" { \n"
	915	" float res = 256.0; \n"
	916	" float dif = 1.0/res; \n"
	917	" vec4 aux1 = tex2D(texture,texCoord); \n"
	918	" vec4 aux2 = tex2D(texture,vec2(texCoord.r+dif,texCoord.g)); \n"
	919	" vec4 aux3 = tex2D(texture,vec2(texCoord.r+dif,texCoord.g+dif)); \n"
	920	" vec4 aux4 = tex2D(texture,vec2(texCoord.r,texCoord.g+dif)); \n"
	921	" float counter = 0.0; \n"
	922	" vec4 aux = vec4(0.0,0.0,0.0,0.0); \n"
	923	" if(aux1.a>0.0) \n"
	924	" { \n"
	925	" aux += vec4(aux1.rgb/aux1.a,1.0); \n"
	926	" counter += 1.0; \n"
	927	" } \n"
	928	" if(aux2.a>0.0) \n"
	929	" { \n"
	930	" aux += vec4(aux2.rgb/aux2.a,1.0); \n"
	931	" counter += 1.0; \n"
	932	" } \n"
	933	" if(aux3.a>0.0) \n"
	934	" { \n"
	935	" aux += vec4(aux3.rgb/aux3.a,1.0); \n"
	936	" counter += 1.0; \n"
	937	" } \n"
	938	" if(aux4.a>0.0) \n"
	939	" { \n"
	940	" aux += vec4(aux4.rgb/aux4.a,1.0); \n"
	941	" counter += 1.0; \n"
	942	" } \n"
	943	" if(counter < 1.0) gl_FragColor = vec4(0.0,0.0,0.0,0.0); \n"
	944	" else \n"
	945	" { \n"
	946	" aux /= counter; \n"
	947	" gl_FragColor = aux; \n"
	948	" } \n"
	949	" } \n";
	950
	951	glShaderSource(vNormalize, 1, &vvNormalize, NULL);
	952	glShaderSource(fNormalize, 1, &ffNormalize, NULL);
	953
	954	glCompileShader(vNormalize);
	955	glCompileShader(fNormalize);
	956
	957	pNormalize = glCreateProgram();
	958	glAttachShader(pNormalize, vNormalize);
	959	glAttachShader(pNormalize, fNormalize);
	960
	961	glLinkProgram(pNormalize);
	962
	963	glUseProgram(pNormalize);
	964	TexturaNormalize = glGetUniformLocation(pNormalize, "texture");
	965	glUseProgram(0);
	966
	967	//Energy Transfer Shaders
	968
	969	vTransfer = glCreateShader(GL_VERTEX_SHADER);
	970	fTransfer = glCreateShader(GL_FRAGMENT_SHADER);
	971
	972	static const char *vvTransfer =
	973	" \n"
	974	" uniform float direction; \n"
	975	" \n"
	976	" varying vec2 p1; \n"
	977	" varying vec2 p2; \n"
	978	" varying float factor; \n"
	979	" \n"
	980	" void main() \n"
	981	" { \n"
	982	" vec4 position = gl_Vertex; \n"
	983	" vec4 texCoord = gl_MultiTexCoord0; \n"
	984	" if(((direction == 0) && (position.b != 1.0) && (position.b < 0.0) && ((texCoord.b > 0.0) \|\| (texCoord.b == 1))) \n"
	985	" \|\| ((direction == 1) && (position.b != 1.0) && (position.b > 0.0) && ((texCoord.b < 0.0) \|\| (texCoord.b == 1)))) \n"
	986	" { \n"
	987	" \n"
	988	" p1 = vec2(position.r, position.g); \n"
	989	" \n"
	990	" p2 = vec2(texCoord.r, texCoord.g); \n"
	991	" \n"
	992	" gl_Position = vec4((p1 * 2.0) - vec2(1.0,1.0), 0.0,1.0); \n"
	993	" \n"
	994	" if (texCoord.b == 1) factor = 1; \n"
	995	" else factor = abs(texCoord.a - position.a); \n"
	996	" } \n"
	997	" else \n"
	998	" { \n"
	999	" gl_Position = vec4( 0.0,0.0, 2.0, 1.0 ); \n"
	1000	" p1 = p2 = vec2(1.0,1.0); \n"
	1001	" factor = 0.5; \n"
	1002	" } \n"
	1003	" } \n";
	1004
	1005	static const char *ffTransfer =
	1006	" \n"
	1007	" uniform sampler2D reflectivity; \n"
	1008	" uniform float dmax; \n"
	1009	" \n"
	1010	" varying vec2 p1; \n"
	1011	" varying vec2 p2; \n"
	1012	" varying float factor; \n"
	1013	" \n"
	1014	" void main() \n"
	1015	" { \n"
	1016	" if(factor>=dmax) gl_FragColor.rgb = vec3(0.5,0.5,0.5); \n"
	1017	" else gl_FragColor.rgb = tex2D(reflectivity,p2).rgb * sqrt(factor/dmax); \n"
	1018	" gl_FragColor.a = 1.0; \n"
	1019	" } \n";
	1020
	1021	glShaderSource(vTransfer, 1, &vvTransfer, NULL);
	1022	glShaderSource(fTransfer, 1, &ffTransfer, NULL);
	1023
	1024	glCompileShader(vTransfer);
	1025	glCompileShader(fTransfer);
	1026
	1027	pTransfer = glCreateProgram();
	1028	glAttachShader(pTransfer, vTransfer);
	1029	glAttachShader(pTransfer, fTransfer);
	1030
	1031	glLinkProgram(pTransfer);
	1032
	1033	glUseProgram(pTransfer);
	1034	TexturaReflectTransfer = glGetUniformLocation(pTransfer, "reflectivity");
	1035	DirectionTransfer = glGetUniformLocation(pTransfer, "direction");
	1036	DmaxTransfer = glGetUniformLocation(pTransfer, "dmax");
	1037
	1038	glUseProgram(0);
	1039
	1040	// Setup GL States
	1041	glEnable (GL_DEPTH_TEST); // Enable Depth Testing
	1042
	1043	//Generate the reflectivity texture.
	1044	RenderReflect();
	1045
	1046	UpdateTexture(60,3);
	1047
	1048	}
	1049
	1050	// Function that interfaces with the VisualCAD.
	1051	int vcObscurerGenerateImage(CMesh &geom, char argv, int quality, int imgUsize, int imgVsize, float *imgRgbBuffer)
	1052	{
	1053	// float divisor;
	1054	int *DadesTemp = new int[4];
	1055	float *dadesf=NULL;
	1056	int *dadesi=NULL;
	1057	int qual;
	1058	float aux[4];
	1059	float a;
	1060
	1061
	1062	glutCreateWindow("T");
	1063
	1064	glerror = glewInit();
	1065
	1066	FILE *file = NULL;
	1067
	1068	file = fopen("tmp.txt", "w");
	1069
	1070	if (glerror != GLEW_OK) fprintf(file, "\nError initializing glew library, %s", glewGetErrorString(glerror));
	1071	else fprintf(file, "\nTot Correcte!\n");
	1072
	1073	fclose(file);
	1074
	1075	memset(&aux, 0.0, 4);
	1076
	1077	qual = quality;
	1078
	1079	if (qual < 1) qual = 1;
	1080
	1081	switch (qual)
	1082	{
	1083	case 1: imgVsize = imgUsize = 256;
	1084	break;
	1085	case 2: imgVsize = imgUsize = 512;
	1086	break;
	1087	case 3: imgVsize = imgUsize = 1024;
	1088	break;
	1089	case 4: imgVsize = imgUsize = 2048;
	1090	break;
	1091	default: printf("\nResolution not supported");
	1092	};
	1093
	1094	Res2X = *imgUsize;
	1095	Res2Y = *imgVsize;
	1096
	1097	ResX = Res2X * 2.0;
	1098	ResY = Res2Y * 2.0;
	1099
	1100	if(ResX == 4096) ResX = 2048;
	1101	if(ResY == 4096) ResY = 2048;
	1102
	1103	printf("\nRes(Plans de projeccio): ResolucioX = %d , ResolucioY = %d", ResX, ResY);
	1104	printf("\nRes2(Lightmap): ResolucioX = %d , ResolucioY = %d", Res2X, Res2Y);
	1105	dadesf = new float[Res2XRes2Y4];
	1106	dadesi = new int[Res2XRes2Y4];
	1107
	1108	init2(argv);
	1109
	1110	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb5);
	1111	glReadPixels(0,0,Res2X,Res2Y,GL_RGBA,GL_FLOAT,dadesf);
	1112	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
	1113
	1114	*imgRgbBuffer = dadesf;
	1115
	1116	geom = g_pMesh;
	1117
	1118	return 0;
	1119
	1120	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: