#include <GL/glut.h>
#include <iostream.h>
#include <stdio.h>


#define BUFFWIDTH 50
#define BUFFHEIGHT 50



enum projectiontype {orthographic, perspective };  	/* possible modes of program */
enum colors {black, white, red, blue, green};	/* available colors */
enum axis {xaxis, yaxis, zaxis};				/* axes of rotation */
enum menuitems {Morthographic, Mperspective, Mwhite, Mred, Mblue, Mgreen, Mtranslate, Mrotate, Mscale, Mredraw, Mclear};



/* the global variables */
int fb[BUFFWIDTH][BUFFHEIGHT];  				/* the simulated frame buffer*/
int width=500,height=500;  						/*  initial window size  */
float pixwidth = (float) width/BUFFWIDTH;  		/* simulated pixel width */
float pixheight = (float) height/BUFFHEIGHT;  	/* simulated pixel height */
int currprojection=orthographic;				/* type of projection */
int currcolor=white;							/* drawing color  */
float CTM[4][4], CPM[4][4];						/* modeling and projection matrices*/
int mainmenu, colormenu, projectionmenu;

void translate(int dx, int dy, int dz);
void rotate(int angle, int rotateaxis);
void scale(int dx, int dy, int dz);

round(float x) 
{
	if (x>0)
		return (int) x+0.5;
	else
		return (int) x-0.5;

}



void drawPolygon()
{
	// Insert code here
}

void setWindowTitle()
{

	// Insert code here
	if (currprojection == orthographic) {
		switch (currcolor) {
		case black:
			glutSetWindowTitle("Settings: Orthographic, Black");
			break;
		case white: 
			glutSetWindowTitle("Settings: Orthographic, White");
			break;
		case red:
			glutSetWindowTitle("Settings: Orthographic, Red");
			break;
		case blue:
			glutSetWindowTitle("Settings: Orthographic, Blue");
			break;
		case green:
			glutSetWindowTitle("Settings: Orthographic, Green");
			break;
		}
	}
	else   {
		switch (currcolor) {
		case black:
			glutSetWindowTitle("Settings: Perspective, Black");
			break;
		case white: 
			glutSetWindowTitle("Settings: Perspective, White");
			break;
		case red:
			glutSetWindowTitle("Settings: Perspective, Red");
			break;
		case blue:
			glutSetWindowTitle("Settings: Perspective, Blue");
			break;
		case green:
			glutSetWindowTitle("Settings: Perspective, Green");
			break;
		}
	}

}

void init()
{
	FILE *fp, *fopen(const char*, const char*);
	int		i,j, numvertices;
	int		x,y;

	glClearColor(0.0,0.0,0.0,0.0);	/* clear color is black  */
	for (i=0; i<BUFFWIDTH; i++)	/* initially simulated pixels are black */
		for (j=0; j<BUFFHEIGHT; j++)
			fb[i][j]=0;
		
	// UNCOMMENT WHEN LOAD IDENTITY IS WRITTEN
	// loadidentity(&CTM[0][0]);
	// loadidentity(&CPM[0][0]);

	// create a new polygon
	fp = fopen((const char*) "polygon.dat", (const char *) "r");
	fscanf(fp,"%d",&numvertices);
	for (i=0; i< numvertices; i++)  {
		fscanf(fp,"%d %d", &x, &y);
		fb[x][y]=white;  // comment this out after you get the draw working 
		//  create a new vertex
		//  and add it to the polygon
		}

	fclose(fp);
  

}

void display()
{
	glClear(GL_COLOR_BUFFER_BIT);  /* clear the screen */
	int i,j;


	/*  draw white pixels */
	glColor3f(1.0,1.0,1.0);  /*  drawing color is white */
	for (i=0;i<BUFFWIDTH;i++)  /* draw the "on"  pixels */
		for (j=0;j<BUFFHEIGHT;j++)
			if (fb[i][j]==white) 			
				glRectf(i*pixwidth, j* pixheight,(i+1)*pixwidth, (j+1)*pixheight);

	/*  draw green pixels */
	glColor3f(0.0,1.0,0.0);  /*  drawing color is green */
	for (i=0;i<BUFFWIDTH;i++)  /* draw the "on"  pixels */
		for (j=0;j<BUFFHEIGHT;j++)
			if (fb[i][j]==green) 			
				glRectf(i*pixwidth, j* pixheight,(i+1)*pixwidth, (j+1)*pixheight);

	/*  draw blue pixels */
	glColor3f(0.0,0.0,1.0);  /*  drawing color is blue */
	for (i=0;i<BUFFWIDTH;i++)  /* draw the "on"  pixels */
		for (j=0;j<BUFFHEIGHT;j++)
			if (fb[i][j]==blue) 			
				glRectf(i*pixwidth, j* pixheight,(i+1)*pixwidth, (j+1)*pixheight);

	/*  draw red pixels */
	glColor3f(1.0,0.0,0.0);  /*  drawing color is blue */
	for (i=0;i<BUFFWIDTH;i++)  /* draw the "on"  pixels */
		for (j=0;j<BUFFHEIGHT;j++)
			if (fb[i][j]==red) 			
				glRectf(i*pixwidth, j* pixheight,(i+1)*pixwidth, (j+1)*pixheight);

	glutSwapBuffers();

}

void reshape(int w, int h)
{
	 width = w;
	 height = h;
	pixwidth =(float) w/BUFFWIDTH;
	pixheight = (float) h/BUFFHEIGHT;
	glViewport(0,0,w,h);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrtho(0,w,0,h,-1,1);
	glMatrixMode(GL_MODELVIEW);
	 glLoadIdentity();
}

void keyboard(unsigned char key, int x, int y)
{
	int dx,dy,dz;
	float sx,sy,sz;
	int angle, axisofrotation;
	switch (key) {


	case 's':
	case 'S':
        printf("Enter scale factors sx, sy, and sz (floats):\n");
		scanf("%f %f %f", &sx, &sy, &sz);

	//  UNCOMMENT NEXT LINE AFTER SCALE ROUTINE IS WRITTEN
	//	scale(sx,sy,sz);  
	//  INSERT SUBROUTINE CALL  HERE TO REDRAW POLYGON 
		glutPostRedisplay();
		break;

	case 't':
	case 'T':
        printf("Enter scales dx, dy, and dz (ints):\n");
		scanf("%d %d %d", &dx, &dy, &dz);

	//  UNCOMMENT NEXT LINE AFTER TRANSLATE ROUTINE IS WRITTEN
	//	translate(dx,dy,dz);  
	//  INSERT SUBROUTINE CALL  HERE TO REDRAW POLYGON 
		glutPostRedisplay();
		break;

	case 'r':
	case 'R':
        printf("Enter angle of rotation (int) and axis (x=%d, y=%d, z=%d):\n", xaxis, yaxis, zaxis);
		scanf("%d %d", &angle, &axisofrotation);

	//  UNCOMMENT NEXT LINE AFTER RotateX ROUTINE IS WRITTEN
	//	rotate(angle,axisofrotation);  
	//  INSERT SUBROUTINE CALL  HERE TO REDRAW POLYGON 
		glutPostRedisplay();
		break;
	}
}

void mouse(int button, int state, int x, int y)
{
	if (state == GLUT_DOWN && button==GLUT_LEFT_BUTTON) {
		{  /* color chosen pixel */
			int x0= round((float) x/pixwidth);
			int y0= BUFFHEIGHT -  y/pixheight ;
			fb[x0][y0]=currcolor;
 

		   glutPostRedisplay();
	}
  }
}

void menu(int choice)
{

	int i,j;
	int dx,dy,dz;
	int sx, sy, sz;
	int angle, axisofrotation;



	switch (choice) {

	case Morthographic: 
		
		currprojection = orthographic;
		setWindowTitle();
		drawPolygon();
		glutPostRedisplay();
		break;

	case Mperspective:
		currprojection = perspective;
		setWindowTitle();
		drawPolygon();
		glutPostRedisplay();
		break;

	case Mclear:
		for (i=0;i<BUFFWIDTH;i++)
			for(j=0;j<BUFFHEIGHT;j++)
				fb[i][j]=0;
		glutPostRedisplay();
		break;

	case Mredraw:
		glutPostRedisplay();
		break;

	case Mwhite:
		currcolor=white;
		drawPolygon();
		setWindowTitle();
		glutPostRedisplay();
		break;

	case Mred:
		currcolor = red;
		drawPolygon();
		setWindowTitle();
		glutPostRedisplay();
		break;

	case Mblue:
		currcolor=blue;
		drawPolygon();
		setWindowTitle();
		glutPostRedisplay();
		break;

	case Mgreen:
		currcolor = green;
		drawPolygon();
		setWindowTitle();
		glutPostRedisplay();
		break;

	case Mtranslate:
		printf("Enter x-translation, y-translation and z-translation (ints):\n");
		scanf("%d %d %d",&dx, &dy, &dz);
		translate(dx,dy,dz);
		drawPolygon();
		glutPostRedisplay();
		break;

	case Mrotate:
		printf("Enter rotation angle (in degrees) and axis (x=%d, y=%d, z=%d) (ints):\n", xaxis,yaxis, zaxis);
		scanf("%d %d",&angle, &axisofrotation);
		rotate(angle, axisofrotation);
		drawPolygon();
		glutPostRedisplay();
		break;

	case Mscale:
		printf("Enter x-scale, y-scale and z-scale (ints):\n");
		scanf("%d %d %d", &sx, &sy, &sz);
		scale(sx,sy,sz);
		drawPolygon();
		glutPostRedisplay();
		break;
	default:
		break;
	}
}






main(int argc, char* argv[])
{


	 /* set up window */
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE |  GLUT_RGB);
	glutInitWindowSize(width,height);
	glutInitWindowPosition(100,100);
	glutCreateWindow("Settings:  Orthographic, White");

	
	init();  /* initialize program parameters */

	/* set up menu */
	colormenu=glutCreateMenu(menu);
	glutAddMenuEntry("White", Mwhite);
	glutAddMenuEntry("Red", Mred);
	glutAddMenuEntry("Blue", Mblue);
	glutAddMenuEntry("Green", Mgreen);

	projectionmenu=glutCreateMenu(menu);
	glutAddMenuEntry("Orthographic",Morthographic);
	glutAddMenuEntry("Perspective",Mperspective);

	mainmenu=glutCreateMenu(menu);
	glutAddSubMenu("Set Projection Type",projectionmenu);
	glutAddSubMenu("Set Color", colormenu);
	glutAddMenuEntry("Redraw",Mredraw);
	glutAddMenuEntry("Clear",Mclear);
	glutAddMenuEntry("Rotate",Mrotate);
	glutAddMenuEntry("Translate",Mtranslate);
	glutAddMenuEntry("Scale",Mscale);
	
	glutAttachMenu(GLUT_RIGHT_BUTTON);


	  /* register callback functions */
	glutDisplayFunc(display);  
	glutReshapeFunc(reshape);
	glutKeyboardFunc(keyboard);
	glutMouseFunc(mouse);


	glutMainLoop(); /* loop until something happens */


  return 1;
}

void translate(int dx, int dy, int dz)
{
	// Insert code here 
}

void scale(int sx, int sy, int sz)
{
	// Insert code here 
}

void rotate(int angle, int axisofrotation)
{
	// Insert code here 
}