#include ".\preillumsystem.h"

#include <list>


PreIllumSystem::~PreIllumSystem(void)
{
}

float PreIllumSystem::Phase(Vector diri,Vector dirj,float symmetry)
{
	float anglecos=diri*dirj;
	float g=symmetry;
	float g2=g*g;
	float phase=3*(1-g2)*(1+anglecos*anglecos)/2/(2+g2)/pow((1+g2-2*anglecos*g),1.5f);
	return phase/(4*M_PI);
	//return 1.0/(4*M_PI);
}

void PreIllumSystem::Calculate_Up_Right_Vector(Vector viewdir,Vector& UpVector,Vector& RightVector)
{
	if(viewdir.y==0)
	{
		UpVector.x=0;UpVector.y=1;UpVector.z=0;
	}
	else
	{
		Vector projected;
		projected.x=viewdir.x;projected.z=viewdir.z;
		projected.y=0;
		projected.Normalize();
	
		UpVector=viewdir-projected;
		UpVector.Normalize();
	}
	RightVector=UpVector%viewdir;
	RightVector.Normalize();
}

PreIllumSystem::GetNearestDirection(Vector LightPosition)
{	
	Vector dir=LightPosition;
	dir.Normalize();
	
	float angle1,angle2;
	//transform to polar coordinates
	angle2=asin(dir.y); // -pi/2 -- pi/2
	
	dir.y=0;
	dir.Normalize();

	float sign;
	if(dir.z>0)sign=1;
	if(dir.z<0)sign=-1;
	if(dir.z==0)sign=0;

	angle1=acos(dir.x)*sign; // -pi -- pi
	
	Vector dirre(cos(angle1)*cos(angle2),
							sin(angle2),
							sin(angle1)*cos(angle2));
	
	angle1=angle1/6.28+0.5; // 0 -- 1
	angle2=angle2/3.14+0.5; // 0 -- 1

	int coord1=angle1*512;
	int coord2=angle2*512;
	int index=coord2*512*4+coord1*4;

	if(index+3>512*512*4) exit(1);
	m_NearestDir=m_DirectionData[index];
	m_NearestDir2=m_DirectionData[index+1];
	m_Weight1=m_DirectionData[index+2];
	m_Weight2=m_DirectionData[index+3];	
}

void PreIllumSystem::CreateGivenDirections()
{	/*
	m_Directions=new Vector[4];	

	m_Directions[0]=Vector(1,0,0);
	m_Directions[1]=Vector(0,0,1);
	m_Directions[2]=Vector(0,0,-1);
	m_Directions[3]=Vector(-1,0,0);
	*/
	m_Directions=new Vector[m_DirectionCount];
	for(int i=0;i<m_DirectionCount/2;i++)
	{
		float angle=(float)i*2.0*3.14/(float)m_DirectionCount;
		Vector dir(cos(angle),0,sin(angle));
		m_Directions[i]=dir;
		m_Directions[m_DirectionCount-1-i]=dir*-1;
	}
}

void PreIllumSystem::CreateRandomDirections(bool fillarray=false)
{	
	Halton Halton1(1,7);
	Halton Halton2(1,13);
	Halton Halton3(1,17);

	if(fillarray)
	m_DirectionArray=new float[3*m_DirectionCount];	
	
	m_Directions=new Vector[m_DirectionCount];	
	
	for(int i=0;i<m_DirectionCount/2;i++)
	{
	/*	Vector randpoint(RangeRandom(-1,1),
							RangeRandom(-1,1),
							RangeRandom(-1,1));*/
		Vector randpoint((float)Halton1.Random(),
							(float)Halton2.Random(),
							(float)Halton3.Random());

		randpoint.Normalize();
		if(fillarray)
		{
			m_DirectionArray[m_DirectionCount-3*(i+1)]=randpoint.x;
			m_DirectionArray[m_DirectionCount-3*(i+1)+1]=randpoint.y;
			m_DirectionArray[m_DirectionCount-3*(i+1)+2]=randpoint.z;
		}
		m_Directions[m_DirectionCount-(i+1)]=randpoint;
		randpoint=randpoint*-1;
		if(fillarray)
		{
			m_DirectionArray[3*i]=randpoint.x;
			m_DirectionArray[3*i+1]=randpoint.y;
			m_DirectionArray[3*i+2]=randpoint.z;
		}
		m_Directions[i]=randpoint;
	}	
}

void PreIllumSystem::CreateVisibilityTexture()
{		
	float *data=new float[m_DirectionCount*m_ParticleCount*3];
	for(int m=0;m<m_DirectionCount*m_ParticleCount;m++)
	{
		data[3*m]=m_ParticleCount;		
		data[3*m+1]=0;		
		data[3*m+2]=0;	//channel not used	
	}
	/*
	//distances
	float *distances=new float[m_DirectionCount*m_ParticleCount];
	for(int m=0;m<m_DirectionCount*m_ParticleCount;m++)
	{
		distances[m]=-1;//initial value
	}
*/
	CreateRandomDirections(true);
	//CreateGivenDirections();

	Vector RightVector;
	Vector UpVector;
	Vector ViewDir;

	float particleradius=m_System.m_Emitter.getSize();
	Vector temp;

	for(int d=0;d<m_DirectionCount;d++)
	{
		
		ViewDir=m_Directions[d];
		Calculate_Up_Right_Vector(m_Directions[d],UpVector,RightVector);
			
		for(int i=0;i<m_ParticleCount;i++)
		{
			
			Vector particle0=m_ParticleArray[i].getPosition();
			//adott részecske transzformálása
			
			temp=particle0;
			particle0.x=temp.x*RightVector.x+temp.y*RightVector.y+temp.z*RightVector.z;
			particle0.y=temp.x*UpVector.x+temp.y*UpVector.y+temp.z*UpVector.z;
			particle0.z=temp.x*ViewDir.x+temp.y*ViewDir.y+temp.z*ViewDir.z;

			for(int j=0;j<m_ParticleCount;j++)
			{

				if(i!=j)
				{
					Vector particle=m_ParticleArray[j].getPosition();
					temp=particle;
					//transform
					particle.x=temp.x*RightVector.x+temp.y*RightVector.y+temp.z*RightVector.z;
					particle.y=temp.x*UpVector.x+temp.y*UpVector.y+temp.z*UpVector.z;
					particle.z=temp.x*ViewDir.x+temp.y*ViewDir.y+temp.z*ViewDir.z;

					//visible?
					if(abs(particle.x-particle0.x)<2*particleradius&&abs(particle.y-particle0.y)<2*particleradius)
					{
						float z=particle.z-particle0.z;
						
						if(z>0)
						{
							//if(z<distances[d*m_ParticleCount+i]||distances[d*m_ParticleCount+i]==-1)
							if(z<data[3*d*m_ParticleCount+3*i+1]||data[3*d*m_ParticleCount+3*i+1]==0)
							{
								//distances[d*m_ParticleCount+i]=z;
								data[3*d*m_ParticleCount+3*i]=j;
								data[3*d*m_ParticleCount+3*i+1]=z;
							}
						}						
					}
				}
			}
			
			
		}

	}
		
	glGenTextures(1, &m_VisibilityTexID);
	glBindTexture(GL_TEXTURE_RECTANGLE_NV, m_VisibilityTexID);
	
	/*glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);*/
	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER,
	GL_NEAREST);
	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER,
	GL_NEAREST);

	glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_FLOAT_RGB16_NV, m_ParticleCount,
		m_DirectionCount, 0,GL_RGB , GL_FLOAT,
	data);
	
	delete[] data;		
}

void PreIllumSystem::CreateTauTexture()
{
	float* taus=new float[m_ParticleCount];

	int samplecount=1;
		
	for(int i=0;i<m_ParticleCount;i++)
	{
		int count=0;

		std::list <float> distlist;
		std::list <float>::iterator Iter;

		for(int j=0;j<m_ParticleCount;j++)
		{
			if(i!=j)
			{
				float dist=(m_ParticleArray[j].getPosition()-m_ParticleArray[i].getPosition()).Length();
				distlist.push_back(dist);
			}
		}
		
		distlist.sort();
		float sum=0;
		Iter=distlist.begin();
		for(int h=0;h<samplecount;h++)
		{
			sum+=*Iter;
			Iter++;
		}
		taus[i]=sum/(float)samplecount;
		//fprintf(stderr, "avrdist: %f\n",taus[i]);
	}
	
	glGenTextures(1, &m_TauTextureID);
	glBindTexture(GL_TEXTURE_RECTANGLE_NV, m_TauTextureID);
	
	/*glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);*/
	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER,
	GL_NEAREST);
	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER,
	GL_NEAREST);

	glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_FLOAT_RG16_NV, m_ParticleCount,
		1, 0,GL_RED , GL_FLOAT,
	taus);
	
}

void PreIllumSystem::CreateNearestDirectionTexture()
{
	m_DirectionData=new float[512*512*4];
	for(int i=0;i<512*512*4;i++)
	{
		m_DirectionData[i]=0;
	}

	float distance=0;
	
	float nearestdist=-1;
	float nearestdist2=-1;
	int nearestdirid=-1;
	int nearestdirid2=-1;


	for(int i=0;i<512;i++)
	{
		for(int j=0;j<512;j++)
		{
			float angle1=2*M_PI/512*i-M_PI;
			float angle2=M_PI/512*j-M_PI/2;

			distance=0;
			nearestdist=-1;
			nearestdist2=-1;
			nearestdirid=-1;
			nearestdirid2=-1;

			Vector dir(cos(angle1)*cos(angle2),
							sin(angle2),
							sin(angle1)*cos(angle2));
			dir.Normalize();

			angle1=angle1/6.28+0.5; // 0 -- 1
			angle2=angle2/3.14+0.5; // 0 -- 1

			int coord1=angle1*512;
			int coord2=angle2*512;
			
			for(int k=0;k<m_DirectionCount;k++)
			{
				distance=(dir-m_Directions[k]).Length();
				//nearest direction
				if(distance<nearestdist||nearestdist==-1)
				{
					nearestdist=distance;
					nearestdirid=k;
				}
				else
				{
					//second nearest direction
					if(distance<nearestdist2||nearestdist2==-1)
					{
						nearestdist2=distance;
						nearestdirid2=k;
					}
				}
			}
			//m_DirectionData[i*512+j]=UnitRandom();
			m_DirectionData[j*512*4+4*i]=nearestdirid;
			m_DirectionData[j*512*4+4*i+1]=nearestdirid2;
			//weights
			float weight1=1-(nearestdist/(nearestdist+nearestdist2));
			float weight2=1-(nearestdist2/(nearestdist+nearestdist2));
			m_DirectionData[j*512*4+4*i+2]=weight1;
			m_DirectionData[j*512*4+4*i+3]=weight2;
		}
	}

	
	glGenTextures(1, &m_DirectionsTexID);
	glBindTexture(GL_TEXTURE_2D, m_DirectionsTexID);
	
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
	GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
	GL_NEAREST);

	glTexImage2D(GL_TEXTURE_2D, 0, GL_FLOAT_RGBA16_NV, 512,
	512, 0, GL_RGBA, GL_FLOAT,
	m_DirectionData);

	//delete[] m_DirectionData;	
}

void PreIllumSystem::CreatePhaseTexture()
{
	float* data=new float[m_DirectionCount*m_DirectionCount];

	for(int i=0;i<m_DirectionCount;i++)
	{
		Vector diri=m_Directions[i]*-1;

		for(int j=0;j<m_DirectionCount;j++)
		{
			Vector dirj=m_Directions[j];
			
			data[j*m_DirectionCount+i]=Phase(diri,dirj,m_Symmetry);			
		}
	}

	glGenTextures(1, &m_PhaseTextureID);
	glBindTexture(GL_TEXTURE_RECTANGLE_NV, m_PhaseTextureID);
	
	/*glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);*/
	
	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER,
	GL_NEAREST);
	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER,
	GL_NEAREST);

	glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_LUMINANCE_FLOAT16_ATI, m_DirectionCount,
		m_DirectionCount, 0, GL_LUMINANCE, GL_FLOAT,	data);

	delete[] data;
}

void PreIllumSystem::CreateLVisMap()
{
	
	Texture Bbtex;
	Bbtex.setFilename("kor.bmp");
	Bbtex.LoadImage();

	glBindTexture(GL_TEXTURE_2D,Bbtex.getTextureHandler());
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
		GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
	GL_NEAREST);

	m_LVisMap=new unsigned char[m_DirectionCount*m_ParticleCount];	
	for(int i=0;i<m_DirectionCount*m_ParticleCount;i++)
	{
		m_LVisMap[i]=0;
	}
	
	m_LVisPrograms.SetFragmentTexParam("BbTexture",Bbtex.getTextureHandler());
	
	m_Target.EnablewithColorRelease();
	
	m_LVisPrograms.Enable();    
	
	
	Vector RightVector;
	Vector UpVector;
	
		
	for(int i=0;i<m_DirectionCount;i++)
	{
		Vector CamPos=m_Directions[i]*-1;
		
		Calculate_Up_Right_Vector(CamPos,UpVector,RightVector);
			
		CamPos=CamPos*-1*m_System.getBoundingRadius();		
		
		glClearColor(m_ParticleCount,1,1,1);
		glClearDepth(1.0);
		glEnable(GL_DEPTH_TEST);
		glDepthFunc(GL_LESS);
		glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		glOrtho(-m_System.getBoundingRadius(),m_System.getBoundingRadius(),-m_System.getBoundingRadius(),m_System.getBoundingRadius(),0,2*m_System.getBoundingRadius());
		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();
		gluLookAt(CamPos.x,CamPos.y,CamPos.z,0,0,0,UpVector.x,UpVector.y,UpVector.z);
		//render particles
		m_TempCamera.SetPosition(CamPos);
		
		m_System.SortFromCamera(&m_TempCamera,true,true);
		glEnable(GL_BLEND);
		glDisable(GL_DEPTH_TEST);
		
		glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
		int pointsize=m_System.m_Emitter.getSize()*m_LightWindowSize/m_System.getBoundingRadius();
		glPointSize(pointsize);	
		
		m_System.RenderAsPoints(true);

		glReadPixels(0,0,m_LightWindowSize,m_LightWindowSize,GL_RED,GL_FLOAT,m_Pixels);
		
		for(int j=0;j<m_LightWindowSize*m_LightWindowSize;j++)
		{
			if(m_Pixels[j]<m_ParticleCount)
			{				
				m_LVisMap[i*m_ParticleCount+(int)m_Pixels[j]]+=50;
				//m_LVisMap[i*m_ParticleCount+(int)m_Pixels[j]]=255;
			}
		}
	}

	glDisable(GL_BLEND);
	m_LVisPrograms.DisableFragmentTexParam("BbTexture");	
	m_LVisPrograms.Disable();

	m_Target.DisablewithColorBind();

	glGenTextures(1, &m_LVisMapID);
	glBindTexture(GL_TEXTURE_RECTANGLE_NV, m_LVisMapID);
	
	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER,
		GL_NEAREST);
	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER,
	GL_NEAREST);
	
	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S,
	GL_CLAMP);
	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T,
	GL_CLAMP);

	glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_LUMINANCE,m_ParticleCount,
		m_DirectionCount, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE,m_LVisMap);

	delete[] m_LVisMap;
}

void PreIllumSystem::FindVisiblesWithRendering(Vector LightPosition,int row)
{
	
	
	for(int i=0;i<m_ParticleCount;i++)
	{
		m_LRendVisMap[row*m_ParticleCount+i]=0;
	}	
	
	m_LVisPrograms.SetFragmentTexParam("BbTexture",m_Bbtex.getTextureHandler());
	
	m_Target.EnablewithColorRelease();

	m_LVisPrograms.Enable();

	
	Vector RightVector;
	Vector UpVector;

		Vector CamPos=LightPosition;
		CamPos.Normalize();
		CamPos=CamPos*-1;

		Calculate_Up_Right_Vector(CamPos,UpVector,RightVector);
			
		CamPos=CamPos*-1*m_System.getBoundingRadius();		
		
		glClearColor(m_ParticleCount,1,1,1);
		glClearDepth(1.0);
		glEnable(GL_DEPTH_TEST);
		glDepthFunc(GL_LESS);
		glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		glOrtho(-m_System.getBoundingRadius(),m_System.getBoundingRadius(),-m_System.getBoundingRadius(),m_System.getBoundingRadius(),0,2*m_System.getBoundingRadius());
		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();
		gluLookAt(CamPos.x,CamPos.y,CamPos.z,0,0,0,UpVector.x,UpVector.y,UpVector.z);
		
		//render particles
		m_TempCamera.SetPosition(CamPos);		
		m_System.SortFromCamera(&m_TempCamera,true,true);
		glEnable(GL_BLEND);
		glDisable(GL_DEPTH_TEST);
		glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
		
		float pointsize=m_LightWindowSize/m_System.getBoundingRadius();
		glPointSize(pointsize);	
		
		//glDisable(GL_BLEND);
		//glEnable(GL_DEPTH_TEST);
		m_System.RenderAsPoints(true);

		glReadPixels(0,0,m_LightWindowSize,m_LightWindowSize,GL_RED,GL_FLOAT,m_Pixels);
		
		for(int j=0;j<m_LightWindowSize*m_LightWindowSize;j++)
		{
			if(m_Pixels[j]<m_ParticleCount)
			{				
				m_LRendVisMap[m_ParticleCount*row+(unsigned int)m_Pixels[j]]=255;
				//m_LRendVisMap[(unsigned int)m_Pixels[j]]+=100;
			}
		}
	
	glDisable(GL_BLEND);
		
	m_LVisPrograms.DisableFragmentTexParam("BbTexture");
	m_LVisPrograms.Disable();
	
	m_Target.DisablewithColorBind();

	glBindTexture(GL_TEXTURE_RECTANGLE_NV,m_RenderedVisID);	
	
	glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_LUMINANCE,m_ParticleCount,
		2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE,m_LRendVisMap);

}

void PreIllumSystem::Init(int particlecount,int directioncount)
{
	m_ParticleCount=particlecount;
	m_DirectionCount=directioncount;

	m_TexRectPrograms.SetProgramFiles("SimplePrograms.cg","SimplePrograms.cg");
	m_TexRectPrograms.SetProgramEntries("VertexProgram","FragmentProgram");
	m_TexRectPrograms.InitPrograms();
	
	m_LightIllumPrograms.SetProgramFiles("LightIlluminatePrograms.cg","LightIlluminatePrograms.cg");
	//m_LightIllumPrograms.SetProgramFiles("InternalLightIlluminatePrograms.cg","InternalLightIlluminatePrograms.cg");
	m_LightIllumPrograms.SetProgramEntries("VertexProgram","FragmentProgram");
	m_LightIllumPrograms.InitPrograms();
	
    m_IllumIteratePrograms.SetProgramFiles("IllumIteratePrograms.cg","IllumIteratePrograms.cg");
	m_IllumIteratePrograms.SetProgramEntries("VertexProgram","FragmentProgram");
	m_IllumIteratePrograms.InitPrograms();
	
	m_EyeRadPrograms.SetProgramFiles("FinalizeIllumMap.cg","FinalizeIllumMap.cg");
	m_EyeRadPrograms.SetProgramEntries("VertexProgram","FragmentProgram");
	m_EyeRadPrograms.InitPrograms();

	m_LVisPrograms.SetProgramFiles("LVisDisplay.cg","LVisDisplay.cg");
	m_LVisPrograms.SetProgramEntries("VertexProgram","FragmentProgram");
	m_LVisPrograms.InitPrograms();	
	
	m_FinalRenderPrograms.SetProgramFiles("FinalDisplay.cg","FinalDisplay.cg");
	m_FinalRenderPrograms.SetProgramEntries("VertexProgram","FragmentProgram");
	m_FinalRenderPrograms.InitPrograms();
		
	m_DirectIlumTexture.Initialize(m_ParticleCount,m_DirectionCount,"rgb float=16 textureRECT");
	m_IllumTexture.Initialize(m_ParticleCount,m_DirectionCount,"rgb float=16 textureRECT");
	m_IllumTexture2.Initialize(m_ParticleCount,m_DirectionCount,"rgb float=16 textureRECT");
	m_EyeRadTexture.Initialize(m_ParticleCount,1,"rgb float=16 textureRECT");
	m_Target.Initialize(m_LightWindowSize,m_LightWindowSize,"rgba float=16 depth=16 textureRECT");
	m_ImpostorTexture.Initialize(512,512,"rgba texture2D",false);

	m_Pixels=new float[m_LightWindowSize*m_LightWindowSize];
	m_LRendVisMap=new unsigned char[m_ParticleCount*2];

	InitSystem(particlecount,directioncount);

	m_BillboardTexture.setFilename("proba.dds");
	m_BillboardTexture.LoadImage();	

	m_Bbtex.setFilename("kor.bmp");
	m_Bbtex.LoadImage();

	glBindTexture(GL_TEXTURE_2D,m_Bbtex.getTextureHandler());
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
		GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
	GL_NEAREST);

	glGenTextures(1,&m_RenderedVisID);
	glBindTexture(GL_TEXTURE_RECTANGLE_NV,m_RenderedVisID);	
	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER,
		GL_NEAREST);
	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER,
	GL_NEAREST);	
	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S,
	GL_CLAMP);
	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T,
	GL_CLAMP);

	m_DirectIlumTexture.EnablewithColorRelease();
	glClearColor(0,0,0,0);//Emission
	glClear(GL_COLOR_BUFFER_BIT);
	m_DirectIlumTexture.DisablewithColorBind();		
	m_EyeRadTexture.EnablewithColorRelease();
	glClearColor(0,0,0,0);
	glClear(GL_COLOR_BUFFER_BIT);
	m_EyeRadTexture.DisablewithColorBind();

}	

void PreIllumSystem::InitSystem(int particlecount,int directioncount)
{
	m_System.m_Emitter.setPositionsFile("cloud.txt");
	m_System.m_Emitter.setOffset(0.15);
	m_System.m_Emitter.setPosition(Vector(-0.625,-6,-1.75));
	
	m_System.m_Emitter.setRadius(0.2);
	//7,4,5
	
	m_System.m_Emitter.setSize(0.95);
	m_System.m_Emitter.setSizevariation(0.9);
	m_System.m_Emitter.setEmissionRate(0);
	m_System.setQuota(m_ParticleCount);
	m_System.m_Emitter.setTimeToLive(0);
	m_System.m_Emitter.setTimeToLiveVariation(0);
	m_System.m_Emitter.setVelocity(0);
	m_System.m_Emitter.setVelocityVariation(0);

	m_System.RefreshParticles(0,0);
	
	m_System.RefreshCamera(m_EyeCamera);
	m_System.RefrBRadius_Dist();
	m_System.RefreshBuffer(false);
	
	//m_System.SortFromCamera(m_EyeCamera,true,true);

	m_ParticleArray=m_System.getParticleArray();
	m_PositionArray=m_System.getVertexBuffer();

	unsigned int lasttime=timeGetTime();
	fprintf(stderr, "Building Visibility Map: ..");
	this->CreateVisibilityTexture();
	unsigned int thistime=timeGetTime();
	float elapsed=(float)(thistime-lasttime)/1000.0f;
	lasttime=thistime;
	fprintf(stderr, "OK %fs\n",elapsed);
	

	fprintf(stderr, "Building Nearest Directions Map: ..");
	this->CreateNearestDirectionTexture();
	thistime=timeGetTime();
	elapsed=(float)(thistime-lasttime)/1000.0f;
	lasttime=thistime;
	fprintf(stderr, "OK %fs\n",elapsed);

	fprintf(stderr, "Building Phase Function Map: ..");
	CreatePhaseTexture();
	thistime=timeGetTime();
	elapsed=(float)(thistime-lasttime)/1000.0f;
	lasttime=thistime;
	fprintf(stderr, "OK %fs\n",elapsed);

	fprintf(stderr, "Building Tau Map: ..");
	CreateTauTexture();
	thistime=timeGetTime();
	elapsed=(float)(thistime-lasttime)/1000.0f;
	lasttime=thistime;
	fprintf(stderr, "OK %fs\n",elapsed);
/*
	fprintf(stderr, "Building Light Visibility Map: ..");
	CreateLVisMap();
	thistime=timeGetTime();
	elapsed=(float)(thistime-lasttime)/1000.0f;
	lasttime=thistime;
	fprintf(stderr, "OK %fs\n",elapsed);
*/
	m_IllumColorTex=&m_IllumTexture2;
	m_IllumRenderTex=&m_IllumTexture;

	m_IllumTexture2.EnablewithColorRelease();
		glClearColor(0,0,0,0);
		glClear(GL_COLOR_BUFFER_BIT);
	m_IllumTexture2.DisablewithColorBind();
	
}

char* PreIllumSystem::DisplayTexture(int tex)
{
	char* displaytext;
	int dimX,dimY;
	unsigned int TexID;
	float MaxValue;

	switch(tex)
	{
	case 1: //LightView
	/*	dimX=m_ParticleCount;
		dimY=m_DirectionCount;
		TexID=m_VisibilityTexID;
		MaxValue=m_ParticleCount;*/
		dimX=m_LightWindowSize;
		dimY=m_LightWindowSize;
		TexID=m_Target.getColorTextureID();
		MaxValue=m_ParticleCount;
		
		displaytext="LightView";
		break;	

	case 2: //LightVisibility
		dimX=m_ParticleCount;
		dimY=2;
		TexID=m_RenderedVisID;
		MaxValue=1;
		displaytext="LightVisibility";
		break;	

	case 3: //DirectIllumTexture
		dimX=m_ParticleCount;
		dimY=m_DirectionCount;
		TexID=m_DirectIlumTexture.getColorTextureID();
		MaxValue=1;
		displaytext="DirectIllumTexture";
		break;	

	case 4: //IllumTexture1
		dimX=m_ParticleCount;
		dimY=m_DirectionCount;
		TexID=m_IllumTexture.getColorTextureID();
		MaxValue=1;
		displaytext="IllumTexture1";
		break;	

	case 5: //IllumTexture2
		dimX=m_ParticleCount;
		dimY=m_DirectionCount;
		TexID=m_IllumTexture2.getColorTextureID();
		MaxValue=1;
		displaytext="IllumTexture2";
		break;

	case 6: //EyeRadTexture
		dimX=m_ParticleCount;
		dimY=1;
		TexID=m_EyeRadTexture.getColorTextureID();
		MaxValue=1;
		displaytext="EyeRadTexture";
		break;	
	}

	m_TexRectPrograms.Enable();

	m_TexRectPrograms.SetFragmentTexParam("Texture",TexID);
	m_TexRectPrograms.SetFragmentParam1f("invmaxvalue",1.0/MaxValue);

	m_ScreenQuad.DisplayScreenQuad(dimX,dimY);

	m_TexRectPrograms.Disable();

	return displaytext;
}

void PreIllumSystem::Refresh(Vector lightpos,Vector lightpos2,Vector lightcolor,Vector lightcolor2)
{	
/*
	m_IllumColorTex->EnablewithColorRelease();
	glClearColor(0,0,0,0);
	glClear(GL_COLOR_BUFFER_BIT);
	m_IllumColorTex->DisablewithColorBind();
*/
	static bool first=true;
	
	////Light1
	FindVisiblesWithRendering(lightpos,0);	
	GetNearestDirection(lightpos);
	int lastNearest=m_NearestDir;	
	m_NearestDir=lastNearest;	
	m_LightPosition=lightpos;	
	m_LightColor=lightcolor;

	if(first)
	{
		////Light2
		FindVisiblesWithRendering(lightpos2,1);
		GetNearestDirection(lightpos2);
		int thisNearest=m_NearestDir;
		m_NearestDir2=thisNearest;
		m_LightPosition2=lightpos2;	
		
		first=false;
	}
	m_LightColor2=lightcolor2;

	RefreshDirectIllumTexture();

	for(int i=0;i<m_IterateCount;i++)
	{
		Iterate();
	}
	
	GetNearestDirection(m_EyeCamera->getPosition()*-1);

	CreateEyeRadTexture();
	
}

void PreIllumSystem::RefreshDirectIllumTexture()
{	
	m_LightIllumPrograms.SetFragmentTexParam("LVisMap",m_RenderedVisID);
	//m_LightIllumPrograms.SetFragmentTexParam("LVisMap",m_LVisMapID);
	m_LightIllumPrograms.SetFragmentTexParam("Phase",m_PhaseTextureID);
	m_LightIllumPrograms.SetFragmentParam3f("LightRad",m_LightColor.x,m_LightColor.y,m_LightColor.z);
	m_LightIllumPrograms.SetFragmentParam3f("LightRad2",m_LightColor2.x,m_LightColor2.y,m_LightColor2.z);
	m_LightIllumPrograms.SetFragmentParam4f("LightDirsWeights",m_NearestDir,m_NearestDir2,m_Weight1,m_Weight2);
	m_LightIllumPrograms.SetFragmentParam2f("Alb_Op",m_Albedo,m_Opacity);
	
	m_DirectIlumTexture.EnablewithColorRelease();
	//glClearColor(0,0,0,0);
	//glClear(GL_COLOR_BUFFER_BIT);
	glBlendColorEXT(1,1,1,0.08);
	//glEnable(GL_BLEND);
	//glDisable(GL_BLEND);
	glBlendFunc(GL_CONSTANT_ALPHA_EXT,GL_ONE_MINUS_CONSTANT_ALPHA_EXT);
	
	m_LightIllumPrograms.Enable(); 	

	m_ScreenQuad.DisplayScreenQuad(m_ParticleCount,m_DirectionCount);

	m_LightIllumPrograms.DisableFragmentTexParam("LVisMap");
	m_LightIllumPrograms.DisableFragmentTexParam("Phase");
	m_LightIllumPrograms.Disable();
	
	m_DirectIlumTexture.DisablewithColorBind();		
}

void PreIllumSystem::Iterate()
{	
	m_IllumIteratePrograms.SetFragmentTexParam("IllumTexture",m_IllumColorTex->getColorTextureID());
	m_IllumIteratePrograms.SetFragmentTexParam("VisMap",m_VisibilityTexID);
	m_IllumIteratePrograms.SetFragmentTexParam("TauTexture",m_TauTextureID);
	m_IllumIteratePrograms.SetFragmentTexParam("DirectIllum",m_DirectIlumTexture.getColorTextureID());
	m_IllumIteratePrograms.SetFragmentParam3f("Alb_Op",m_Albedo,m_Opacity,m_Albedo*(4*M_PI)/m_DirectionCount);
	m_IllumIteratePrograms.SetFragmentParam3f("SkyColor",m_SkyColor.x,m_SkyColor.y,m_SkyColor.z);
	m_IllumIteratePrograms.SetFragmentTexParam("Phase",m_PhaseTextureID);
	
	m_IllumRenderTex->EnablewithColorRelease();

	m_IllumIteratePrograms.Enable();
	
	//glClearColor(0,0,0,0);
	//glClear(GL_COLOR_BUFFER_BIT);
	//glDisable(GL_BLEND);
	
	m_ScreenQuad.DisplayScreenQuad(m_ParticleCount,m_DirectionCount);
	
	m_IllumIteratePrograms.DisableFragmentTexParam("IllumTexture");
	m_IllumIteratePrograms.DisableFragmentTexParam("VisMap");
	m_IllumIteratePrograms.DisableFragmentTexParam("DirectIllum");
	m_IllumIteratePrograms.DisableFragmentTexParam("Phase");
	m_IllumIteratePrograms.Disable();	
		
	m_IllumRenderTex->DisablewithColorBind();


	RenderTexture* nextcolor=m_IllumRenderTex;
	m_IllumRenderTex=m_IllumColorTex;
	m_IllumColorTex=nextcolor;
	
}

void PreIllumSystem::CreateEyeRadTexture()
{
	m_EyeRadPrograms.SetFragmentTexParam("DirectIllumTexture",m_DirectIlumTexture.getColorTextureID());
	m_EyeRadPrograms.SetFragmentTexParam("IllumTexture",m_IllumColorTex->getColorTextureID());
	m_EyeRadPrograms.SetFragmentTexParam("Phase",m_PhaseTextureID);
	m_EyeRadPrograms.SetFragmentTexParam("TauTexture",m_TauTextureID);	
	m_EyeRadPrograms.SetFragmentParam4f("EyeDirsWeights",m_NearestDir,m_NearestDir2,m_Weight1,m_Weight2);
	float ize=m_Albedo*(4*M_PI)/(float)m_DirectionCount;
	m_EyeRadPrograms.SetFragmentParam3f("Alb_Op",m_Albedo,m_Opacity,ize);
	
	m_EyeRadTexture.EnablewithColorRelease();

	glBlendColorEXT(1,1,1,0.06);
	glEnable(GL_BLEND);
	glBlendFunc(GL_CONSTANT_ALPHA_EXT,GL_ONE_MINUS_CONSTANT_ALPHA_EXT);
	
	m_EyeRadPrograms.Enable();
	
	m_ScreenQuad.DisplayScreenQuad(m_ParticleCount,1);
	m_EyeRadPrograms.DisableFragmentTexParam("DirectIllumTexture");
	m_EyeRadPrograms.DisableFragmentTexParam("IllumTexture");
	m_EyeRadPrograms.DisableFragmentTexParam("Phase");
	m_EyeRadPrograms.Disable();

	m_EyeRadTexture.DisablewithColorBind();
}

void PreIllumSystem::RenderToImpostor()
{
	m_ImpostorTexture.EnablewithColorRelease();
	glClearColor(0,0,0,0);
	glClear(GL_COLOR_BUFFER_BIT);
	m_CameraImpostor.ApplyCameraTransform();

	m_FinalRenderPrograms.Enable();
	
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
	glPointSize(1000*m_System.m_Emitter.getSize());
	
	m_FinalRenderPrograms.SetFragmentTexParam("BbTexture",m_BillboardTexture.getTextureHandler());
	m_FinalRenderPrograms.SetFragmentTexParam("IllumTex",m_EyeRadTexture.getColorTextureID());
		
	//sort particles	
	m_System.SortFromCamera(m_EyeCamera,true,true);
	
	glDepthMask(GL_FALSE);
	//glDisable(GL_BLEND);
	m_System.RenderAsPoints(true);
	
	glDepthMask(GL_TRUE);
	glDisable(GL_BLEND);
	
	m_FinalRenderPrograms.DisableFragmentTexParam("BbTexture");
	m_FinalRenderPrograms.DisableFragmentTexParam("IllumTex");
	m_FinalRenderPrograms.Disable();

	m_ImpostorTexture.DisablewithColorBind();
}

void PreIllumSystem::Display()
{
	m_FinalRenderPrograms.Enable();
	
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
	glPointSize(1000);
	
	m_FinalRenderPrograms.SetFragmentTexParam("VisMap",m_VisibilityTexID);
	m_FinalRenderPrograms.SetFragmentTexParam("BbTexture",m_BillboardTexture.getTextureHandler());
	m_FinalRenderPrograms.SetFragmentTexParam("IllumTex",m_EyeRadTexture.getColorTextureID());
	m_FinalRenderPrograms.SetVertexParam1f("Opacity",m_Opacity);
		
	//sort particles	
	m_System.SortFromCamera(m_EyeCamera,true,true);
	
	glDepthMask(GL_FALSE);
	//glDisable(GL_BLEND);
	m_System.RenderAsPoints(true);
	
	glDepthMask(GL_TRUE);
	glDisable(GL_BLEND);
	
	m_FinalRenderPrograms.DisableFragmentTexParam("BbTexture");
	m_FinalRenderPrograms.DisableFragmentTexParam("IllumTex");
	m_FinalRenderPrograms.Disable();
}
/*
void PreIllumSystem::Display()
{
	m_FinalRenderPrograms.Enable();
	
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
	glPointSize(1000*m_System.m_Emitter.getSize());
	
	m_FinalRenderPrograms.SetFragmentTexParam("BbTexture",m_BillboardTexture.getTextureHandler());
	m_FinalRenderPrograms.SetFragmentTexParam("LVisMap",m_LVisMapID);
	m_FinalRenderPrograms.SetFragmentParam1f("Ldir",(float)m_NearestDir);	
	
	//sort particles	
	m_System.SortFromCamera(m_EyeCamera,true,true);
	
	glDepthMask(GL_FALSE);
	//glDisable(GL_BLEND);
	m_System.RenderAsPoints(true);
	
	glDepthMask(GL_TRUE);
	glDisable(GL_BLEND);
	
	m_FinalRenderPrograms.DisableFragmentTexParam("BbTexture");
	m_FinalRenderPrograms.DisableFragmentTexParam("LVisMap");
	m_FinalRenderPrograms.Disable();
}*/