/* Tutor on NURB curves (1-dimension)

Written by Caroline Geiersbach and Scott D. Anderson
scott.anderson@acm.org
Summer 2003
*/

#include <stdio.h>
#include <stdlib.h>
#include <GL/glut.h>
#include <math.h>
#include "tw.h"

//window stuff
GLuint window, adjustable, world, command;
#define GAP 25               //gap between subwindows
int cWinWidth = 450;         //command window width
int cWinHeight = 450;        //command window height
int wWinWidth = 450;         //world window width
int wWinHeight = 550;        //world window height
int mWinWidth = 900+GAP*3;   //main window width 
int mWinHeight = 600;       //main window height

//for picking
int count;
int p=15; //unselected point
int k=31; //unselected knot

//global parameters for the knots
GLfloat uKnot[30];
GLfloat knotXVal[30]; //position of knots on screen
static int numPoints;
static int uOrder;
static int numKnots;

GLUnurbsObj *myNurb;
void redisplayAll();

//specify all control points here
GLfloat points[15][4] = {
  {-7,-3,1,1}, {-6,-3,1,1}, {-5,0,1,1}, {-4,-5,1,1}, {-3,5,1,1}, 
  {-2,-3,1,1}, {-1,3,1,1}, {0,-16,1,1}, {1,0,1,1}, {2,-3,1,1}, 
  {3,-10,1,1}, {4,13,1,1}, {5,-10,1,1}, {6,-3,1,1},{7,-4,1,1},
};

GLfloat originalPoints[15][4] = {
  {-7,-3,1,1}, {-6,-3,1,1}, {-5,0,1,1}, {-4,-5,1,1}, {-3,5,1,1}, 
  {-2,-3,1,1}, {-1,3,1,1}, {0,-16,1,1}, {1,0,1,1}, {2,-3,1,1}, 
  {3,-10,1,1}, {4,13,1,1}, {5,-10,1,1}, {6,-3,1,1},{7,-4,1,1},
};

//cells are used in the command window; each cell has an id; a
//raster location at x,y; min and max values; a current value; the 
//step for adjusting values; info on what the cell specifies; and
//finally the format of the printed values.
typedef struct _cell {
    int id;
    int x, y;
    GLfloat min, max;
    GLfloat value;
    GLfloat step;
    char* info;
    char* format;
} cell;

cell pickedPoint[4] = {
    { 1, 180, 260, -24.0, 24.0, 0.0, 0.05,
    "Specifies X coordinate of point that was last clicked.", "%.2f" },
    { 2, 240, 260, -24.0, 24.0, 0.0, 0.05,
    "Specifies Y coordinate of point that was last clicked.", "%.2f" },
    { 3, 300, 260, -24.0, 24.0, 0.0, 0.0, //z coord non-adjustable
    "Specifies Z coordinate of point that was last clicked.", "%.2f" },
    { 4, 360, 260, 0, 50.0, 1.0, 0.5,
    "Specifies weight of the point that was last clicked.", "%.2f" },
};

cell curveParams[2] = {
    {5, 225, 100, 0, 15, 15, 1,
     "Specifies the number of control points for the curve.", "%.1f"},
    {6, 150, 180, 0, 15, 3, 1,
     "Specifies the order of the curve.", "%.1f"},
};

GLint selection = 0;
int old_y; //for command mouse

//moves information from command window to corresponding global variables
void setVals () {
  numPoints = (int)curveParams[0].value;
  uOrder = (int)curveParams[1].value;
  numKnots = numPoints + uOrder;
}

/*
void setWeights() {
  int i, j;
  for (i = 0; i < numPoints; i++) {
    pt[i][3] = points[i][3];
    for(j = 0; j<3; j++) {
      pt[i][j] = points[i][3]*pt[i][3];
    }
  }
  printf("curve with weights:\n");
  for(i=0;i<numPoints;i++) {
    for(j=0;j<3;j++) {
      printf("pt[%i][%i] = %.2f  ", i, j, pt[i][j]);
    }
  }
  printf("\n");    
  }*/

//adapted from Hill pg. 635
void makeKnots(int ord, int pts, GLfloat knot[]) {
  //pts control points and B-splines of order ord
  int i;
  if(pts < ord) { 
    printf("too few points for curve of order %i\n", ord);
    return; 
  }
  for (i=0; i<pts+ord; i++) {
    if (i<ord) knot[i]=0.0;
    else if (i<pts) knot[i] = i-ord+1; //i at least ord
    else knot[i] = pts-ord+1; //i exceeds pts
  }
}

//sets X position of knots on screen
void setKnotXVal() { 
  int i;
  GLfloat space = numPoints-uOrder+1; //intervals between knots
  if(numPoints>=uOrder) {
    for(i=0; i <numKnots; i++) {
      if (i < uOrder) knotXVal[i] = 0.0;
      else if (i < numPoints) knotXVal[i]=cWinWidth*(i-uOrder+1)/space;
      else knotXVal[i] = cWinWidth-2;
    }
  }
}

void mainDisplay() {
    //set up camera 
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0,mWinWidth,mWinHeight,0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glClearColor(0.7, 0.7, 1.0, 0.0); //light blue background
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glColor3f(0,0,0);
    twSetFont("helvetica", 12);
    twDrawString(GAP, 20, "your nurb");
    twDrawString(GAP*2+wWinWidth, 20, "adjustment window");
    twDrawString(GAP*2+wWinWidth, cWinHeight+45, "knot adjustment");

    glutSwapBuffers();
}

/* WORLD */
void worldDisplay(void) {
    int i,j;
    glClearColor(1,1,1,1);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    twCamera();

    twColorName(TW_ORANGE);
    glLineWidth(3);
    gluBeginCurve(myNurb);
    
    /*gluNurbsCurve(GLUnurbsObj *myNurb, GLint uKnotCount, GLfloat *uKnot,
     GLint uStride, GLfloat *points, GLint uOrder(degree+1), GLenum type)*/
    gluNurbsCurve(myNurb,numKnots,uKnot,4,&points[0][0],uOrder,
                  GL_MAP1_VERTEX_3);
    gluEndCurve(myNurb);
 
    twColorName(TW_GRAY);
    glLineWidth(1);
    glBegin(GL_LINE_STRIP); //lines between points
    for(i=0;i<numPoints;i++) {
      glVertex3fv(points[i]);
    }
    glEnd();

    twColorName(TW_BLACK);
    glPointSize(3);
    glBegin(GL_POINTS);     //points
    for(i=0;i<numPoints;i++) {
      glVertex3fv(points[i]);
    }
    glEnd();
    
    glFlush();
    glutSwapBuffers(); 
}

//returns the array element num; otherwise 15
int pick(int x, int y) {
  int i;
  twTriple screen, world;
  for(i = 0; i<numPoints; i++) {
    twTripleCopy(world,points[i]); 
    twProject(screen,world); //project world coords to screen
    if(x<screen[0]+4 && x>screen[0]-4 && y<screen[1]+4 && y>screen[1]-4) {
      return i;
    }
  }
  return 15;
}

void adjust(int x, int y, int element) {
  if(p<15) {
    twTriple world; //new coords for element
    twTriple A,B,V; 
    twTriple winA = {x,y,0}; 
    twTriple winB = {x,y,1}; 
    twUnProject(A,winA);
    twUnProject(B,winB);
    twVector(V,B,A);
    twPointOnLine(points[element],A,V,0.5);
    //setWeights();
  }
}

static int mouse_x, mouse_y;

void worldMouse(int button, int state, int x, int y) {
  y=wWinHeight-y;
  if(button==GLUT_LEFT_BUTTON && state==GLUT_DOWN){
    mouse_x=x;
    mouse_y=y;
    p = pick(x,y);
  }
  redisplayAll();
}

void worldMotion(int x, int y) {
  y=wWinHeight-y;
  adjust(x,y,p);
  redisplayAll();
}

void worldInit() {
  int i,k, j;
  glutMouseFunc(worldMouse);
  glutMotionFunc(worldMotion);
  myNurb=gluNewNurbsRenderer();
  gluNurbsProperty(myNurb,GLU_DISPLAY_MODE,GLU_FILL);
  glEnable(GL_MAP1_VERTEX_3);
  // glEnable(GL_MAP1_VERTEX_4);

  setVals();
  makeKnots(uOrder,numPoints,uKnot);
  setKnotXVal();
  /*
  for (i = 0; i < numPoints; i++) {
    pt[i][3] = points[i][3];
    for(j = 0; j<3; j++) {
      pt[i][j] = points[i][j]*pt[i][3];//points1[i][j]*points[i][3];
    }
    }*/
  /*setWeights();
    printf("curve with weights:\n");
    for(k=0;k<numPoints;k++) {
      for(j=0;j<4;j++) {
        printf("pt[%i][%i] = %.2f\n", k, j, pt[k][j]);
      }
      }*/
}

/* COMMAND */
void cellDraw(cell* cell) {
    twColorName(TW_WHITE); //color of unselected numbers
    if (selection == cell->id) {
        twColorName(TW_CYAN); //color of info text
        twDrawString(10, 20, cell->info);
    }
    twDrawString(cell->x, cell->y, cell->format, cell->value);
}

//returns cell id if cell has been clicked on; 0 otherwise
int cellHit(cell* cell, int x, int y) {
    if (x > cell->x && x < cell->x+55 &&
        y > cell->y-15 && y < cell->y+15){
        return cell->id;
    }
    return 0;
}

//updates the cell's value 
void cellUpdate(cell* cell, int update) {
    if (selection != cell->id)
        return;
    cell->value += update * cell->step;
    //tests for min and max values of the points
    if (cell->value < cell->min)
        cell->value = cell->min;
    else if (cell->value > cell->max) 
        cell->value = cell->max;
    setVals();
    if(cell->id ==5 || cell->id==6) {//curve params change; redo knots
      printf("uOrder = %i, numPoints = %i\n", uOrder, numPoints);
      makeKnots(uOrder,numPoints,uKnot);
      setKnotXVal();
    }
}

//display on right side; where user can adjust values
void commandDisplay() {
    //set up camera
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0, cWinWidth, cWinHeight, 0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    glClearColor(0.0, 0.0, 0.0, 1.0); //clear to black
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    twSetFont("helvetica", 18);
    twDrawString(10, curveParams[0].y, "number of control points:");
    twDrawString(10, curveParams[1].y, "order of curve:");
    cellDraw(&curveParams[0]);
    cellDraw(&curveParams[1]);

    if(p<15) { //point has been selected
      pickedPoint[0].value = points[p][0]; 
      pickedPoint[1].value = points[p][1];
      pickedPoint[2].value = points[p][2];
      pickedPoint[3].value = points[p][3];
      twDrawString(10, pickedPoint[0].y, "point coordinates = (");
      twDrawString(pickedPoint[0].x+55, pickedPoint[0].y, ",");
      twDrawString(pickedPoint[1].x+55, pickedPoint[1].y, ",");
      twDrawString(pickedPoint[2].x+55, pickedPoint[2].y, ",");
      twDrawString(pickedPoint[3].x+55, pickedPoint[3].y, ");");
      cellDraw(&pickedPoint[0]);
      cellDraw(&pickedPoint[1]);
      cellDraw(&pickedPoint[2]);
      cellDraw(&pickedPoint[3]);  
    } else {
      twColorName(TW_ORANGE);
      twDrawString(10, pickedPoint[0].y, "click on point to view its coords.");
    }

    twColorName(TW_RED);
    if(k<31) { //knot has been selected
      twDrawString(10, 340, "knot index: %i", k);
      twDrawString(10, 380, "knot value: %.2f", uKnot[k]);
    } else {
      twDrawString(10,340, "no knot selected");
    }

    if (!selection) {
      twColorName(TW_CYAN);
      twDrawString(10, 20,
       "Click on args and move mouse to modify values.");
    }   
    //directions at bottom of command window
    twColorName(TW_CYAN);
    twDrawString(10,425, "Hit <p> to print point and knot values.");
    twColorName(TW_WHITE);
    glutSwapBuffers();
}

void commandMouse(int button, int state, int x, int y) {
    selection = 0;
    if(state == GLUT_DOWN) {
      /* mouse should only hit _one_ of the cells, so adding up all
         the hits just propagates a single hit. */
      selection += cellHit(&curveParams[0], x, y);
      selection += cellHit(&curveParams[1], x, y);
      selection += cellHit(&pickedPoint[0], x, y);
      selection += cellHit(&pickedPoint[1], x, y);
      selection += cellHit(&pickedPoint[2], x, y);
      selection += cellHit(&pickedPoint[3], x, y);
    }
    old_y = y;
    redisplayAll();
}

//sets values of pickedPoint to the correct point in the points array
void setPoint() {
  points[p][0] = pickedPoint[0].value;
  points[p][1] = pickedPoint[1].value;
  points[p][2] = pickedPoint[2].value;
  points[p][3] = pickedPoint[3].value;
  
  //  setWeights();
}

/*void setNewWeights() {
  int i, j;
    for (i = 0; i < numPoints; i++) {
      points[i][3] = points1[i][3];
      for(j = 0; j<3; j++) {
        points[i][j] = points1[i][j]*points[i][3];
      }
    }

}
*/
//allows for click and drag
void commandMotion(int x, int y) {
    cellUpdate(&curveParams[0], old_y-y);
    cellUpdate(&curveParams[1], old_y-y);
    cellUpdate(&pickedPoint[0], old_y-y);
    cellUpdate(&pickedPoint[1], old_y-y);
    cellUpdate(&pickedPoint[2], old_y-y);
    cellUpdate(&pickedPoint[3], old_y-y);
    setPoint();
    old_y = y;
    redisplayAll();
}

/* ADJUSTABLE */
void adjustableDisplay() {
    int i;
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0, cWinWidth, 75, 0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    glClearColor(0.0, 0.0, 0.0, 1.0); //clear to black
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    //horizontal line
    twColorName(TW_RED);
    glLineWidth(3);
    glBegin(GL_LINES);
    glVertex2f(0,40);
    glVertex2f(cWinWidth, 40);
    glEnd();
    //vertical lines
    twColorName(TW_WHITE);
    glPushMatrix();
    glLineWidth(2);
    for(i=0; i<numKnots; i++) {
      glBegin(GL_LINES);
      glVertex2f(knotXVal[i],35);
      glVertex2f(knotXVal[i],45);
      glEnd();
      twSetFont("times roman", 12);
      if(knotXVal[i]>0 && knotXVal[i]<cWinWidth-2)
        twDrawString((int)knotXVal[i]-2, 20, "%i", i);
    }
    glPopMatrix();
    glutSwapBuffers();

}

//returns the array element num; otherwise 31
int knotPick(int x, int y) {
  int i;
  twTriple screen, world;
  for(i = 0; i<numKnots; i++) {
    if(x<knotXVal[i]+5 && x>knotXVal[i]-5 && y<45 && y>35) {
      //printf("selected knot: %i\n",i); 
      return i;
    }
  }
  return 31; //did not click on a knot
}

//changes knotXVal[element] to x, finds the new knot value
void knotAdjust(int x, int y, int element) {
  if(k<31) {
    knotXVal[element]=x;
    uKnot[element]= (float)x*(numPoints-uOrder+1)/(cWinWidth);
  }
}

int aMouse_x, aMouse_y;

void adjustableMouse(int button, int state, int x, int y) {
  if(button==GLUT_LEFT_BUTTON && state==GLUT_DOWN){
    aMouse_x=x;
    aMouse_y=y;
    k = knotPick(x,y);
  }
  redisplayAll();
}

void adjustableMotion(int x, int y) {
  knotAdjust(x,y,k);
  redisplayAll();
}

void printVals(unsigned char key, int x, int y) {
  int i;
  int numPoints = (int)curveParams[0].value;
  int order = (int)curveParams[1].value;
  printf("numPoints = %i, order = %i\n", numPoints, order);
  printf("Your current control points are: \n");
  for(i=0; i<numPoints; i++) {
    printf("control point %i",i);
    twTriplePrint("", points[i]);
  }
  printf("Your knot values are: {");
  int numKnots = numPoints+order;
  for(i=0; i<numKnots; i++) {
    printf("%.2f, ", uKnot[i]); 
  }
  printf("}\n");
  printf("Your knot X values are: {");
  for(i=0; i<numKnots; i++) {
    printf("%.2f, ", knotXVal[i]);
  }
  printf("}\n");
}

void reset (unsigned char key, int x, int y) {
  int i,j;
  uOrder = 3;
  numPoints = 15;
  curveParams[0].value = 15;
  curveParams[1].value = 3;
  for (i =0; i < 15; i ++) {
    for (j=0; j<4; j++) points[i][j] = originalPoints[i][j];
  }
  numKnots = 18;
  makeKnots(3, 15, uKnot);
  setKnotXVal();
  redisplayAll();
}

void keyInit() {
  twKeyCallback('p', printVals, "prints current values.");
  twKeyCallback('r', reset, "resets values.");
}

void redisplayAll(void) {
    glutSetWindow(world);
    glutPostRedisplay();
    glutSetWindow(command);
    glutPostRedisplay();
    glutSetWindow(adjustable);
    glutPostRedisplay();
}

void myInit() {
  twMainInit();
  keyInit();
}

int main(int argc, char** argv) {
    glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
    glutInitWindowSize(mWinWidth, mWinHeight); 
    glutInitWindowPosition(0, 0);
    glutInit(&argc, argv);
    
    //parent window
    window = glutCreateWindow("Tutor on 1-dimensional NURBS");
    glutDisplayFunc(mainDisplay);
    myInit();
      
    //upper right sub-window
    command = glutCreateSubWindow(window, GAP*2+wWinWidth, GAP, 
                                  cWinWidth,cWinHeight);
    glutDisplayFunc(commandDisplay);
    myInit();
    glutMotionFunc(commandMotion);
    glutMouseFunc(commandMouse);

    //lower right sub-window (knot control)
    adjustable = glutCreateSubWindow(window, GAP*2+wWinWidth, GAP*2+cWinHeight,
                                     cWinWidth, 75);
    twBoundingBox(-1,1,-1,1,-1,1);
    myInit();
    glutDisplayFunc(adjustableDisplay);
    glutMotionFunc(adjustableMotion);
    glutMouseFunc(adjustableMouse);
    
    //left sub-window
    world = glutCreateSubWindow(window, GAP, GAP,wWinWidth,wWinHeight);
    twBoundingBox(-10,10,-10,10,-10,10);
    glutDisplayFunc(worldDisplay);
    myInit();
    worldInit();
    
    redisplayAll();
    glutMainLoop();
    return 0;
}