#include "camera_gl.h"

#include "fileobject.h"




#include <GL/glut.h>

/*number of houses in street*/
#define MAXHOUSE 20

/*number of streets*/
#define MAXSTREET 2

static FILE *fp;

static GLint Height;		/*height of window*/

static Camera_GL *TheCamera;
static GObject *groundObj;	/*root of the entire hierarchy*/

static GLint XC, YC;		/*current mouse position*/
short Move = 0;
short Rotate = 0;


enum {

	M_PLANAR,

		M_FASTER,

		M_SLOWER,

		M_RFASTER,

		M_RSLOWER

};


int usePlanarConstraint = 1;

double velocity = 0.05;

double angularVel = 0.005;




static void moveVRP(void)
/*move the VRP along the VPN*/
{
	Vector3D n;
	Point3D vrp;
	
	
	vrp = TheCamera->vrp;
	
	/*normalise the vpn - pity this happens also in camera code*/
	normaliseVector3D(&TheCamera->vpn,&n);
	
	vrp.x += (velocity*n.x)*Move;
	vrp.y += (velocity*n.y)*Move;

	if (!usePlanarConstraint) {

		vrp.z += (velocity*n.z)*Move;

	}

	
	setVRP_GL(TheCamera,vrp.x,vrp.y,vrp.z);
}


static void rotateVPN(int x, int y)

{

	double dx, dy; /*change in mouse position*/

	double nx,ny,nz; /*new vpn*/

	RotationMatrix r;

	/*trial and error value affecting angular velocity*/

	

	/*difference between old and new coordinates*/

	dx = angularVel*(x - XC);

	dy = angularVel*((Height-y)- YC);

	

	XC = x;

	YC = Height-y;

	

	/*treat (dx,dy,1) as the new offset VPN, expressed in VC*/

	/*transform back to WC, using transpose of RotationMatrix*/

	r = TheCamera->R;

	nx = r.m[0][0]*dx + r.m[0][1]*dy + r.m[0][2];

	ny = r.m[1][0]*dx + r.m[1][1]*dy + r.m[1][2];

	nz = r.m[2][0]*dx + r.m[2][1]*dy + r.m[2][2];

	

	setVPN_GL(TheCamera,nx,ny,nz);

}



static void idle(void)

/*if nothing else happening*/

{

	if(Move!=0) {

		moveVRP();

		clickView_GL(TheCamera);

		

		/*force a call to display*/

		glutPostRedisplay();

	}

}



static void mouseButton(int button, int state, int x, int y)
{
	if(button==GLUT_LEFT_BUTTON){
		XC = x;
		YC = Height - y;
		if(state==GLUT_DOWN) Rotate = 1;
		else Rotate = 0;
	}	

	
	if(button==GLUT_RIGHT_BUTTON){
		if(state==GLUT_DOWN) Move = 1;
		else Move = 0;
	}
}


static void mouseMotion(int x, int y)
{

	
	if(Rotate){/*for left button*/
		rotateVPN(x,y);
	}
	
	if(Move!=0){/*for right button*/
		moveVRP();
	}
	
	clickView_GL(TheCamera);
	
	/*force a call to display*/
	glutPostRedisplay();
}



static void createMainStreet(void)
{
	FaceArray *facearray;
	GObject *cubeObj,*roofObj, *houseObj[MAXHOUSE],*streetObj[MAXSTREET];
	Matrix m;
	int i;
	
	/*create a FaceArray large enough to hold all polygons in the scene*/
	facearray = newFaceArray(1024);
	
	/*read a ground plane - has max two children*/
	groundObj = readObjectFromFile("../Data/plane.dat",facearray,2);
	
	/*cube has max two children child*/
	cubeObj = readObjectFromFile("../Data/house.dat",facearray,2);	
	
	/*has no children*/
	roofObj = readObjectFromFile("../Data/roof.dat",facearray,0);
	
	/*add the cube as a child to the ground*/
	addChildToObject(groundObj,cubeObj);
	
	/*add the roof as a child to the cube*/
	addChildToObject(cubeObj,roofObj);
	
	/*set local matrix of roof to be on top of cube*/
	setTranslationMatrix(m,0.0,0.0,1.0);
	setLTMOfObject(roofObj,m);
	/*now the cube and roof define a house*/
	
	/*make a hierarchy where each house has a child which is 
	the next house further down the street*/
	houseObj[0] = cubeObj;
	setTranslationMatrix(m,0.0,3.0,0.0);
	
	for(i=1;i<MAXHOUSE;++i){
		houseObj[i] = deepCloneObject(houseObj[i-1]);
		addChildToObject(houseObj[i-1],houseObj[i]);
		putLTMOfObject(houseObj[i],m);
	}
	
	/*now recurse through whole structure to set the LTMs properly*/
	
	/*set the local matrix of the cube to be shifted to the right*/
	setTranslationMatrix(m,2.0,0.0,0.0);
	setLTMOfObject(houseObj[0],m);
	
	/*make the streets*/
	streetObj[0] = houseObj[0];
	streetObj[1] = deepCloneObject(houseObj[0]);
	
	addChildToObject(groundObj,streetObj[1]);
	setTranslationMatrix(m,-2.0,0.0,0.0);
	setLTMOfObject(streetObj[1],m);
}

static void display ()
{
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
    displayObjectTree_GL(groundObj);
    glutSwapBuffers();
}


static void reshape(int width, int height)
{ 	
	
	setCOP_GL(TheCamera,0.0,0.0,-1.0);
	setVPDistance_GL(TheCamera,0.0);
	setClipPlanes_GL(TheCamera,-0.9,100.0);
	setVPWindow_GL(TheCamera,-0.5,0.5,-0.5,0.5);
	
	clickProject_GL(TheCamera);
	
	glViewport (0, 0, width, height); /*define the viewport*/
}

static void initialise(void) 
{
	
	GLfloat light_diffuse[] = {1.0,1.0,1.0,1.0};
	GLfloat light_specular[] = {1.0,1.0,1.0,1.0};
	GLfloat light_position[] = {0.5,1.0,1.0,0.0};
	
	
	/*GL_FLAT or GL_SMOOTH*/	
	glShadeModel (GL_FLAT);
    
	/*set the background (clear) Color to white*/
	glClearColor(1.0,1.0,1.0,0.0);
	
	/*enable normalisation*/
	glEnable(GL_NORMALIZE);
	glEnable(GL_DEPTH_TEST);
	
    
	/*set the depth buffer for clearing*/
	glClearDepth(1.0);
	
	/*enable lighting*/
	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT0);
	glLightfv(GL_LIGHT0,GL_DIFFUSE,light_diffuse);
	glLightfv(GL_LIGHT0,GL_SPECULAR,light_specular);
	
	/*initialise the camera*/
	TheCamera = newCamera_GL();
	setVRP_GL(TheCamera,0.0,-5.0,1.0);
	setVPN_GL(TheCamera,0.0,1.0,-0.2);
	setVUV_GL(TheCamera,0.0,0.0,1.0);

	setCOP_GL(TheCamera,0.0,0.0,-1.0);

	setVPDistance_GL(TheCamera,0.0);

	setClipPlanes_GL(TheCamera,-0.9,100.0);

	setVPWindow_GL(TheCamera,-0.5,0.5,-0.5,0.5);


	click_GL(TheCamera);
	
	glPushMatrix();
	glLoadIdentity();
	glLightfv(GL_LIGHT0,GL_POSITION,light_position);
	glPopMatrix();
	
	/*create the scene*/
	createMainStreet();
}






static void keyboard(unsigned char c, int x, int y)



{

	switch (c) {

	case 27:

		exit(0);

		return;

	}

}



static void specialDown(int key, int x, int y)

{

	switch (key){

	case GLUT_KEY_UP:

		Move = 1;

		break;

	case GLUT_KEY_DOWN:

		Move = -1;

		break;

		

	}

}





static void specialUp(int key, int x, int y)

{

	switch (key) {

	case GLUT_KEY_UP:

		Move = 0;

		break;

	case GLUT_KEY_DOWN:

		Move = 0;

		break;

		

	}

}

void menu(int item)

{

	switch (item) {

		

	case M_PLANAR:

		usePlanarConstraint = 1 - usePlanarConstraint;

		break;

    case M_FASTER:

		velocity*=1.5;

		break;

	case M_SLOWER:

		velocity*=0.5;

		break;

    case M_RFASTER:

		angularVel*=1.5;

		break;

	case M_RSLOWER:

		angularVel*=0.5;

		break;

	}

	glutPostRedisplay();

}



int main(int argc, char** argv)
{	
	int window;
	
	glutInit(&argc,argv);
	
	glutInitWindowSize(500,500);
	
	
	/*record the window height*/
	Height = 500;
	
	glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH);
	
	window = glutCreateWindow("Mainstreet");
	glutSetWindow(window);
	
	initialise();
	
	/*register callbacks*/
	glutIdleFunc(idle);

	glutDisplayFunc(display); /*display function*/
	glutReshapeFunc(reshape);
	glutMouseFunc(mouseButton);
	glutMotionFunc(mouseMotion);
	glutKeyboardFunc(keyboard);

	glutSpecialFunc(specialDown);

	glutSpecialUpFunc(specialUp);

	glutIdleFunc(idle);
	glutCreateMenu(menu);

	glutAddMenuEntry("Toggle planar constraint", M_PLANAR);

	glutAddMenuEntry("Move Faster", M_FASTER);

	glutAddMenuEntry("Move Slower", M_SLOWER);

	glutAddMenuEntry("Rotate Faster", M_RFASTER);

	glutAddMenuEntry("Rotate Slower", M_RSLOWER);

	glutAttachMenu(GLUT_RIGHT_BUTTON);

	
	glutMainLoop();
}