//clickpoly.c
//James Vanderhyde, 18 August 2004
//Adapted from Llamas's unproject.c


#ifdef _WIN32
#include <windows.h>
#endif
#include <GL/glut.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>

struct Point2D
{
  int x,y;
};

struct Point2D vertices[100];
int numVertices=0;
int tol=3;
int movingVertex=-1;

void insert_vertex_at(int p, int x, int y)
{
  int i;
  if (numVertices<100)
    {
      for (i=numVertices; i>p; i--)
	{
	  vertices[i].x=vertices[i-1].x;
	  vertices[i].y=vertices[i-1].y;
	}
      vertices[p].x=x;
      vertices[p].y=y;
      numVertices++;
    }
}

void remove_vertex_at(int p)
{
  int i;
  numVertices--;
  for (i=p; i<numVertices; i++)
    {
      vertices[i].x=vertices[i+1].x;
      vertices[i].y=vertices[i+1].y;
    }
}

void draw_control_poly()
{
  int i;

  GLint viewport[4];
  glGetIntegerv (GL_VIEWPORT, viewport);

  glPushMatrix();
  glTranslatef(0.0,0.0,-10.0);
  glScalef(10.0/viewport[3],10.0/viewport[3],10.0/viewport[3]);
  glTranslatef(-0.5*viewport[2],-0.5*viewport[3],0.0);

  glColor3f(1.0,1.0,1.0);
  glBegin(GL_LINE_LOOP);
  for (i=0; i<numVertices; i++)
    {
      glVertex3f((GLfloat)vertices[i].x,(GLfloat)vertices[i].y,0.0);
    }
  glEnd();

  glBegin(GL_QUADS);
  for (i=0; i<numVertices; i++)
    {
      if (i==movingVertex)
	glColor3f(1.0,1.0,0.3);
      else
	glColor3f(1.0,1.0,0.8);
      glVertex3f((GLfloat)vertices[i].x-tol,(GLfloat)vertices[i].y-tol,0.0);
      glVertex3f((GLfloat)vertices[i].x-tol,(GLfloat)vertices[i].y+tol,0.0);
      glVertex3f((GLfloat)vertices[i].x+tol,(GLfloat)vertices[i].y+tol,0.0);
      glVertex3f((GLfloat)vertices[i].x+tol,(GLfloat)vertices[i].y-tol,0.0);
    }
  glEnd();
  

  /*glBegin(GL_POLYGON);
  glVertex3f(0,0.0,0.0);
  glVertex3f(viewport[2],0.0,0.0);
  glVertex3f(viewport[2],viewport[3],0.0);
  glVertex3f(0.0,viewport[3],0.0);
  glEnd();*/

  glPopMatrix();

}

void display(void)
{
  glClear(GL_COLOR_BUFFER_BIT);
  glMatrixMode(GL_MODELVIEW);
  draw_control_poly();
  glFlush();
  glutSwapBuffers();
}

void reshape(int w, int h)
{
   glViewport (0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   gluPerspective (2*atan(0.5)/M_PI*180, (GLfloat) w/(GLfloat) h, 1.0, 100.0);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
}

int vertex_near_point(int x, int y)
{
  int i;
  for (i=0; i<numVertices; i++)
    {
      if (((vertices[i].x-tol<=x) && (x<=vertices[i].x+tol)) && 
	  ((vertices[i].y-tol<=y) && (y<=vertices[i].y+tol)))
	return i;
    }
  return -1;
}

int edge_near_point(int x, int y)
{
  struct Point2D a,b;
  float min=1e20;
  float dist,dot1,dot2;
  int i,mini=-1;
  for (i=0; i<numVertices; i++)
    {
      a=vertices[i];
      if (i+1<numVertices) b=vertices[i+1];
      else b=vertices[0];
      dist=((b.x-a.x)*(y-a.y)-(b.y-a.y)*(x-a.x))/sqrt((b.x-a.x)*(b.x-a.x)+(b.y-a.y)*(b.y-a.y));
      if (dist<0.0) dist=-dist;
      dot1=(b.x-a.x)*(x-a.x)+(b.y-a.y)*(y-a.y);
      dot2=(a.x-b.x)*(x-b.x)+(a.y-b.y)*(y-b.y);
      if ((min>dist) && (dot1>=0) && (dot2>=0))
	{
	  min=dist;
	  mini=i;
	}
    }
  return mini;
}

void mouse_click(int button, int state, int x, int y) 
{
   GLint viewport[4]; /*  viewport[3] is height of window in pixels  */
   GLint flippedy;    /*  OpenGL y coordinate position  */
   int p,clickedVertex;

   switch (button)
     {
     case GLUT_LEFT_BUTTON:
       if (state == GLUT_DOWN)
	 {
	   glGetIntegerv (GL_VIEWPORT, viewport);
	   flippedy = viewport[3] - (GLint) y - 1;
	   clickedVertex=vertex_near_point(x,flippedy);
	   if (clickedVertex>=0)
	     {
	       movingVertex=clickedVertex;
	     }
	   else
	     {
	       p=edge_near_point(x,flippedy)+1;
	       if (p>0)
		 {
		   insert_vertex_at(p,x,flippedy);
		   movingVertex=p;
		 }
	     }
	   glutPostRedisplay();
	 }
       if (state == GLUT_UP)
	 {
	   movingVertex=-1;
	   glutPostRedisplay();
	 }
       
       break;
     case GLUT_RIGHT_BUTTON:
       if (state == GLUT_DOWN)
	 {
	   if (numVertices>3)
	     {
	       glGetIntegerv (GL_VIEWPORT, viewport);
	       flippedy = viewport[3] - (GLint) y - 1;
	       clickedVertex=vertex_near_point(x,flippedy);
	       if (clickedVertex>=0)
		 {
		   remove_vertex_at(clickedVertex);
		 }
	       glutPostRedisplay();	   
	     }
	 }
       if (state == GLUT_UP)
	 {
	 }
       break;
     default:
       break;
     }
}

void mouse_drag(int x, int y)
{
  GLint viewport[4];
  GLint flippedy;
  if (movingVertex >= 0)
    {
      glGetIntegerv (GL_VIEWPORT, viewport);
      flippedy = viewport[3] - (GLint) y - 1;
      vertices[movingVertex].x=x;
      vertices[movingVertex].y=flippedy;
      glutPostRedisplay();
    }
}

void keyboard(unsigned char key, int x, int y)
{
  switch(key) 
    {
    case 27:  /* ESC */
      exit(0);
 
    default:  break;
  }
}

int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB); /* turn on double buffering */
   glutInitWindowSize (500, 500); 

   numVertices=3;
   vertices[0].x=250; vertices[0].y=420;
   vertices[1].x=50;  vertices[1].y=80;
   vertices[2].x=450; vertices[2].y=80;

   glutInitWindowPosition (100, 100);
   glutCreateWindow (argv[0]);
   glutDisplayFunc(display); 
   glutReshapeFunc(reshape); 
   glutMouseFunc(mouse_click);
   glutMotionFunc(mouse_drag);
   glutKeyboardFunc(keyboard);
   glutMainLoop();
   return EXIT_SUCCESS;
}