/* plot_tri_basis2.c  and test */
/*                   triangle points: 1 is 0,0   2 is 0,4   3 is 4,4
 *                   mid points:      4 is 0,2   5 is 2,4   6 is 2,2
 *          0,4 *
 *             / \
 *        0,3 *---* 1,4
 *           / \ / \             inside points
 *      0,2 *---*---* 2,4             1,3
 *         / \ / \ / \
 *    0,1 *---*---*---* 3,4        1,2   2,3
 *       / \ / \ / \ / \
 *  0,0 *---*---*---*---* 4,4
 *        1,1  2,2  3,3
 *
 *                                base is blue dots
 *                                function is green lines with red dots
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <GL/glut.h>
#include "tri_basis.h" /* geometry in tri_basis.c */

static int width=600;
static int height=600;
static double T[6] = {1.0,1.0, 3.0,2.0, 3.5,0.5}; /* irregular */
/* static double T[6] = {0.0,0.0, 0.0,3.0, 3.0,0.0};  regular */
static double xp[5][5], yp[5][5], zp[5][5];
static int np = 5;
static double xmin = 0.0;
static double xmax = 4.0;
static double ymin = 0.0;
static double ymax = 4.0;
static double zmin = -1.5;
static double zmax = 4.0;
static float offset = 0.0;
static GLfloat theta[] = {-60.0,0.0,30.0};
static GLint axis = 2;
static int stop = 0;
static int next = 0;

void compute_phi1()
{
  int i, j, k, ip, jp;
  double x, y;
  double z;

  for(i=0; i<np; i++)
  {
    for(j=i; j<np; j++)
    {
      x = xp[i][j];
      y = yp[i][j];
      if(next==0) z = phi2p(T,x,y);
      if(next==1) z = phi2x(T,x,y);
      if(next==2) z = phi2y(T,x,y);
      if(next==3) z = phi2xx(T,x,y);
      if(next==4) z = phi2xy(T,x,y);
      if(next==5) z = phi2yy(T,x,y);
      if(next==6) z = 4.0*phi1(T,x,y)*phi2(T,x,y)*phi3(T,x,y); /* bubble */
      zp[i][j] = z;
    }
  }
} /* end compute_phi1 */

void draw_points()
{
  int i, j, k;

  glPointSize(4.0);
  glColor3f(0.0, 0.0, 1.0);
  glBegin(GL_POINTS);
  for(i=0; i<np; i++)
  {
    for(j=i; j<np; j++)
    {
      glVertex3f(xp[i][j], yp[i][j], 0.0); /* base */
    }
  }
  glEnd();
  glColor3f(1.0, 0.0, 0.0);
  glBegin(GL_POINTS);
  for(i=0; i<np; i++)
  {
    for(j=i; j<np; j++)
    {
      glVertex3f(xp[i][j], yp[i][j], zp[i][j]); /* surface */
    }
  }
  glEnd();

  glColor3f(0.0, 1.0, 0.0);
  glBegin(GL_LINES);
  for(i=0; i<np-1; i++)
  {
    glVertex3f(xp[i][i],yp[i][i],zp[i][i]);
    glVertex3f(xp[i+1][i+1],yp[i+1][i+1],zp[i+1][i+1]);
    for(j=i; j<np-1; j++)
    {
      glVertex3f(xp[i][j],yp[i][j],zp[i][j]);
      glVertex3f(xp[i][j+1],yp[i][j+1],zp[i][j+1]);
    }
  }
  glEnd();

  glColor3f(0.0, 1.0, 0.0);
  glBegin(GL_LINES);
  for(i=0; i<np-1; i++)
  {
    for(j=i+1; j<np; j++)
    {
      glVertex3f(xp[i][j],yp[i][j],zp[i][j]);
      glVertex3f(xp[i+1][j],yp[i+1][j],zp[i+1][j]);
    }
  }
  glEnd();
} /* end draw_points */

static void drawText(float x, float y, char * msg)
{
  int   i, len;

  glPushMatrix();
  glLoadIdentity();
  glRasterPos2f(x, y);
  len = strlen(msg);
  for (i=0; i<len; i++)
    glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18, msg[i]);
  glPopMatrix();
} /* end drawText */


void display(void)
{
  char text1[7][15]={"phi2p(T,x,y)  ", "phi2x(T,x,y)  ", "phi2y(T,x,y)  ",
                     "phi2xx(T,x,y) ", "phi2xy(T,x,y) ", "phi2yy(T,x,y) ",
                     "phi1B(T,x,y)  "};
  char text2[]=" n  next function, s  stop rotation, g  go rotation";
  char text3[]=" mouse button or arrow keys change axis of rotation";
  char text4[]=" blue is base triangle, green lines with red dots is function";
  int i, j;
  
  /* clear window */
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glLoadIdentity();
  glRotatef(theta[0], 1.0, 0.0, 0.0);
  glRotatef(theta[1], 0.0, 1.0, 0.0);
  glRotatef(theta[2], 0.0, 0.0, 1.0);
  glColor3f(0.0, 0.0, 0.0);
  
  /* draw text */
  drawText(0.0, 0.0, text1[next]);
  drawText(-xmax, -ymax+0.5, text2);
  drawText(-xmax, -ymax+0.3, text3);
  drawText(-xmax, -ymax+0.1, text4);

  
  /* Draw the points */
  offset = 0.25;
  compute_phi1();
  draw_points();
  
  glFlush(); 
  glutSwapBuffers();
} /* end display */

void spinCube(void)
{
  if(stop) return;
  /* Idle callback, spin cube .2 degrees about selected axis */
  theta[axis] = theta[axis] + 0.2;
  if(theta[axis] > 360.0) theta[axis] = theta[axis] - 360.0;
  /* display(); */
  glutPostRedisplay();
} /* end spinCube */


void mouse(int btn, int state, int x, int y)
{
  /* mouse callback, selects an axis about which to rotate */
  if(btn==GLUT_LEFT_BUTTON && state == GLUT_DOWN) axis = 0;
  if(btn==GLUT_MIDDLE_BUTTON && state == GLUT_DOWN) axis = 1;
  if(btn==GLUT_RIGHT_BUTTON && state == GLUT_DOWN) axis = 2;
} /* end mouse */

static void keyboard(unsigned char key, int x, int y)
{
  if(key=='s' || key=='S') stop = 1;
  if(key=='g' || key=='G') stop = 0;
  if(key=='n' || key=='N')
  {
    next++;
    if(next>6) next = 0;
  }
  glutPostRedisplay();  
} /* end keyboard */

static void special(int k, int x, int y)
{
  switch(k)
  {
    case GLUT_KEY_LEFT:
      axis = 1;
      break;
    case GLUT_KEY_RIGHT:
      axis = 2;
      break;
    case GLUT_KEY_DOWN:
      axis = 0;
      break;
  }
  glutPostRedisplay();  
}

void myReshape(int w, int h)
{
  glViewport(0, 0, w, h);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glOrtho(-xmax, xmax, -ymax, ymax, -zmax, zmax);
  glMatrixMode(GL_MODELVIEW);
} /* end myReshape */

void init()
{
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glOrtho(-xmax, xmax, -ymax, ymax, -zmax, zmax);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  glClearColor(1.0, 1.0, 1.0, 1.0);
  xp[0][0] = T[0];
  yp[0][0] = T[1];
  xp[0][4] = T[2];
  yp[0][4] = T[3];
  xp[4][4] = T[4];
  yp[4][4] = T[5];
  xp[0][2] = (xp[0][0]+xp[0][4])/2.0;
  yp[0][2] = (yp[0][0]+yp[0][4])/2.0;
  xp[0][1] = (xp[0][0]+xp[0][2])/2.0;
  yp[0][1] = (yp[0][0]+yp[0][2])/2.0;
  xp[0][3] = (xp[0][4]+xp[0][2])/2.0;
  yp[0][3] = (yp[0][4]+yp[0][2])/2.0;
  xp[2][2] = (xp[4][4]+xp[0][0])/2.0;
  yp[2][2] = (yp[4][4]+yp[0][0])/2.0;
  xp[1][1] = (xp[0][0]+xp[2][2])/2.0;
  yp[1][1] = (yp[0][0]+yp[2][2])/2.0;
  xp[1][2] = (xp[0][2]+xp[2][2])/2.0;
  yp[1][2] = (yp[0][2]+yp[2][2])/2.0;
  xp[2][4] = (xp[0][4]+xp[4][4])/2.0;
  yp[2][4] = (yp[0][4]+yp[4][4])/2.0;
  xp[2][3] = (xp[2][2]+xp[2][4])/2.0;
  yp[2][3] = (yp[2][2]+yp[2][4])/2.0;
  xp[1][3] = (xp[0][3]+xp[2][3])/2.0;
  yp[1][3] = (yp[0][3]+yp[2][3])/2.0;
  xp[1][4] = (xp[0][4]+xp[2][4])/2.0;
  yp[1][4] = (yp[0][4]+yp[2][4])/2.0;
  xp[3][3] = (xp[2][2]+xp[4][4])/2.0;
  yp[3][3] = (yp[2][2]+yp[4][4])/2.0;
  xp[3][4] = (xp[2][4]+xp[4][4])/2.0;
  yp[3][4] = (yp[2][4]+yp[4][4])/2.0;
} /* end init */

int main(int argc, char *argv[])
{
  glutInit(&argc, argv);
  /* need both double buffering and z buffer */
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
  glutInitWindowSize(width, height);
  glutCreateWindow(argv[0]);
  glutReshapeFunc(myReshape);
  init();
  glutDisplayFunc(display);
  glutIdleFunc(spinCube);      /* "spinCube" setup */
  glutMouseFunc(mouse);        /* "mouse" setup    */
  glutKeyboardFunc(keyboard);  /* enable keyboard */
  glutSpecialFunc(special);    /* enable arrow keys */
  glutMainLoop();
  return 0;
}