/* NURB curve (2-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 "tw.h"
#include <math.h>

//mouse mode
int mouseMode = 1;
int drawMode = 0; //wireframe
int curveMode = 0; //show curve
//for picking
int count;
int p;

//number of points the user wants
GLint uPointsCount=11;
GLint vPointsCount = 9;

GLUnurbsObj *myNurb;
GLint uOrder=4; //degree+1
GLint vOrder = 3; 

GLint uKnotCount;
GLint vKnotCount = 12;

GLfloat vKnot[12] = {0,0,0,1,1,2,2,3,3,4,4,4};

GLuint material = 0;
GLuint textureIDs[3];
/*-------------------------------------------------------------------
CONTROL POINTS
  One can construct an object out of a polynomial (you have to supply 
  many more points, though!). Specifying control points is much more 
  efficient for the programmer.*/

GLfloat points[13][9][4];
GLfloat conicPoints[9][4];

/*GLfloat vasePoints[6][4] = { //lamp
  {-14,-11.8,0,1}, {-11.9,-2.9,0,1},{-3.4,4.5,0,1},{-3.3,7.3,0,1},
  {-3.3,8.5,0,1},{0,8.5,0},
  };*/

/*GLfloat vasePoints[5][4] = { //hershey's kiss
  {0,-10.5,0,1}, {-13.7,-10.6,0,1},{-8.0,-4.6,0,1}, {-3.0,1.1,0,1},
  {0,4.7,0,1}};*/

GLfloat vasePoints[13][4] = { //vase's profile (u)
  {-3.9,-14.0,0,1}, {-3.9,-14.0,0,1}, {-3.9,-14.0,0,1}, 
  {-5,-10,0,1}, {-12.5,-5.0,0,1}, {-12.5,-5.0,0,1}, 
  {-12.5,-5.0,0,1}, {-10,3.0,0,1}, {0,2.6,0,1},
  {0,2.6,0,1},{0,2.6,0,1},{2.2,2.4,0,1},{0,0,0,1}, 
  };

/*GLfloat vasePoints[3][4] = {
  {-3,4,0,1}, {-3,0,0,1}, {-3,-4,0,1}
  };*/

GLfloat initConicPoints(GLfloat x, GLfloat y) {
  int i,j;
  // GLfloat conicPointsWeights[7][4]= {
    /* {0,y,x*-0.5,1},
    {x*0.5,y,x*-0.5,0.5},
    {x*0.25,y,x*-0.0669873,1}, 
    {0,y,x*0.3880254,0.5},
    {x*-0.25,y,x*-0.0669873,1},
    {x*-0.5,y,x*-0.5,0.5}, 
    {0,y,x*-0.5,1},
    };*/
  GLfloat a = sqrt(2)/2;
  GLfloat conicPointsWeights[9][4]= {
    {x,y,0,1},{x,y,x,a},{0,y,x,1},{-x,y,x,a}, {-x,y,0,1},{-x,y,-x,a},
    {0,y,-x,1},{x,y,-x,a},{x,y,0,1}};
  for(i = 0; i < 9; i++) {
    conicPoints[i][3] = conicPointsWeights[i][3];
    for(j = 0; j<3; j++) {
        conicPoints[i][j] = conicPointsWeights[i][j]*conicPoints[i][3];
    }
  }
}

void initSurface() {
  int u,v;
  for(u=0;u< uPointsCount; u++) {//u<2; u++) {
    initConicPoints(vasePoints[u][0],vasePoints[u][1]);
    // is the following still necessary?  -- sda
    for(v=0; v<vPointsCount;v++) {
      points[u][v][0]=conicPoints[v][0];
      points[u][v][1]=conicPoints[v][1];
      points[u][v][2]=conicPoints[v][2];
      points[u][v][3]=conicPoints[v][3];
    }
  }
}

//adapted from Hill pg. 635; constructs the standard knot vector
void makeKnots(int ord, int pts, GLfloat knot[]) {
    //control points pts and B-splines of order ord
    int i;
    if(pts < ord) { 
      printf("too few control points entered for curve of order %i\n",uOrder);
      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
      // printf("knot[%i]=%f\n", i, knot[i]);
    }
}

void display(void) {
    int i,j,k,m;
    twDisplayInit();
    twCamera();
   
    //create knots
    uKnotCount = uOrder+uPointsCount;
    GLfloat uKnot[uKnotCount];
    makeKnots(uOrder,uPointsCount,uKnot);

    glLineWidth(1);
    //    twTriple nurbColor = {0.8,0.3,0.8};
    twTriple nurbColor = {1,1,1};
    twColor(nurbColor,1.0,128.0);

    if(drawMode == 1) {
        glEnable(GL_LIGHTING);
    }
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, textureIDs[material]);
    gluBeginSurface(myNurb);
    /*gluNurbsSurface(GLUnurbsObj *myNurb, GLint uKnotCount, GLfloat *uKnot,
      GLint vKnotCount,GLfloat *vKnot,GLint uStride,GLint vStride,GLfloat
      *points,GLint uOrder,GLint vOrder,GLenum type)*/
    gluNurbsSurface(myNurb, uKnotCount,uKnot,vKnotCount,vKnot,36,4,
          &points[0][0][0],uOrder,vOrder, GL_MAP2_TEXTURE_COORD_2);
    gluNurbsSurface(myNurb, uKnotCount,uKnot,vKnotCount,vKnot,36,4,
          &points[0][0][0],uOrder,vOrder, GL_MAP2_NORMAL);
    gluNurbsSurface(myNurb,uKnotCount,uKnot,vKnotCount,vKnot,36,4,//3,21,
                    &points[0][0][0],uOrder,vOrder,GL_MAP2_VERTEX_4);
    gluEndSurface(myNurb);
    glDisable(GL_TEXTURE_2D);
    glDisable(GL_LIGHTING);
    
    if(curveMode == 0) {
        twColorName(TW_RED);
        glPointSize(7.0);
        glBegin(GL_POINTS);
        for(i = 0; i <uPointsCount; i++) {
            glVertex3fv(vasePoints[i]);
        }
        glEnd();

        twColorName(TW_BLUE);
        glLineWidth(3);
        gluBeginCurve(myNurb);
        gluNurbsCurve(myNurb,uKnotCount,uKnot,4,&vasePoints[0][0],uOrder,
                      GL_MAP1_VERTEX_4);
        gluEndCurve(myNurb);
    }
   
    glFlush();
    glutSwapBuffers(); 
}

//returns the array element num; otherwise 15
int testClick(int x, int y) {
    int i;
    twTriple screen, world;
    for(i = 0; i<uPointsCount; i++) {
      twTripleCopy(world,vasePoints[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 pick(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(vasePoints[element],A,V,0.5);
    }
}

static int mouse_x, mouse_y;

void myMouse(int button, int state, int x, int y) {
    if (mouseMode == 0) twMouseFunction(button,state, x,y);
    else {
      y=650-y;
      if(button==GLUT_LEFT_BUTTON && state==GLUT_DOWN){
        mouse_x=x;
        mouse_y=y;
        p = testClick(x,y);
      }
    }
}

void myMotion(int x, int y) {
    if(mouseMode == 0) twMotionFunction(x,y);
    else {
      y=650-y;
      pick(x,y,p);
      initSurface();
      glutPostRedisplay();
    }
}

void printCoords(unsigned char key, int x, int y) {
    int i;
    printf("Your current control points are: \n");
    for(i=0; i<uPointsCount; i++) {
      printf("control point %i",i);
      twTriplePrint("", vasePoints[i]);
    }
}

void setKeyMode(unsigned char key, int x, int y) {
    if (key == 'm') mouseMode = 0; //tw settings
    else mouseMode = 1;
}

void myInit();

void setDrawMode(unsigned char key, int x, int y) {
  if (key == 'w') {
      drawMode = 0;
  } else {
      drawMode = 1;
  }
  myInit();
  glutPostRedisplay();
}

void setCurveMode(unsigned char key, int x, int y) {
  if (key == 'h') curveMode = 1;
  else curveMode = 0;
  // myInit();
  glutPostRedisplay();
}

void setMaterial(unsigned char key, int x, int y) {
    switch(key) {
    case('t'): material = 0; break;
    case('r'): material = 1; break;
    case('e'): material = 2; break;
    }
    glutPostRedisplay();
}

void keyInit() {
    twKeyCallback('p', printCoords, "prints values of control points");
    twKeyCallback('m', setKeyMode, "tw mouse settings");
    twKeyCallback('M', setKeyMode, "my mouse settings");
    twKeyCallback('w', setDrawMode, "draws in wireframe mode");
    twKeyCallback('f', setDrawMode, "draws in fill mode");
    twKeyCallback('h', setCurveMode, "hides lines");
    twKeyCallback('s', setCurveMode, "shows lines");
    twKeyCallback('t', setMaterial, "wood");
    twKeyCallback('r', setMaterial, "rock");
    twKeyCallback('e', setMaterial, "wood2");
}

void loadTextures() {
  glGenTextures(3,textureIDs);
  twLoadTexture(textureIDs[0], "wood.ppm");
  twLoadTexture(textureIDs[1], "granite.ppm");
  twLoadTexture(textureIDs[2], "redWood.ppm");
}

void myInit() {
    glShadeModel(GL_SMOOTH);
    // glEnable(GL_NORMALIZE);
    GLfloat lightPos[] = {8,-5,1,0};
    twTriple lightColor = {0.5,0.5,0.5};
    twTriple specColor = {0.7,0.7,0.7};
    glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
    glLightfv(GL_LIGHT0, GL_AMBIENT_AND_DIFFUSE, lightColor);
    glLightfv(GL_LIGHT0, GL_SPECULAR, specColor);
    twAmbient(0.3);
    glEnable(GL_LIGHT0);
    
    initSurface();
    twMainInit();
    glutMouseFunc(myMouse);
    glutMotionFunc(myMotion);
    keyInit();
    myNurb=gluNewNurbsRenderer();
    gluNurbsProperty(myNurb,GLU_SAMPLING_TOLERANCE,50.0);
    if (drawMode == 0) //wireframe
      gluNurbsProperty(myNurb,GLU_DISPLAY_MODE,GLU_OUTLINE_POLYGON);
    else
      gluNurbsProperty(myNurb,GLU_DISPLAY_MODE,GLU_FILL);
    glEnable(GL_MAP2_VERTEX_4);
    glEnable(GL_MAP1_VERTEX_4);
    loadTextures();
}

int main(int argc, char **argv) {
    /* printf("Enter the number of profile control points, up to 15 points\n");
    scanf("%i", &uPointsCount);
    printf("Enter the order of the curve\n");
    scanf("%i", &uOrder);
    */
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    twInitWindowSize(650, 650);
    twBoundingBox(-10,10,-10,10,-10,10);
    glutCreateWindow("NURBS!");
    glutDisplayFunc(display);
    twMainInit();
    myInit();
    glutMainLoop();
    return 0;
}

/* extra code
    
    for(i=0;i<5;i++) 
    for(j=0;j<7;j++) 
      printf("%2d: %f %f %f %f \n",7*i+j,
             points[i][j][0],
             points[i][j][1],
             points[i][j][2],
             points[i][j][3]);*/