/* 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 identifiers
GLuint mainWindow, curveWindow, controlWindow, knotWindow;

#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

void redisplayAll(void) {
    glutSetWindow(curveWindow);
    glutPostRedisplay();
    glutSetWindow(controlWindow);
    glutPostRedisplay();
    glutSetWindow(knotWindow);
    glutPostRedisplay();
}

const int NO_KNOT = -1;
int knotIndex;                        // the index of the picked knot

// ================================================================
// The model

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

//global parameters for the knots
GLfloat uKnot[30];
int numControlPoints;
int uOrder;
int numKnots;

GLUnurbsObj *myNurb;

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},
};

GLfloat controlPoints[15][4];
GLfloat weights[15];

// This makes a conventional knot vector, with all knots at unit steps
// except for the beginning and the end, where multiple knots force
// the NURBS to interpolate the first and last control points. Adapted
// from Hill pg. 635.  Rescaled to 0..1

void makeKnots(int order, int numControlPoints, GLfloat knot[]) {
  //pts control points and B-splines of order ord
  int i;
  if(numControlPoints < order) { 
    printf("too few points for curve of order %i\n", order);
    return; 
  }
  GLfloat max=numControlPoints-order+1;
  for (i=0; i<order; i++)
    knot[i] = 0.0;
  for (i=order; i<numControlPoints; i++)
    knot[i] = (i-order+1)/max;
  for (i=numControlPoints; i<numControlPoints+order; i++)
    knot[i] = 1.0;
}

void reset (unsigned char key, int x, int y) {
  int i,j;
  uOrder = 3;
  numControlPoints = 15;
  for (i=0; i < numControlPoints; i++) {
    for (j=0; j<4; j++) controlPoints[i][j] = originalPoints[i][j];
  }
  for(i=0; i < numControlPoints; i++) weights[i] = 1;
  numKnots = 18;
  makeKnots(3, 15, uKnot);
  redisplayAll();
}

// ================================================================
// control window

// cells are used in the controlWindow; 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, 180, 300, 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"},
};


// Returns the cell id if the cell has been clicked on, otherwise
// zero.  It's important that it return zero, since this value is
// relied on in selectCell.  This function hard-codes the width of a
// cell as 55 and the height as 30 (and the y-value given above is in
// the center vertically).

bool 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;
}

int selectedCell = 0;

// Given a mouse click, (mx,my), determine the index of the cell that
// was hit, if any.  Store result in selectedCell.  This function
// relies on cellHit returning zero for all cells except the one that
// is hit, if any.

void selectCell(int mx, int my) {
  selectedCell=0;
  selectedCell += cellHit(&curveParams[0], mx, my);
  selectedCell += cellHit(&curveParams[1], mx, my);
  selectedCell += cellHit(&pickedPoint[0], mx, my);
  selectedCell += cellHit(&pickedPoint[1], mx, my);
  selectedCell += cellHit(&pickedPoint[2], mx, my);
  selectedCell += cellHit(&pickedPoint[3], mx, my);
}

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

// updates the cell's value 
void cellUpdate(cell* cell, int update) {
  // generic code
  if (selectedCell != 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;
  if (cell->value > cell->max) cell->value = cell->max;
  // special case code.  Cells 5 and 6 correspond to the number of
  // control points and curve order, so if they are changed, we have
  // to recalculate the knots as well.
  setVals();
  if(cell->id ==5 || cell->id==6) {
    makeKnots(uOrder,numControlPoints,uKnot);
  }
}

int old_y; //for controlWindow mouse

void cellDraw(cell* cell) {
    twColorName(TW_YELLOW); //color of numbers not currently selected
    if (selectedCell == cell->id) {
      // When a number is modified, info text is displayed at the top
      // of the window (10,20), saying what the number means.
        twColorName(TW_CYAN);
        twDrawString(10, 20, cell->info);
    }
    twDrawString(cell->x, cell->y, cell->format, cell->value);
}

const int NO_POINT = -1;       // an invalid index for a control point
int pickedPointIndex = NO_POINT; // a click picks and motion adjusts

//display on right side; where user can adjust values
void controlWindowDisplay() {
  curveParams[1].value = uOrder;
  curveParams[0].value = numControlPoints;

    //set up camera
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0, cWinWidth, cWinHeight, 0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    glClearColor(0.7, 0.7, 0.7, 1.0); //clear to gray
    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(pickedPointIndex != NO_POINT) { //point has been selected
      int p = pickedPointIndex;
      pickedPoint[0].value = controlPoints[p][0];
      pickedPoint[1].value = controlPoints[p][1];
      pickedPoint[2].value = controlPoints[p][2];
      pickedPoint[3].value = weights[p];
      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(10,pickedPoint[3].y, "weight = ");
      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(knotIndex != NO_KNOT) { //knot has been selected
      twDrawString(10, 340, "knot index: %i", knotIndex);
      twDrawString(10, 380, "knot value: %.2f", uKnot[knotIndex]);
    } else {
      twDrawString(10,340, "no knot selected");
    }

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

void controlWindowMouse(int button, int state, int x, int y) {
    if(state == GLUT_DOWN) {
      selectCell(x,y);
    }
    old_y = y;
    redisplayAll();
}

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

//allows for click and drag
void controlWindowMotion(int x, int y) {
  // any movement less than 10 pixels doesn't count.
  if(abs(old_y-y)<10) return;
    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();
}

// ================================================================
// curveWindow

void curveDisplay(void) {
    int i,j;
    twDisplayInit();
    twCamera();

    twColorName(TW_RED);
    glLineWidth(3);
    gluBeginCurve(myNurb);
    {
      GLfloat nurbsCP[numControlPoints][4];
      for(i=0; i<numControlPoints; i++)
        for(j=0; j<4; j++)
          nurbsCP[i][j] = controlPoints[i][j]*weights[i];
      printf("CP[0] = %f %f\n",controlPoints[0][0],controlPoints[0][1]);
    
      gluNurbsCurve(myNurb,numKnots,uKnot,4,&controlPoints[0][0],uOrder,
                    GL_MAP1_VERTEX_4);
    }
    gluEndCurve(myNurb);
 
    twColorName(TW_BLUE);
    glLineWidth(1);
    glBegin(GL_LINE_STRIP); //lines between points
    for(i=0;i<numControlPoints;i++) {
      glVertex4fv(controlPoints[i]);
    }
    glEnd();

    twColorName(TW_GREEN);
    glPointSize(3);
    glBegin(GL_POINTS);     //points
    for(i=0;i<numControlPoints;i++) {
      glVertex4fv(controlPoints[i]);
    }
    glEnd();
    
    glFlush();
    glutSwapBuffers(); 
}

// Pick returns the index of the control point that was picked (must
// be within 4 pixels), or NO_POINT.  Would it be more efficient to
// unproject the x,y point once and then use twPointDistance2?  But
// how would we then choose the threshold?  Maybe unproject a small
// vector and measure the length of the unprojection?

void pick(int x, int y) {
  int i;
  twTriple screen, world;
  for(i = 0; i<numControlPoints; i++) {
    twTripleCopy(world,controlPoints[i]); 
    twProject(screen,world); //project world coords to screen
    int dx = (int)screen[0]-x;
    int dy = (int)screen[1]-y;
    if(dx*dx+dy*dy<16) {
      pickedPointIndex = i;
      printf("picked point %d\n",i);
      return;
    }
  }
  printf("nothing picked\n");
}

// Determine the new position of a control point that has been dragged.

void adjust(int x, int y) {
  if(pickedPointIndex != NO_POINT) {
    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(controlPoints[pickedPointIndex],A,V,0.5);
  }
}

void curveMouse(int button, int state, int x, int y) {
  y=wWinHeight-y;
  if(button==GLUT_LEFT_BUTTON && state==GLUT_DOWN) {
    pick(x,y);
  }
  // have to redisplay controlWindow, to show this point's coordinates
  redisplayAll();
}

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

// ================================================================
// knotWindow is where we can see and change the knot values

void knotDisplay() {
    int i;
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0, 1, 1, 0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    glClearColor(0, 0, 0, 1); //clear to black
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    //horizontal line
    twColorName(TW_RED);
    glLineWidth(3);
    glBegin(GL_LINES);
    glVertex2f(0,0.5);
    glVertex2f(1,0.5);
    glEnd();
    //vertical lines
    twColorName(TW_WHITE);
    glPushMatrix();
    glLineWidth(2);
    for(i=0; i<numKnots; i++) {
      glBegin(GL_LINES);
      glVertex2f(uKnot[i],0.3);
      glVertex2f(uKnot[i],0.7);
      glEnd();
      twSetFont("times roman", 12);
      if(uKnot[i]>0 && uKnot[i]<1)
        twDrawString((int)uKnot[i], 20, "%i", i);
      printf("knot %d = %f\n",i,uKnot[i]);
    }
    glPopMatrix();
    glutSwapBuffers();
}

// Determines the array index for the chosen knot; there's exactly one.
int knotPick(int x, int y) {
  int i;
  twTriple screen = {x,y,0}, world;
  twUnProject(world,screen);
  GLfloat mouse_x = world[0];
  // find which knot value is closest.  What about ties?  Find the
  // pair of indices where the screen value is between the knots, and
  // use the closer knot.
  while(uKnot[i]<mouse_x) i++;
  i--;
  if(mouse_x-uKnot[i] > uKnot[i+1]-mouse_x)
    knotIndex = i+1;
  else 
    knotIndex = i;
}

//changes knotXVal[element] to x, finds the new knot value
void knotAdjust(int x, int y) {
  // this calculation is essentially what unprojection would do.
  uKnot[knotIndex] = (float)x*(numControlPoints-uOrder+1)/(cWinWidth);
}

int knotMouse_x, knotMouse_y;

void knotMouse(int button, int state, int x, int y) {
  if(button==GLUT_LEFT_BUTTON && state==GLUT_DOWN){
    knotMouse_x=x;
    knotMouse_y=y;
    knotPick(x,y);
  }
  redisplayAll();
}

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

void printVals(unsigned char key, int x, int y) {
  int i;
  int numControlPoints = (int)curveParams[0].value;
  int order = (int)curveParams[1].value;
  printf("numControlPoints = %i, order = %i\n", numControlPoints, order);
  printf("Your current control points and their weights are: \n");
  for(i=0; i<numControlPoints; i++) {
    printf("   %d:  %f %f %f, weight = %f\n",i,
           controlPoints[i][0],
           controlPoints[i][1],
           controlPoints[i][2],
           weights[i]);
  }
  printf("Your knot values are: {");
  int numKnots = numControlPoints+order;
  for(i=0; i<numKnots; i++) {
    printf("%.2f, ", uKnot[i]); 
  }
  printf("}\n");
}

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

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

// ================================================================
// main window (AKA parent window)

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);
    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();
}

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

    //lower right sub-window (knot control)
    knotWindow = glutCreateSubWindow(mainWindow, GAP*2+wWinWidth, GAP*2+cWinHeight,
                                     cWinWidth, 75);
    twBoundingBox(-1,1,-1,1,-1,1);
    myInit();
    glutDisplayFunc(knotDisplay);
    glutMotionFunc(knotMotion);
    glutMouseFunc(knotMouse);
    
    //left sub-window
    curveWindow = glutCreateSubWindow(mainWindow, GAP, GAP,wWinWidth,wWinHeight);
    twBoundingBox(-10,10,-10,10,-10,10);
    myInit();
    myNurb=gluNewNurbsRenderer();
    gluNurbsProperty(myNurb,GLU_DISPLAY_MODE,GLU_FILL);
    glutDisplayFunc(curveDisplay);
    glutMouseFunc(curveMouse);
    glutMotionFunc(curveMotion);
    
    reset(0,0,0);                // initialize all model parameters
    redisplayAll();
    glutMainLoop();
    return 0;
}