anytestfunctions.cpp

PDE simulator on GPU.

	int i,j, DimX,DimY,DimZ;
	unsigned int Tex0,Tex1;

	DimX = 13;
	DimY = 13;
	DimZ = 13;
	/// Image0----DimY*DimX
	unsigned char *ImageDataFile0 = new unsigned char[DimX*DimY];
	for(i=0;i<DimY;i++)
	{
		for(j=0;j<DimX;j++)
		{
			ImageDataFile0[i*DimX + j] = 255;
		}
	}
	////Generate DimSize Textures
	glGenTextures(1,&Tex0);
	glBindTexture(GL_TEXTURE_RECTANGLE_NV,Tex0);
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST);	

	glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexImage2D( GL_TEXTURE_RECTANGLE_NV, 0, 1, DimX, DimY, 0, GL_RED, GL_UNSIGNED_BYTE, ImageDataFile0 );
	delete[] ImageDataFile0;
	ImageDataFile0 = NULL;
	
	//// Image1----DimX*DimZ
	unsigned char *ImageDataFile1 = new unsigned char[DimX*DimZ];
	for(i=0;i<DimX;i++)
	{
		for(j=0;j<DimZ;j++)
		{
			ImageDataFile1[i*DimZ + j]  = i*DimZ + j ;
		}
	}
	////Generate DimSize Textures
	glGenTextures(1,&Tex1);
	glBindTexture(GL_TEXTURE_RECTANGLE_NV,Tex1);
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST);	

	glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexImage2D( GL_TEXTURE_RECTANGLE_NV, 0, 1, DimZ, DimX, 0, GL_RED, GL_UNSIGNED_BYTE, ImageDataFile1 );
	delete[] ImageDataFile1;
	ImageDataFile1 = NULL;

	glColor3f(1,1,1);

	//////////////Tex0
	glActiveTexture(GL_TEXTURE0_ARB);
	glBindTexture(GL_TEXTURE_RECTANGLE_NV,Tex0);
	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glDisable(GL_TEXTURE_RECTANGLE_NV);
/*
	glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_ADD);
	glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE0);
	glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
	glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PRIMARY_COLOR);
	glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
*/	
	//////////////Tex1
	glActiveTexture(GL_TEXTURE1_ARB);
	glBindTexture(GL_TEXTURE_RECTANGLE_NV,Tex1);
	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glEnable(GL_TEXTURE_RECTANGLE_NV);
/*
	float mixcol[] = {1,1,1,0};
	glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, mixcol);
	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
	glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
	glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
	glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_ONE_MINUS_SRC_COLOR);
	glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_TEXTURE1);
	glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
	glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_CONSTANT);
	glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_COLOR);
*/

	/////Result--------------DimY*DimZ
	glBegin( GL_QUADS );
		//glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0,0);	
		//glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0,0);	
		glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0,0);	
		//glTexCoord2f(0,0);	
		glVertex2i( 0, 0);

		//glMultiTexCoord2fARB(GL_TEXTURE0_ARB, DimX, 0);	
		//glMultiTexCoord2fARB(GL_TEXTURE1_ARB, DimX, 0);	
		glMultiTexCoord2fARB(GL_TEXTURE1_ARB, DimZ, 0);	
		//glTexCoord2f(DimX, 0);	
		glVertex2i( DimZ, 0);

		//glMultiTexCoord2fARB(GL_TEXTURE0_ARB, DimX, DimY);	
		//glMultiTexCoord2fARB(GL_TEXTURE1_ARB, DimX, DimY);		
		glMultiTexCoord2fARB(GL_TEXTURE1_ARB, DimZ, DimX);		
		//glTexCoord2f(DimX, DimY);	
		glVertex2i( DimZ, DimX);

		//glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0, DimY);	
		//glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0, DimY);	
		glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0, DimX);	
		//glTexCoord2f(0, DimY);	
		glVertex2i( 0, DimX);
	glEnd();
	
	////save the immediate texture result into 
	glCopyTexSubImage2D(GL_TEXTURE_RECTANGLE_NV, 0, 0, 0, 0, 0, DimZ, DimY);
/*
	unsigned char *TexData = new unsigned char[DimZ*DimY];
	glGetTexImage(GL_TEXTURE_RECTANGLE_NV, 0, GL_RED, GL_UNSIGNED_BYTE, TexData);
	FILE *fp1 = fopen("..\\testtt.txt","w");
	fprintf(fp1,"Width=%d  Height=%d\n",DimZ, DimY);
	for(i=0;i<DimY;i++)
	{
		for(j=0;j<DimZ;j++)
			fprintf(fp1,"%4d  ",TexData[i*DimZ+j]);
		fprintf(fp1,"\n");
	}
	fclose(fp1);
	delete[] TexData;
	TexData = NULL;
*/
}



int Width  = 16;
int Height = 16;
unsigned int texid;
unsigned int ShaderID;
unsigned int ShaderID1;
unsigned int ShaderID2;

GLenum TexTarget = GL_TEXTURE_RECTANGLE_NV;
void LoadData(unsigned int &TexID)
{
	float *ImageData = new float[Width*Height];

	glGenTextures(1,&TexID);
	int i,j;
	for(i=0;i<Height;i++)
	{
		for(j=0;j<Width;j++)
		{
			ImageData[i*Width + j] = TexID;
		}
	}

	float borderColor[] = {0,0,0,1.0};

	glBindTexture(TexTarget,TexID);
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glTexParameterf(TexTarget, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameterf(TexTarget, GL_TEXTURE_MIN_FILTER, GL_NEAREST);	

	//// Extension is zero in texture
    //glTexParameterf(TexTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
    //glTexParameterf(TexTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);

    //// For max operation in a vector OK!
	glTexParameterf(TexTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(TexTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	
	/// The following is not ideal for my thinking
	//glTexParameterfv(TexTarget, GL_TEXTURE_BORDER_COLOR, borderColor);

	glTexImage2D( TexTarget, 0, GL_FLOAT_R32_NV, Width, Height, 0, GL_RED, GL_FLOAT, ImageData );
	
	delete []ImageData;	

	return;
}

void TestTexelPos()
{
	LoadData(texid);
	///// Bind the Fragment Program to current drawing
	LoadFragmentProgramFromFile("..\\ssmatrixvectorRECT.fp", ShaderID);
	LoadFragmentProgramFromFile("..\\simple.fp", ShaderID1);
	glEnable(GL_FRAGMENT_PROGRAM_NV);
	glEnable(TexTarget);

	glDisable(GL_DEPTH_TEST);
	/// Bind the predefined fragment program object 
	//glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, ShaderID1);
	glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, ShaderID);
	glBindTexture(TexTarget,texid);

	glBegin(GL_QUADS);
		glTexCoord2f(0,0);
		glVertex2i(0,0);

		glTexCoord2f(Width,0);
		glVertex2i(Width,0);

		glTexCoord2f(Width,Height);
		glVertex2i(Width,Height);

		glTexCoord2f(0,Height);
		glVertex2i(0,Height);
	glEnd();

	unsigned char *TexData = new unsigned char[Width*Height];
	//memset(TexData, 0, sizeof(unsigned char)*Width*Height);
	//glReadPixels(0, 0, Width, Height, GL_RED, GL_UNSIGNED_BYTE, TexData);
	glCopyTexSubImage2D(TexTarget, 0, 0, 0, 0, 0, Width, Height);
	glGetTexImage(TexTarget, 0, GL_RED, GL_UNSIGNED_BYTE, TexData);
	FILE *fp = fopen("..\\testtt.txt","w");
	for(int i=0;i<Height;i++)
	{
		for(int j=0;j<Width;j++)
			fprintf(fp,"%3d  ",TexData[i*Width+j]);
		fprintf(fp, "\n");
	}
	fclose(fp);

	delete[] TexData;

}
void output(char *filename, unsigned int texid)
{
	//////Debug here
	int i,j;
	FILE *fp = fopen(filename,"w");

	float *fOutputTex = new float[Width*Height*3];
	glBindTexture(GL_TEXTURE_RECTANGLE_NV, texid);
	glGetTexImage(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGB, GL_FLOAT, fOutputTex);
	
	for(i=0;i<Height;i++)
	{
		for(j=0;j<Width;j++)
		{
			//fprintf(fp,"%d %d %5.3f %5.3f \n",i, j, fOutputTex[(i*_iWidth+j)*3], fOutputTex[(i*_iWidth+j)*3+1]);
			fprintf(fp,"(%6.2f,%6.2f)  ",fOutputTex[(i*Width+j)*3], fOutputTex[(i*Width+j)*3+1]);
		}
		fprintf(fp,"\n");
	}
	fclose(fp);
	delete[] fOutputTex;

}

//#include "RenderTexture.h"

unsigned int tex0_id;
unsigned int tex1_id;
unsigned int tex2_id;
void testtwopbuffer()
{
	int i;
	///////////////////////////////////////////////////////
	///// Bind the Fragment Program to current drawing
	LoadFragmentProgramFromFile("..\\test.fp", ShaderID1);
	LoadFragmentProgramFromFile("..\\test.fp", ShaderID2);


	///Setup two pbuffers, and the class CFloatPBuffer from RTT of Harris
	CFloatPBuffer* pbuffer[4];
	for(i=0;i<4;i++)
	{
		pbuffer[i] = new  CFloatPBuffer(Width, Height);
		///Here I have set to share resource contexts
		pbuffer[i]->Initialize();
		pbuffer[i]->BeginCapture();
	
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	
	
		glViewport(0,0,Width,Height);
		glMatrixMode ( GL_PROJECTION );
		glLoadIdentity();
		glOrtho( 0, Width, 0, Height, -1.0, 1.0 );
		glMatrixMode ( GL_MODELVIEW );
		glLoadIdentity();
		glEnable(GL_FRAGMENT_PROGRAM_NV);

		pbuffer[i]->EndCapture();
	}

	int whichone=0;
	
	///Here I have to make one pbuffer current, so the texture data can be correctly used in the following program
	pbuffer[whichone]->BeginCapture();
	LoadData(tex0_id);
	LoadData(tex1_id);	
	LoadData(tex2_id);
	pbuffer[whichone]->EndCapture();

	///Output the textures, the result is correct.
	output("..\\tex0-1.txt", tex0_id);
	output("..\\tex1-1.txt", tex1_id);
	output("..\\tex2-1.txt", tex2_id);

	whichone = 0;
	////Set the tex1_id as the target of RTT
	HPBUFFERARB hpf = pbuffer[whichone]->GetHandle();
	pbuffer[whichone]->Activate();

	glDrawBuffer(GL_FRONT);
	glReadBuffer(GL_FRONT);

	glBindTexture(GL_TEXTURE_RECTANGLE_NV,  tex1_id);
	wglReleaseTexImageARB(hpf, WGL_FRONT_LEFT_ARB);
	glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, ShaderID1);

	glActiveTextureARB(GL_TEXTURE0_ARB);
	glBindTexture(GL_TEXTURE_RECTANGLE_NV, tex0_id);
	glActiveTextureARB(GL_TEXTURE1_ARB);
	glBindTexture(GL_TEXTURE_RECTANGLE_NV, tex2_id);

	glBegin(GL_QUADS);
		glVertex2i(0,0);
		glVertex2i(Width,0);
		glVertex2i(Width,Height);
		glVertex2i(0,Height);
	glEnd();

	glBindTexture(GL_TEXTURE_RECTANGLE_NV, tex1_id);
	wglBindTexImageARB(hpf, GL_FRONT);

	output("..\\tex0-2.txt", tex0_id);
	output("..\\tex1-2.txt", tex1_id);
	output("..\\tex2-2.txt", tex2_id);
		
//	whichone = 1;

	glDrawBuffer(GL_BACK);	
	glReadBuffer(GL_BACK);
	wglReleaseTexImageARB(hpf, WGL_BACK_LEFT_ARB);
	glBindTexture(GL_TEXTURE_RECTANGLE_NV,  tex0_id);
//	pbuffer[whichone]->BeginCapture();
	glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, ShaderID1);

	glActiveTextureARB(GL_TEXTURE0_ARB);
	glBindTexture(GL_TEXTURE_RECTANGLE_NV, tex1_id);
	glActiveTextureARB(GL_TEXTURE1_ARB);
	glBindTexture(GL_TEXTURE_RECTANGLE_NV, tex2_id);

	glBegin(GL_QUADS);
		glVertex2i(0,0);
		glVertex2i(Width,0);
		glVertex2i(Width,Height);
		glVertex2i(0,Height);
	glEnd();

	glBindTexture(GL_TEXTURE_RECTANGLE_NV, tex0_id);
	wglBindTexImageARB(hpf, WGL_BACK_LEFT_ARB);
	pbuffer[whichone]->InActivate();

//	pbuffer[whichone]->EndCapture();


	///output to have check, no problems here!
	output("..\\tex0-3.txt", tex0_id);
	output("..\\tex1-3.txt", tex1_id);
	output("..\\tex2-3.txt", tex2_id);

}