// GlutRTTAlap.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <random.h>
#include <stdio.h>
#include <My3DGraphRes\ThirdPersonCamera.h>


bool headsupdisplay=false;
bool showplane=true;
Scene theScene;
Scene thePlane;
Vector planeRotate;
Vector planePosition;
float planespeed=0;
float* transformmatrix=new float[16];
bool isrecording=false;
int framenum=0;
AdvancedParticleSystem theSystem;
//ThirdPersonCamera theCamera;
Camera theCamera;

SkyBox theSkyBox;

Vector LightPos(12,74,-33);
Vector LightColor(.85,.90,0.93);
float angle=0;

unsigned int lastTime;
unsigned int frameRate=0;
unsigned int frameRateLast=0;
unsigned int timeElapsed;
unsigned int LastDtTime=0;
unsigned int Dt=0;
bool start=true;
int animtime=0;

int x0=-1;
int y00=-1;

char* rendermodes[]={"No shading","Single Scattering","Multiple Forward","Multiple Anisotropic"	};

Impostor ScreenQuad;
RenderTexture PhaseTexture;
CgProgram PhaseProgram;

RenderTexture AngleTexture;
CgProgram AngleProgram;

int displaytex=0;

TransformAnimation cameraanim;
TransformAnimation planeanim;
bool animplaying=true;
int currentframe=0;
int framerate=30;//fps
float oneframeduration=1000.0f/30.0f;
float interpolationvalue=0;

void drawFrameRate(char *str, void *font, GLclampf r, GLclampf g, GLclampf b,
              GLfloat x, GLfloat y) {
  /* font: font to use, e.g., GLUT_BITMAP_HELVETICA_10
     r, g, b: text colour
     x, y: text position in window: range [0,0] (bottom left of window)
           to [1,1] (top right of window). */

  glDisable(GL_TEXTURE_2D);
  char *ch;
  GLint matrixMode;
  GLboolean lightingOn;

 lightingOn= glIsEnabled(GL_LIGHTING);        /* lighting on? */
 if (lightingOn) glDisable(GL_LIGHTING);

 glGetIntegerv(GL_MATRIX_MODE, &matrixMode);  /* matrix mode? */

 glMatrixMode(GL_PROJECTION);
 glPushMatrix();
   glLoadIdentity();
   gluOrtho2D(0.0, 1.0, 0.0, 1.0);
   glMatrixMode(GL_MODELVIEW);
   glPushMatrix();
     glLoadIdentity();
     glPushAttrib(GL_COLOR_BUFFER_BIT);       /* save current colour */
       glColor4f(r, g, b,1);
       glRasterPos3f(x, y, 0.0);
       for(ch= str; *ch; ch++) {
          glutBitmapCharacter(font, (int)*ch);
       }
     glPopAttrib();
   glPopMatrix();
   glMatrixMode(GL_PROJECTION);
 glPopMatrix();
 glMatrixMode(matrixMode);
 if (lightingOn) glEnable(GL_LIGHTING);
 glColor4f(1, 1, 1,1);
 glEnable(GL_TEXTURE_2D);
}

void calculateFrameRate()
{
	unsigned int thisTime=(unsigned)timeGetTime();
	timeElapsed=thisTime-lastTime;
	Dt=thisTime-LastDtTime;
	LastDtTime=thisTime;
	frameRate++;
	if(timeElapsed>1000)
	{
		lastTime=thisTime;
		frameRateLast=frameRate;
		frameRate=0;
	}
	if(animplaying)
	{
//calculate animation
	currentframe++;
		if(currentframe==planeanim.framecount)
		{
			currentframe=0;
		}
	}
}

void RenderPhaseTexture()
{
	PhaseTexture.EnableTarget();
	PhaseProgram.Enable();

	glClearColor(1,1,1,1);
	glClear(GL_COLOR_BUFFER_BIT);

	glDisable(GL_DEPTH_TEST);
	ScreenQuad.DisplayScreenQuad();
	glEnable(GL_DEPTH_TEST);

	PhaseProgram.Disable();
	PhaseTexture.DisableTarget();
	PhaseTexture.BindColorBuffer();

	//angle texture

	AngleTexture.EnableTarget();
	AngleProgram.Enable();

	glClearColor(1,1,1,1);
	glClear(GL_COLOR_BUFFER_BIT);

	glDisable(GL_DEPTH_TEST);
	ScreenQuad.DisplayScreenQuad();
	glEnable(GL_DEPTH_TEST);

	AngleProgram.Disable();
	AngleTexture.DisableTarget();
	AngleTexture.BindColorBuffer();

	
}

static void display() 
{
	calculateFrameRate();
	
	angle+=0.4;

	if(start)
	{
		Dt=0;timeElapsed=0;
		start=false;
	}
	float x=cos(angle/180*3.14)*2.5;
	float y=sin(angle/180*3.14)*2.5;
		
	theScene.m_Lights[0].m_Position=Vector(60,40,-80);
	LightPos=theScene.m_Lights[0].m_Position;

	theSystem.m_LightColor=LightColor;
	
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	
	theSkyBox.Display(theCamera);

	if(animplaying)
	{
		theCamera.m_Orientation=cameraanim.getRotate(currentframe);
		theCamera.m_EyePosition=cameraanim.getTranslate(currentframe);
		theCamera.SetViewandProjectionNew();	
	}
	else
	{
		theCamera.SetViewandProjectionNew();
	}
	

	glPushMatrix();
	//glTranslatef(0,-20,0);
	glShadeModel(GL_SMOOTH);
	//glScalef(1,1.5,1);
	theScene.Display(true);		
	glShadeModel(GL_FLAT);
	glPopMatrix();


	if(showplane)
	{
		theSystem.theScene=&thePlane;
		//if(animplaying)
		//{
			glMatrixMode(GL_MODELVIEW);
			glPushMatrix();
			
			Vector trans=planeanim.getTranslate(currentframe);
			glTranslatef(trans.x,trans.y,trans.z);			
			
			Vector rot=planeanim.getRotate(currentframe);
			glRotatef(rot.z,0,0,1);
			glRotatef(rot.y,0,1,0);
			glRotatef(rot.x,1,0,0);
			
		
			//	glMultMatrixf(planeanim.getMatrix(currentframe));
			glGetFloatv(GL_MODELVIEW_MATRIX,transformmatrix);
			
			thePlane.Display(false);
			
			glPopMatrix();

			theSystem.setSceneTransformMatrix(transformmatrix);
		/*}
		else
		{
			glMatrixMode(GL_MODELVIEW);
			glPushMatrix();
			glLoadIdentity();

			//glLightfv(GL_LIGHT0,GL_POSITION,(LightPos-theCamera.getPosition()).GetArrayf());

			glTranslatef(0,-0.3,-(2+planespeed/2));
			glRotatef(planeRotate.z,0,0,1);
			glRotatef(planeRotate.x,1,0,0);
			glRotatef(10,1,0,0);
			glRotatef(180,0,1,0);
			glGetFloatv(GL_MODELVIEW_MATRIX,transformmatrix);
			thePlane.Display(false);
			glPopMatrix();

			theSystem.setSceneTransformMatrix(transformmatrix);
		}*/
	}
	else
	{
		theSystem.m_HasSceneTransformMatrix=false;
		theSystem.theScene=&theScene;
	}
	
	glEnable(GL_DEPTH_TEST);	
	
	glDisable(GL_LIGHTING);
/*
	//light
	glPushMatrix();
	glColor3f(1,0.7,0);
	glTranslatef(LightPos.x,LightPos.y,LightPos.z);
	glutSolidSphere(3,6,6);
	glPopMatrix();
*/	
	glDisable(GL_BLEND);
	
	theSystem.Refresh(&theCamera,LightPos,Dt,timeElapsed);
	
	theSystem.Display(&theCamera,LightPos);
	
	//theSystem.displayillum(&theCamera);
	//theSystem.displaytexture(displaytex);	
	
	char fr[255];
	sprintf( fr,"FPS:%u Density: %f Albedo: %f Symmetry: %f Rendermode:%s",frameRateLast,theSystem.transparency,theSystem.albedo,theSystem.symmetry,rendermodes[theSystem.m_PSys_RenderMode]);
	//sprintf( fr,"FPS:%u Density: %f Albedo: %f Symmetry: %f Rendermode:%i",frameRateLast,theSystem.transparency,theSystem.albedo,theSystem.symmetry,displaytex);
	
	if(headsupdisplay)
	drawFrameRate(fr, GLUT_BITMAP_HELVETICA_10, 1.0f, 0.0f, 1.0f, 0.05, 0.95 );

	if(isrecording)
	{
		framenum++;
        ilutGLScreenie();
		char fname[25];
		sprintf( fname,"smoke%i.tga",framenum);
		rename("screen0.tga",fname);

	}

	glutSwapBuffers();

	glutReportErrors();
//	glutPostRedisplay();
}	


void idle()
{	
    glutPostRedisplay();
}

void getExts(void)
{
  if(! glh_init_extensions(
                          "GL_ARB_multitexture "
                          "WGL_ARB_pbuffer "
                          "WGL_ARB_pixel_format "
                          "WGL_ARB_render_texture "
                          "GL_NV_vertex_program "
                          "GL_NV_fragment_program "
						//  "GL_ARB_vertex_program "
						//  "GL_ARB_fragment_program "
                       //   "WGL_NV_float_buffer"
						"GL_ARB_vertex_buffer_object "
						"GL_ATI_draw_buffers "
						"GL_EXT_blend_equation_separate "
						"GL_EXT_blend_minmax "
						"GL_EXT_blend_func_separate "
						"GL_EXT_blend_color "
						//"GL_EXT_pixel_buffer_object "
						  )) {
    fprintf(stderr, "Error - required extensions were not supported: %s", glh_get_unsupported_extensions());
	exit(-1);
  }
}

void specialkey(int key, int x, int y)
{
	switch(key)
	{
		case GLUT_KEY_LEFT:
			theCamera.Rotate(AXIS_Y,1);
			break;
		case GLUT_KEY_RIGHT:
			theCamera.Rotate(AXIS_Y,-1);
			break;
		case GLUT_KEY_UP:
			theCamera.Rotate(AXIS_X,1);
			break;
		case GLUT_KEY_DOWN:
			theCamera.Rotate(AXIS_X,-1);
			break;

		case GLUT_KEY_F2:
			if(glutGetModifiers())
				theSystem.DecreaseAlbedo();
			else
				theSystem.IncreaseAlbedo();
			break;
		case GLUT_KEY_F1:
			if(glutGetModifiers())
				theSystem.DecreaseTransparency();
			else
				theSystem.IncreaseTransparency();
			break;		
		case GLUT_KEY_F3:
			if(glutGetModifiers())
				theSystem.DecreaseSymmetry();
			else
				theSystem.IncreaseSymmetry();
			break;

	}
}

static void keyboard(unsigned char key, int x, int y)
{
   
	switch(key)
	{		
		case 27:
			exit(0);
			break;

		case 'w':
			theCamera.Move(AXIS_Z,0.5);
			//planespeed+=0.35;
			
			break;
		case 's':
			theCamera.Move(AXIS_Z,-0.5);
			//planespeed-=0.15;
			break;
		case 'd':
			theCamera.Move(AXIS_X,0.5);
			break;
		case 'a':
			theCamera.Move(AXIS_X,-0.5);
			break;

		case 'r':
			theCamera.Move(AXIS_Y,0.5);
			break;
		case 'f':
			theCamera.Move(AXIS_Y,-0.5);
			break;

		case 'm':
			ilutGLScreenie();//screenshot
			break;
	
		case 'i':
			theSystem.depthcalc=!theSystem.depthcalc;
			break;
		case 'L':
				theSystem.m_PSys_RenderMode--;
				if(theSystem.m_PSys_RenderMode<0)theSystem.m_PSys_RenderMode=3;
			break;
		case 'l':
				theSystem.m_PSys_RenderMode++;
				if(theSystem.m_PSys_RenderMode>2)theSystem.m_PSys_RenderMode=0;
			break;
		case 'k':
			displaytex++;
				if(displaytex>2)displaytex=0;
			break;

		case 'p':
			isrecording=!isrecording;
			break;
		case 'o':
			//if(!animplaying)currentframe=0;
			animplaying=!animplaying;
			break;

		case 'h':
			headsupdisplay=!headsupdisplay;
			break;

		case 'j':
			showplane=!showplane;
			break;
		
	}
}

void mouseMove(int x, int y)
{
	if(x0==-1)
	{
		x0=x;
		y00=y;
	}

	int dx=x-x0;
	int dy=y-y00;

	theCamera.Rotate(Vector(0,((float)-dx)/10.0,0));
	theCamera.Rotate(Vector(((float)-dy)/10.0,0,0));

	x0=x;
	y00=y;
}
void mouseButton(int button, int state,int x, int y)
{
	if(state==GLUT_UP)
	{
		x0=-1;
		y00=-1;
	}
}


void initOpenGL()
{
	srand( (unsigned)timeGetTime() );

	glEnable(GL_DEPTH_TEST);
	glClearDepth(1.0);
	glClearColor(0,0,0, 0.0);
	glEnable(GL_BLEND);	

	getExts();

	theSystem.Initialize();
	theSystem.m_BillboardTexture.setFilename("gradient.png");
	//theSystem.m_BillboardTexture.setFilename("pamacs.dds");
	theSystem.m_BillboardTexture.LoadImage();
	theSystem.m_BbFrontDepthTexture.setFilename("2.dds");
	theSystem.m_BbFrontDepthTexture.LoadImage();
	theSystem.m_BbBackDepthTexture.setFilename("3.dds");
	theSystem.m_BbBackDepthTexture.LoadImage();

	PhaseTexture.Initialize(256,256,"r float=16 textureRECT");
	PhaseProgram.SetProgramFiles("PhaseFunction.cg","PhaseFunction.cg");
	PhaseProgram.SetProgramEntries("VertexProgram","FragmentProgram");
	PhaseProgram.InitPrograms();

	AngleTexture.Initialize(256,256,"r float=16 textureRECT");
	AngleProgram.SetProgramFiles("Angle.cg","Angle.cg");
	AngleProgram.SetProgramEntries("VertexProgram","FragmentProgram");
	AngleProgram.InitPrograms();

	theCamera.setFarClipDistance(300);
	theCamera.setFovX(54.43);
	

	RenderPhaseTexture();
	theSystem.PhaseTexID=PhaseTexture.getColorTextureID();
	theSystem.AngleTexID=AngleTexture.getColorTextureID();

	theSkyBox.Initialize("greydream");

	theScene.Load("hegyek.txt");
	thePlane.Load("plane3.txt");

	cameraanim.Load("cameraanim.txt");
	planeanim.Load("planeanim.txt");
}

int _tmain(int argc, _TCHAR* argv[])
{
	glutInit(&argc, argv);
	ilInit();
	iluInit();
	ilutRenderer(ILUT_OPENGL);
	
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(512, 512);
    glutCreateWindow("GlutRTTAlap");

	initOpenGL();
		
	glutSpecialFunc(specialkey);
	glutKeyboardFunc(keyboard);
	glutMotionFunc(mouseMove);
	glutMouseFunc(mouseButton);
    glutDisplayFunc(display);

	glutIdleFunc(idle);
    
    glutMainLoop();

   return 0;
}