#include <string.h>
#include <stdio.h>
#include <stdarg.h>
#include <math.h>
#include <GL/glut.h>

#define MAXPTS 55
#define EPS 0.000001
#define STEP 0.01
#define WIREFRAME 1
#define SOLID 2
#define PTMOVEMUL 5

int mousex, mousey;
int sirka=800, vyska=600;
int M=0,N=0;
double V[MAXPTS][MAXPTS][3];
int sel_pt_i=0,sel_pt_j=0,color=0,mode=0;
int is_ctrl,is_alt,is_shift;
double ZOOM=2.0,XOFFSET=-1.0,YOFFSET=0.0,ROTATEX=15.0,ROTATEY=0.0;
GLuint wlist,slist;

double Comb[100][100];
int SHOW_PTS=1;

void PreCompute(void){
  int i,j;
  for (i=0;i<100;i++) for (j=0;j<=i;j++) 
    if ((!j)||(j==i)) Comb[i][j]=1; else Comb[i][j]=Comb[i-1][j-1]+Comb[i-1][j];
}

void PisBitmapovyText(int x, int y, char *string, void *font) {
  int len, i;
  glRasterPos2f(x, y);
  len = (int) strlen(string);
  for (i = 0; i < len; i++) glutBitmapCharacter(font, string[i]);
}

void PisVektorovyText(GLfloat x, GLfloat y, char *format,...) {
  va_list args;
  char buffer[200], *p;

  va_start(args, format);
  vsprintf(buffer, format, args);
  va_end(args);
  glPushMatrix();

  glLoadIdentity();
  glTranslatef(-1.0,0.0,-6.0f); // move into the screen 6.0
  glRotatef(15,1.0,0.0,0.0);
  glRotatef(0,0.0,1.0,0.0);
  glScalef(2,2,-2);
  glTranslatef(x, y, 0);
  glScalef(0.0005,0.0005,0.0005);
  for (p = buffer; *p; p++) glutStrokeCharacter(GLUT_STROKE_ROMAN, *p);
  glPopMatrix();
}

void SetVertexColor(double u, double v) {
  if (u+v<=1.0) glColor3d(1.0,u+v,0.0); else glColor3d(2.0-u-v,1.0,0.0);
}

void GenerateBezierWireframe(void){
  double u,v,P[3],MSTEP,NSTEP;
  int i,j,k;

  glNewList(wlist,GL_COMPILE);
  
  MSTEP=1.0/(M-1); NSTEP=1.0/(N-1);
    
  glLineWidth(2.0); glColor3d(0.0,0.0,1.0);

  for (u=0.0;u<1.0+MSTEP-EPS;u+=MSTEP) {
    glBegin(GL_LINE_STRIP);
    for (v=0.0;v<1.0+STEP-EPS;v+=STEP) {
      for (k=0;k<3;k++) { P[k]=0.0; for (i=0;i<M;i++) for (j=0;j<N;j++) 
          P[k]+=V[i][j][k]*Comb[M-1][i]*Comb[N-1][j]*pow(u,i)*pow(1-u,M-i-1)*pow(v,j)*pow(1-v,N-j-1); }
      glVertex3dv(P);
    }
    glEnd();
  }
    
  for (v=0.0;v<1.0+NSTEP-EPS;v+=NSTEP) {
    glBegin(GL_LINE_STRIP);
    for (u=0.0;u<1.0+STEP-EPS;u+=STEP) {
      for (k=0;k<3;k++) { P[k]=0.0; for (i=0;i<M;i++) for (j=0;j<N;j++) 
          P[k]+=V[i][j][k]*Comb[M-1][i]*Comb[N-1][j]*pow(u,i)*pow(1-u,M-i-1)*pow(v,j)*pow(1-v,N-j-1); }
      glVertex3dv(P);
    }
    glEnd();
  }

  glEndList();
}

void GenerateBezierSolid(void){
  double u,v,P[3];
  int i,j,k;

  glNewList(slist,GL_COMPILE);
  
  glColor3d(0.0,0.7,0.7);
  glBegin(GL_QUADS);
  for (u=0.0;u<1.0-EPS;u+=STEP) for (v=0.0;v<1.0-EPS;v+=STEP) {
    for (k=0;k<3;k++) { P[k]=0.0; for (i=0;i<M;i++) for (j=0;j<N;j++) 
        P[k]+=V[i][j][k]*Comb[M-1][i]*Comb[N-1][j]*pow(u,i)*pow(1-u,M-i-1)*pow(v,j)*pow(1-v,N-j-1); }
    SetVertexColor(u,v); glVertex3dv(P);
   
    u+=STEP; for (k=0;k<3;k++) { P[k]=0.0; for (i=0;i<M;i++) for (j=0;j<N;j++) 
        P[k]+=V[i][j][k]*Comb[M-1][i]*Comb[N-1][j]*pow(u,i)*pow(1-u,M-i-1)*pow(v,j)*pow(1-v,N-j-1); } 
    SetVertexColor(u,v); glVertex3dv(P);
    
    v+=STEP; for (k=0;k<3;k++) { P[k]=0.0; for (i=0;i<M;i++) for (j=0;j<N;j++) 
        P[k]+=V[i][j][k]*Comb[M-1][i]*Comb[N-1][j]*pow(u,i)*pow(1-u,M-i-1)*pow(v,j)*pow(1-v,N-j-1); } 
    SetVertexColor(u,v); glVertex3dv(P);
    
    u-=STEP; for (k=0;k<3;k++) { P[k]=0.0; for (i=0;i<M;i++) for (j=0;j<N;j++) 
        P[k]+=V[i][j][k]*Comb[M-1][i]*Comb[N-1][j]*pow(u,i)*pow(1-u,M-i-1)*pow(v,j)*pow(1-v,N-j-1); } 
    SetVertexColor(u,v); glVertex3dv(P);
    v-=STEP;
  }
  glEnd();

  glEndList();
}

void display(void) {
  int i,j;
  char pom[100];

  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
  glLoadIdentity();
  glTranslatef(XOFFSET,YOFFSET,-6.0f); // move into the screen 6.0
  glRotatef(ROTATEX,1.0,0.0,0.0);
  glRotatef(ROTATEY,0.0,1.0,0.0);
  glScalef(ZOOM,ZOOM,-ZOOM);

  glColor3d(1.0,1.0,1.0); glLineWidth(2.0);
  PisVektorovyText(-0.9,1.0,"M=%d N=%d",M-1,N-1);

  if (SHOW_PTS) {
    glColor3d(0.5,0.5,0.5); glLineWidth(1.0);
    for (i=0;i<M;i++) { glBegin(GL_LINE_STRIP); for (j=0;j<N;j++) glVertex3dv(V[i][j]); glEnd(); }
    for (j=0;j<N;j++) { glBegin(GL_LINE_STRIP); for (i=0;i<M;i++) glVertex3dv(V[i][j]); glEnd(); }
  }
  
  if (mode==WIREFRAME) glCallList(wlist);
  if (mode==SOLID)     glCallList(slist);
  
  if (SHOW_PTS) {
    glColor3d(0.5,0.5,0.5);
    glPointSize(5.0);
    glBegin(GL_POINTS); for (i=0;i<M;i++) for (j=0;j<N;j++) glVertex3dv(V[i][j]); glEnd();
    glColor3d(0.0,1.0,0.0);
    glPointSize(7.0);
    glBegin(GL_POINTS); glVertex3dv(V[sel_pt_i][sel_pt_j]); glEnd();
  }
  
  glutSwapBuffers();
}

void reshape(int w, int h) {
  sirka=w; vyska=h;
  glViewport(0, 0, w, h);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(45.0f,(GLfloat)sirka/(GLfloat)vyska,0.1f,100.0f);
  glMatrixMode(GL_MODELVIEW);
}

void keypressed(unsigned char key, int x, int y) { 
  is_ctrl=glutGetModifiers(); 
  is_alt=is_ctrl&GLUT_ACTIVE_ALT; 
  is_shift=is_ctrl&GLUT_ACTIVE_SHIFT; 
  is_ctrl=is_ctrl&GLUT_ACTIVE_CTRL;
  switch (key) {
    case 27:  exit(0); break;
    case 'm': if (M-2) M--; 
      if (mode==WIREFRAME) GenerateBezierWireframe();
      if (mode==SOLID) GenerateBezierSolid();
      break;
    case 'M': if (!M-50) M++;
      if (mode==WIREFRAME) GenerateBezierWireframe();
      if (mode==SOLID) GenerateBezierSolid();
      break;
    case 'n': if (M-2) N--;
      if (mode==WIREFRAME) GenerateBezierWireframe();
      if (mode==SOLID) GenerateBezierSolid();
      break;
    case 'N': if (!N-50) N++;
      if (mode==WIREFRAME) GenerateBezierWireframe();
      if (mode==SOLID) GenerateBezierSolid();
      break;
    case '+': ZOOM+=STEP; break;
    case '-': ZOOM-=STEP; break;
    case 'p': SHOW_PTS^=1; break;
  }
  glutPostRedisplay();
}

void keypressed_special(int key, int x, int y) {
  is_ctrl=glutGetModifiers(); 
  is_alt=is_ctrl&GLUT_ACTIVE_ALT; 
  is_shift=is_ctrl&GLUT_ACTIVE_SHIFT; 
  is_ctrl=is_ctrl&GLUT_ACTIVE_CTRL;
 
  if (is_alt) {
    switch (key) {
      case GLUT_KEY_UP:    ROTATEX-=1; break;
      case GLUT_KEY_DOWN:  ROTATEX+=1; break;
      case GLUT_KEY_LEFT:  ROTATEY-=1; break;
      case GLUT_KEY_RIGHT: ROTATEY+=1; break;
    }
  }
  if (is_ctrl) {
    switch (key) {
      case GLUT_KEY_UP:    YOFFSET-=STEP; break;
      case GLUT_KEY_DOWN:  YOFFSET+=STEP; break;
      case GLUT_KEY_LEFT:  XOFFSET+=STEP; break;
      case GLUT_KEY_RIGHT: XOFFSET-=STEP; break;
    }
  }
  if (is_shift) {
    switch (key) {
      case GLUT_KEY_PAGE_UP:    V[sel_pt_i][sel_pt_j][1]+=PTMOVEMUL*STEP; break;
      case GLUT_KEY_PAGE_DOWN:  V[sel_pt_i][sel_pt_j][1]-=PTMOVEMUL*STEP; break;
      case GLUT_KEY_UP:         V[sel_pt_i][sel_pt_j][2]+=PTMOVEMUL*STEP; break;
      case GLUT_KEY_DOWN:       V[sel_pt_i][sel_pt_j][2]-=PTMOVEMUL*STEP; break;
      case GLUT_KEY_LEFT:       V[sel_pt_i][sel_pt_j][0]-=PTMOVEMUL*STEP; break;
      case GLUT_KEY_RIGHT:      V[sel_pt_i][sel_pt_j][0]+=PTMOVEMUL*STEP; break;
    }
    if (mode==WIREFRAME) GenerateBezierWireframe();
    if (mode==SOLID) GenerateBezierSolid();
  }
  if ((!is_alt)&&(!is_ctrl)&&(!is_shift)) {
    switch (key) {
      case GLUT_KEY_UP:    if (sel_pt_j<N-1) sel_pt_j++; break;
      case GLUT_KEY_DOWN:  if (sel_pt_j>0) sel_pt_j--; break;
      case GLUT_KEY_LEFT:  if (sel_pt_i>0) sel_pt_i--; break;
      case GLUT_KEY_RIGHT: if (sel_pt_i<M-1) sel_pt_i++; break;
    }
  }
  glutPostRedisplay();
}

void motion(int x, int y) {
  if (sel_pt_i!=-1) { V[sel_pt_i][sel_pt_j][0]=x; V[sel_pt_i][sel_pt_j][1]=y; }
  mousex = x; mousey = y;
  glutPostRedisplay();
}

void mouse(int b, int s, int x, int y) {
  int i,j,ok;

  mousex = x; mousey = y;
  if (b==GLUT_LEFT_BUTTON){
    if (s==GLUT_DOWN) {
      ok=1;
/*      for (i=0;i<pts;i++) if ((abs(P[i][0]-x)<=4) && (abs(P[i][1]-y)<=4)) {
        ok=0;  
        for (j=i;j<pts-1;j++) { P[j][0]=P[j+1][0]; P[j][1]=P[j+1][1]; }
        pts--; 
        break;
      }
      if ((ok) && (pts<MAXPTS)) { P[pts][0]=x; P[pts][1]=y; pts++; }*/
    }
  }
  
//  if (b==GLUT_MIDDLE_BUTTON) {
//    if (s==GLUT_DOWN) {
//      sel_pt_i=sel_pt_j=-1;
//      for (i=0;i<pts;i++) if ((abs(P[i][0]-x)<=4) && (abs(P[i][1]-y)<=4)) { sel_pt=i; break; }
//    } else { sel_pt_i=sel_pt_j=-1; }
//  }
  
  glutPostRedisplay();
  motion(x,y);
}

void menu(int choice) {
  mode=choice;
  if (mode==WIREFRAME) GenerateBezierWireframe();
  if (mode==SOLID) GenerateBezierSolid();
  glutPostRedisplay();
}

int main(int argc, char **argv) {
  int i,j; 
  
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_ALPHA );
  
  glutInitWindowSize(800, 600); glutInitWindowPosition(0, 0);
  glutCreateWindow("Miso Forisek -- Krivky a plochy v PG");
  glClearColor(0.0, 0.0, 0.0, 0.0); glColor3d(1.0, 0.0, 0.0); glLineWidth(1.0);
 
  glClearDepth(10.0);                            // Enables Clearing Of The Depth Buffer
  glDepthFunc(GL_LESS);                         // The Type Of Depth Test To Do
  glEnable(GL_DEPTH_TEST);                      // Enables Depth Testing
  glShadeModel(GL_SMOOTH);                      // Enables Smooth Color Shading

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();                             // Reset The Projection Matrix
  gluPerspective(45.0f,(GLfloat)sirka/(GLfloat)vyska,0.1f,100.0f);     // Calculate The Aspect Ratio Of The Window
  glMatrixMode(GL_MODELVIEW);
 
  glutDisplayFunc(display);
  glutReshapeFunc(reshape);
  glutKeyboardFunc(keypressed);
  glutSpecialFunc(keypressed_special);
  glutMotionFunc(motion);
  glutMouseFunc(mouse);
  
  glutCreateMenu(menu); 
  glutAddMenuEntry("Grid only", 0); 
  glutAddMenuEntry("Wire-frame model", 1); 
  glutAddMenuEntry("Solid model", 2);
  glutAttachMenu(GLUT_RIGHT_BUTTON);

  M=N=5;
  for (i=0;i<50;i++) for (j=0;j<50;j++){
    V[i][j][0]=i/5.0;
    V[i][j][2]=j/5.0;
//    V[i][j][1]=(fabs(3.0-i)+fabs(3.0-j))/10.0;
    V[i][j][1]=0.0;
  }
  PreCompute();
  wlist=glGenLists(2); slist=wlist+1;

  glutMainLoop();
  return 0;
}