/********************************************************************
  Title: Interactive Design of Triangular Meshes
  Author: Anand Murugappan (anandm@cc.gatech.edu)
  Advisor: Prof. Jarek Rossignac (jarek@cc.gatech.edu)
  Date: 13th Oct 2005
  
  Code layout:                                        
   1. Globals
      1.1 Constants
      1.2 Flags
      1.3 Colors
      1.4 Tables [These are the data structures for mesh
                  manupalation]
   2. Save/Load Routines
      2.1 unloadAll
        2.1.1 unloadPoints
        2.1.2 unloadTriangles
        2.1.3 unloadOpposites
      2.2 loadAll
        2.2.1 loadPoints
        2.2.2 loadTriangles
        2.2.3 loadOpposites
   3. Navigational Routines
      3.1 getNext
      3.2 getPrevious
      3.3 getRight
      3.4 getLeft
      // Why isnt getOpposite here? It is as simple as O[gC]
   4. Display Routines
      4.1 highlightCurrentVertexGate
      4.2 drawTriangularMesh
      4.3 drawMenu [Needs to be extended to have a menu displayed]
      4.4 setup
      4.5 drawAxis
      4.6 drawAtom
      4.7 draw 
   5. Merge Routines
      5.1 getNearestVertex
      5.2 merge
   6. Input Routines 
      6.1 keyPressed
      6.2 // Mouse movements to be added here!
*********************************************************************/

// global constants
int gMinX = 10;
int gMinY = 10;
int gMaxX = 600-20;
int gMaxY = 600-20;
int gUnit = 10;
int gAngleX = 0;
int gAngleY = 0;
int gAngleZ = 0;

// flags
boolean fillNeeded = false;
boolean axisNeeded = true;

// Colors
color black = color(0, 0, 0); 
color red = color(200, 0, 0); 
color green = color(0, 200, 0); 
color blue = color(0, 0, 200); 
color yellow = color(250, 250, 130);
color white = color(255,255,255);
color bgWhite = color(255,255,255,0);
color grey = color(220,220,220);
color lightYellow = color(250,250,200);
color backgroundClr = white;

// Global tables
float [][] G = new float[500][3]; // Geometry Table
int gGLast=0;
int [] V = new int[500]; // Incidence Table
int gVLast=0;
int gC=0; // Current Vertex!
int [] O = new int[500]; // Opposite Table
int gOLast=0;

/*************************************************************/
/* Save/Load routines                                        */
/*************************************************************/

void unloadPoints()
{
  String [] dumpString = new String [3*gGLast+1];
  dumpString[0] = str(gGLast);
  for(int i=0;i<gGLast;i++)
  {
    dumpString[1+i*3] = str(G[i][0]);
    dumpString[1+i*3+1] = str(G[i][1]);
    dumpString[1+i*3+2] = str(G[i][2]);
  }
  saveStrings("points.ite",dumpString);
}

void unloadTriangles()
{
  String [] dumpString = new String [gVLast+1];
  dumpString[0] = str(gVLast);
  for(int i=0;i<gVLast;i++)
  {
    dumpString[1+i] = str(V[i]);
  }
  saveStrings("triangles.ite",dumpString);
}

void unloadOpposites()
{
  String [] dumpString = new String [gOLast+1];
  dumpString[0] = str(gOLast);
  for(int i=0;i<gOLast;i++)
  {
    dumpString[1+i] = str(O[i]);
  }
  saveStrings("opposites.ite",dumpString);
}

void unloadAll()
{
  unloadPoints();
  unloadTriangles();
  unloadOpposites();
}

void loadPoints()
{
  String lines[] = loadStrings("points.ite"); 
  gGLast = int(lines[0]);
  for(int i=0;i<gGLast;i++)
  {
    G[i][0] = float(lines[1+i*3]);
    G[i][1] = float(lines[1+i*3+1]);
    G[i][2] = float(lines[1+i*3+2]);
  }
}

void loadTriangles()
{
  String lines[] = loadStrings("triangles.ite"); 
  gVLast = int(lines[0]);
  for(int i=0;i<gVLast;i++)
  {
    V[i] = int(lines[1+i]);
  }
}

void loadOpposites()
{
  String lines[] = loadStrings("opposites.ite"); 
  gOLast = int(lines[0]);
  for(int i=0;i<gOLast;i++)
  {
    O[i] = int(lines[1+i]);
  }
}

void loadAll()
{
  loadPoints();
  loadTriangles();
  loadOpposites();
}

/*************************************************************/
/* Navigational routines                                     */
/*************************************************************/
// Get the next corner given the current one
int getNext (int c)
{
  switch (c%3)
  {
    case 0:
      return c+1;
   
    case 1:
      return c+1;
   
    case 2:
      return c-2;
  };
  return -1;
}

// Get the next corner given the current one
int getPrevious(int c)
{
  return getNext(getNext(c));
}

// Get the right corner given the current one
int getRight(int c)
{
  if (O[c] != -1)
  {
    return getNext(O[c]);
  }
  
  return c;
}

// Get the left corner given the current one
int getLeft(int c)
{
  if (O[c] != -1)
  {
    return getPrevious(O[c]);
  }
  
  return c;
}

/*************************************************************/
/* Display routines                                          */
/*************************************************************/

void highLightCurrentVertexGate(int clear)
{
  int clr = backgroundClr;
  int sz = 3;
  if (clear == 0)
  {
    clr = backgroundClr;
  }
  else
  {
    clr = green;  
  }  

  // Highlight current vertex and gate!
  int n = getNext(gC);
  int p = getPrevious(gC);
  stroke(clr);
  fill(clr);
  
  pushMatrix();
  translate(G[V[gC]][0],G[V[gC]][1],G[V[gC]][2]);
  sphere(sz);
  popMatrix();
  
  line(G[V[p]][0],G[V[p]][1],G[V[p]][2],G[V[n]][0],G[V[n]][1],G[V[n]][2]);
  
  // Lets also put a tiny green dot on the interior of the triangle!
  float nx = (G[V[p]][0] + G[V[n]][0])/2.0;
  float ny = (G[V[p]][1] + G[V[n]][1])/2.0;
  float nz = (G[V[p]][2] + G[V[n]][2])/2.0;
  
  float fx = (((nx + G[V[gC]][0])/2.0+G[V[gC]][0])/2.0+G[V[gC]][0])/2;
  float fy = (((ny + G[V[gC]][1])/2.0+G[V[gC]][1])/2.0+G[V[gC]][1])/2;
  float fz = (((nz + G[V[gC]][2])/2.0+G[V[gC]][2])/2.0+G[V[gC]][2])/2;
  
  pushMatrix();
  translate(fx,fy,fz);
  sphere(sz);
  popMatrix();
}

void drawTriangleMesh(int clear)
{
  int clr = backgroundClr;
  int sphereColor = backgroundClr;
  if (clear == 0)
  {
    clr = backgroundClr;
    sphereColor = backgroundClr;
  }
  else
  {
    clr = black;  
    sphereColor = red;
  }  
  
  stroke(clr);
  
  // Plot the edges
  if (fillNeeded == true)
  {
    fill(grey);
  }
  else
  {
    noFill();
  }
  stroke(black);
  beginShape(TRIANGLES);
  for (int i=0;i<gVLast;i++)
  {
    int n = getNext(i);
    strokeWeight(1);  
    vertex(G[V[i]][0],G[V[i]][1],G[V[i]][2]);
  }
  endShape();
  noFill();
  
  // Plot each vertex!
  for (int i=0;i<gGLast;i++)
  {
    stroke(sphereColor);

    pushMatrix();
    translate(G[i][0],G[i][1],G[i][2]);
    sphere(2);
    popMatrix();
    
    stroke(clr);
  }
}

void drawMenu()
{
  // Draw the menu
  stroke(black);
  background(white);
}

void setup()
{
  size(600,600,P3D);  
  ortho(-300,+300,-300,300,-300,300);

  drawMenu();
    
  // Set pen color to black
  stroke(black);

  // Restore pen color to black
  stroke(black);
  
  // Initial triangle to be displayed - modify these
  // The points
  G[0][0] = 50; G[0][1] = 50; G[0][2] = 0; gGLast++;
  G[1][0] = 100; G[1][1] = 150; G[1][2] = 0; gGLast++;
  G[2][0] = 150; G[2][1] = 50; G[2][2] = 0; gGLast++;
  // The edges
  V[0] = 0; V[1] = 1; V[2] = 2; gVLast=3;
  O[0] = -1; O[1] = -1; O[2] = -1; gOLast=3;
  // Current vertex
  gC = 0;
  
  drawAtom(1);
}

void drawAxis(int clr)
{
  color drawClr = grey; 
  color sphereClrX = grey;
  color sphereClrY = grey;
  color sphereClrZ = grey;
  if (clr == 0){ drawClr = backgroundClr; sphereClrX = backgroundClr; sphereClrY = backgroundClr; sphereClrZ = backgroundClr;}
  else { drawClr = grey; sphereClrX = red; sphereClrY = blue; sphereClrZ = green;}
  
  stroke(sphereClrX);
  
  pushMatrix();
  translate(-300,0,0);
  sphere(2);
  popMatrix();

  stroke(sphereClrY);
  
  pushMatrix();
  translate(0,-300,0);
  sphere(2);
  popMatrix();

  stroke(sphereClrZ);
  
  pushMatrix();
  translate(0,0,-300);
  sphere(2);
  popMatrix();

  stroke(drawClr);
  line(-300,0,0,300,0,0);
  line(0,-300,0,0,300,0);
  line(0,0,-300,0,0,300);
}

// Main routine responsible for drawing everything on the screen!
void drawAtom(int clr)
{
  drawMenu();
    
  pushMatrix();

  translate(300,300,0);

  rotateX(radians(gAngleX));
  rotateY(radians(gAngleY));
  rotateZ(radians(gAngleZ));

  if (axisNeeded == true)
  {
    drawAxis(clr);
  }
  drawTriangleMesh(clr);
  highLightCurrentVertexGate(clr);
  popMatrix();
}

void draw()
{
  if (fillNeeded == true)
  {
    lights();
  }
}

/***********************************************************************/
/* Merge routines                                                      */
/***********************************************************************/

// This function is used for the Merge facility
int getNearestVertex(int c)
{
  float min = 640000; // Some huge distance!
  float d= 0;
  int di=-1;
  for (int i=0;i<gGLast;i++)
  {
    if (i != c)
    {
      d = dist(G[c][0],G[c][1],G[c][2],G[i][0],G[i][1],G[i][2]);
      if (min > d) // This guy is lesser so update minimum distance!
      {
        min = d;
        di = i; // This is our closest guy so far!
      }
    }
  }
  return di;
}

void merge()
{
  int gi = getNearestVertex(V[gC]);
  int ngC = getNext(gC); 
  int pgC = getPrevious(gC);
          
  V[gC] = gi; // Merged the 2 vertices!
  gGLast--; // Remove that vertex! Not wanted!

  // Now put the opposite!
          
  // search in all the triangles!
  for(int i=0;i<gVLast/3;i++)
  {
            if (V[i*3]==gi) // Is our first vertex the new vertex?
            {
              // There are 3 cases depending on which one matches ngC
              if (V[i*3+1] == V[ngC] || V[i*3+2] == V[ngC]) // Is there a match with ngC?
              {
                //Ok! we found the triangle!
                // Common vertices are ngC and gi
                if (V[i*3+1] == V[ngC])
                {
                  O[pgC] = V[i*3+2];
                  O[V[i*3+2]] = pgC;
                }
                else
                {
                  O[pgC] = i*3+1;
                  O[i*3+1] = pgC;
                }
                break; // Dont want to mess later!
              }
              else if(V[i*3+1] == V[pgC] || V[i*3+2] == V[pgC])
              {
                //Ok! we found the triangle!
                // Common vertices are ngC and gi
                if (V[i*3+1] == V[pgC])
                {
                  O[pgC] = i*3+2;
                  O[i*3+2] = ngC;
                }
                else
                {
                  O[pgC] = i*3+1;
                  O[i*3+1] = ngC;
                }
              }
              break;
            }
            if (V[i*3+1]==gi) // Is our 2nd vertex the new vertex?
            {
              // There are 3 cases depending on which one matches ngC
              if (V[i*3] == V[ngC] || V[i*3+2] == V[ngC]) // Is there a match with ngC?
              {
                //Ok! we found the triangle!
                // Common vertices are ngC and gi
                if (V[i*3] == V[ngC])
                {
                  O[pgC] = i*3+2;
                  O[i*3+2] = pgC;
                }
                else
                {
                  O[pgC] = i*3;
                  O[i*3] = pgC;
                }
                break;
              }
              else if(V[i*3] == V[pgC] || V[i*3+2] == V[pgC])
              {
                //Ok! we found the triangle!
                // Common vertices are ngC and gi
                if (V[i*3] == V[pgC])
                {
                  O[pgC] = i*3+2;
                  O[i*3+2] = ngC;
                }
                else
                {
                  O[pgC] = i*3;
                  O[i*3] = ngC;
                }
                break;
              }
            }
            if (V[i*3+2]==gi) // Is our 2nd vertex the new vertex?
            {
              // There are 3 cases depending on which one matches ngC
              if (V[i*3] == V[ngC] || V[i*3+1] == V[ngC]) // Is there a match with ngC?
              {
                //Ok! we found the triangle!
                // Common vertices are ngC and gi
                if (V[i*3] == V[ngC])
                {
                  O[pgC] = i*3+1;
                  O[i*3+1] = pgC;
                }
                else
                {
                  O[pgC] = i*3;
                  O[i*3] = pgC;
                }
                break;
              }
              else if(V[i*3] == V[pgC] || V[i*3+1] == V[pgC])
              {
                //Ok! we found the triangle!
                // Common vertices are ngC and gi
                if (V[i*3] == V[pgC])
                {
                  O[pgC] = i*3+1;
                  O[i*3+1] = ngC;
                }
                else
                {
                  O[pgC] = i*3;
                  O[i*3] = ngC;
                }
                break;
              }
            }
   }
}

/**********************************************/
/* Input routines                             */
/**********************************************/
void keyPressed()
{
    int p = getPrevious(gC);
    int n = getNext(gC);
    int c = V[gC];

    // Calculate the local X axis
    double dx = G[V[n]][0] - G[V[p]][0];
    double dy = G[V[n]][1] - G[V[p]][1];
    double dz = G[V[n]][2] - G[V[p]][2];
    double cm = sqrt((float)(dx*dx + dy*dy + dz*dz));          
    // -- Final X axis
    double xx = dx/cm;
    double xy = dy/cm;
    double xz = dz/cm;
    
    // Calculate the local Z axis
    double ux,uy,uz,vx,vy,vz,nz;
    ux = G[V[p]][0] - G[c][0];
    uy = G[V[p]][1] - G[c][1];
    uz = G[V[p]][2] - G[c][2];
    nz = sqrt((float)(ux*ux+uy*uy+uz*uz));
    if (nz==0) nz=1;
    ux = ux/nz;
    uy = uy/nz;
    uz = uz/nz;
    vx = G[V[n]][0] - G[c][0];
    vy = G[V[n]][1] - G[c][1];
    vz = G[V[n]][2] - G[c][2];
    nz = sqrt((float)(vx*vx+vy*vy+vz*vz));
    if (nz==0) nz=1;
    vx = vx/nz;
    vy = vy/nz;
    vz = vz/nz;
    // -- Final Z axis
    double zx = uy*vz-uz*vy;
    double zy = uz*vx-ux*vz;
    double zz = ux*vy-uy*vx;
          
    // Calculate the local Y axis
    double yx = xy*zz - zy*xz;
    double yy = xz*zx - zz*xx;
    double yz = xx*zy - zx-xy;
    nz = sqrt((float)(yx*yx+yy*yy+yz*yz));
    if (nz==0) nz = 1;
    // -- Final Y axis
    yx = yx/nz;
    yy = yy/nz;
    yz = yz/nz;
    
    if (cm == 0) cm = 1;

    drawAtom(0);
  
    if (key>='A' && key<='Z' || key>='a' && key<='z')
    {
      switch (key)
      {
        // Create a new triangle!
        case 'C':
          if (O[gC] == -1) // Make sure there is no opposite vertex already!
          {
            // Set the new vertex by Parallelogram prediction!
            G[gGLast][0] = G[V[n]][0]+G[V[p]][0]-G[V[gC]][0];
            G[gGLast][1] = G[V[n]][1]+G[V[p]][1]-G[V[gC]][1];
            G[gGLast++][2] = G[V[n]][2]+G[V[p]][2]-G[V[gC]][2];
            // Modify the incidence table
            V[gVLast++] = V[n];
            V[gVLast++] = gGLast-1;
            V[gVLast++] = V[p];
            // Modify the opposite table 
            O[gOLast++] = -1;
            O[gOLast++] = gC;
            O[gOLast++] = -1;
            O[gC] = gVLast-2; // Opposite of the current vertex is our new vertex which is gVLast-2
          }  
          break;
        
        // Jump to the previous vertex
        case 'P':
          gC = getPrevious(gC);
          break;

        // Jump to the previous vertex
        case 'N':
          gC = getNext(gC);
          break;

        // Jump to the opposite vertex
        case 'O':
          if (O[gC] != -1)
          {
            gC = O[gC];
          }
          break;
          
        // Jump to the right vertex
        case 'R':
          gC = getRight(gC);
          break;

        // Jump to the left vertex
        case 'L':
          gC = getLeft(gC);
          break;
          
        // Move vertex to the left
        case 'A':
          G[V[gC]][0] = G[V[gC]][0]-gUnit;
          break;

        // Move vertex to the right
        case 'D':
          G[V[gC]][0] = G[V[gC]][0]+gUnit;
          break;

        // Move vertex to the left
        case 'W':
          G[V[gC]][1] = G[V[gC]][1]-gUnit;
          break;

        // Move vertex to the right
        case 'S':
          G[V[gC]][1] = G[V[gC]][1]+gUnit;
          break;

          // Move vertex to the left
        case 'E':
          G[V[gC]][2] = G[V[gC]][2]-gUnit;
          break;

        // Move vertex to the right
        case 'Z':
          G[V[gC]][2] = G[V[gC]][2]+gUnit;
          break;
  
        // Rotate camera!
        case 'T':
          gAngleX = gAngleX + 5;
          break;

        case 'G':
          gAngleX = gAngleX - 5;
          break;
          
        case 'Y':
          gAngleY = gAngleY + 5;
          break;

        case 'H':
          gAngleY = gAngleY - 5;
          break;

        case 'U':
          gAngleZ = gAngleZ + 5;
          break;

        case 'J':
          gAngleZ = gAngleZ - 5;
          break; 
          
        case 'M':
          // Merge
          merge();
          break;
          
        case'X':
          //rotate current vertex over the gate
          fillNeeded = !fillNeeded;
          break;

        case 'V':
          axisNeeded = !axisNeeded;
          break;                    
        
        case 'a':
          // Move along the gate
          G[c][0] -= gUnit*xx;
          G[c][1] -= gUnit*xy;
          G[c][2] -= gUnit*xz;
          
          break; 

        case 'd':
          // Move along the gate
          G[c][0] += gUnit*xx;
          G[c][1] += gUnit*xy;
          G[c][2] += gUnit*xz;
          
          break; 

        case 'e':
          // Move in the perpendicular plane
          G[c][0] += gUnit*(zx);
          G[c][1] += gUnit*(zy);
          G[c][2] += gUnit*(zz);
          break;

       case 'z':
          // Move in the perpendicular plane
          G[c][0] -= gUnit*(zx);
          G[c][1] -= gUnit*(zy);
          G[c][2] -= gUnit*(zz);                   
          break; 

        case 's':
          G[c][0] += gUnit*(yx);
          G[c][1] += gUnit*(yy);
          G[c][2] += gUnit*(yz);
          break;

        case 'w':
          G[c][0] -= gUnit*(yx);
          G[c][1] -= gUnit*(yy);
          G[c][2] -= gUnit*(yz);
          break;
          
        case 'u': // Save(Unload) the contents in a file 
          unloadAll();
          break;
          
        case 'l': // Load from the saved file
          loadAll();
          break;
      
       };      
    }
    drawAtom(1);
}