// CS3451 Computer Graphics
// P3 - Triangle Mesh
// Catherine Herrington
// http://www-static.cc.gatech.edu/grads/c/catyarr/Tmesh
// Modified on June 15, 2006


// Triangle mesh viewer with support for corner table
// Written by Jarek Rossignac June 2006
// OpenGL version

//import processing.opengl.*;
// VERTICES
int w=6;                                    // size of initial Tmesh-grid made in setup
int nv = w*w, maxnv = 100;;               // current and max number of vertices
int nt = 2*(w-1)*(w-1), maxnt = maxnv*2;          // current and max number of triangles
pt[] G = new pt [maxnv];                 // geometry table (vertices)
float[][] UV = new float [maxnv][2];    // texture coordinates for the vertices
vec[] Nv = new vec [maxnv];             // vectors associated with vertices for normal or laplace
vec[] Nt = new vec [maxnt];             // vectors associated with triangles for normal 
int [] valence = new int [maxnv];     // valence (count of incident triangles) for the vertices
pt Cbox = new pt(0,0,0);              // box center
float Rbox;                           // box radius

int[] rgb = new int [maxnt];        // color for each triangle
int iMesh = -1;                        // toggle between mesh files to load

int iNegHit  = -1; 
int iEdgeHit = 0;
int iPosHit  = 1;
int iNoHit   = 2;
int iTriHit  = 1;


// CORNERS
int nc = nt*3;                             // current number of corners
int[] V = new int [3*maxnt];              // V table (triangle/vertex indices)
int[] O = new int [3*maxnt];             // O table (opposite corner indices)
int c = 0;                             // corner 
    
// GUI
int bi=-1;                             // index of selected vertex, -1 if none selected
pt Mouse = new pt(0,0,0);             // current mouse position
float xr, yr = 0;                    // mouse coordinates relative to center of window
int px=0, py=0, dz=0, oz=0;
vec labelD=new vec(-10,-10, 2);      // offset vector for labels
boolean showNormals=false;
color grey = color(200, 200, 210), red = color(200, 10, 10), blue = color(10, 10, 200), lightblue = color(150, 150, 255),
      green = color(10, 200, 20), black = color(10, 10, 10), magenta = color(250, 50, 100), brown = color(150, 100, 50), 
      yellow = color(245, 238, 80), lightgreen = color(150, 255, 150), lightpink = color(255, 160, 160), 
      lightpurple = color(220, 150, 220); 

void setup() { size(750, 750, P3D);  // void setup() { size(750, 750, OPENGL);  
  PFont font = loadFont("Courier-14.vlw"); textFont(font, 12);
  for (int i=0; i<maxnv; i++) {G[i]=new pt(0,0,0); Nv[i]=new vec(0,0,0);};
  for (int i=0; i<maxnt; i++) {Nt[i]=new vec(0,0,0);};
  for (int i=0; i<maxnt; i++) { rgb[i]=-1; };         //Reset color for each triangle
  
  for (int i=0; i<w; i++) {for (int j=0; j<w; j++) {G[w*i+j].setTo(width*.8*j/(w-1)+width/10,height*.8*i/(w-1)+height/10,0);}}    
  for (int i=0; i<w-1; i++) {for (int j=0; j<w-1; j++) {
      V[(i*(w-1)+j)*6]=i*w+j;       V[(i*(w-1)+j)*6+2]=(i+1)*w+j;       V[(i*(w-1)+j)*6+1]=(i+1)*w+j+1;
      V[(i*(w-1)+j)*6+3]=i*w+j;     V[(i*(w-1)+j)*6+5]=(i+1)*w+j+1;     V[(i*(w-1)+j)*6+4]=i*w+j+1;    }; };
  computeBox();   
  orientTrianglesEdges();
  computeO();
  shell();
  } ;
 
void draw() { 
  background(255); sphereDetail(4); lights();
  if (bi!= -1) {G[bi].setToMouse();};      // snap selected vertex to mouse position during dragging
  float w=float(width); float h=float(height);  // window sizes
  translate(-Cbox.x, -Cbox.y, -Cbox.z);     // center view wrt window  
  translate(w/2, h/2, 0.0);     // center view wrt window  
  if (mousePressed && !keyPressed) {yr += (mouseY-py)/h;   xr += (mouseX-px)/w; };
  translate(Cbox.x, Cbox.y, Cbox.z);  rotateX(-yr/2); rotateY(xr); translate(-Cbox.x, -Cbox.y, -Cbox.z);       
  stroke(black); 
  
  for(int i=0; i<nt; i++) {  // choose color for triangles
    if(rgb[i]==0){fill(yellow);}
    else if(rgb[i]==1){fill(lightblue);}
    else if(rgb[i]==2){fill(lightgreen);}
    else if(rgb[i]==3){fill(lightpink);}
    else if(rgb[i]==4){fill(lightpurple);}
    else if(rgb[i]==5){fill(magenta);}
    else {fill(grey);}
    
    shade(i); 
  };
  fill(green); noStroke(); for (int i=0; i<nv; i++) {G[i].show(5); };
  fill(black); for (int i=0; i<nv; i++) {G[i].label(str(i),labelD); };
  if (showNormals) {stroke(blue); showTriNormals();};
  noStroke(); fill(green); shade(t(c)); fill(red); showCorner(c); 
  stroke(red); drawEdge(c);
  };
  
void shade(int i) { beginShape(TRIANGLES); G[V[3*i]].vert(); G[V[3*i+1]].vert(); G[V[3*i+2]].vert(); endShape(); };

void computeO() {                       // works only if triangles are properly oriented
  for (int i=0; i<3*nt; i++) {O[i]=-1;};
  for (int i=0; i<3*nt; i++) {for (int j=i+1; j<3*nt; j++) { 
    if( (v(n(i))==v(p(j))) && (v(p(i))==v(n(j))) ) {O[i]=j; O[j]=i;};
     };}; };
vec triNormal(int i) { return(triNormalFromPts(G[V[3*i]], G[V[3*i+1]], G[V[3*i+2]])); };
pt triCenter(int i) {return(triCenterFromPts( G[V[3*i]], G[V[3*i+1]], G[V[3*i+2]] )); };
void computeTriNormals() {for (int i=0; i<nt; i++) {Nt[i]= triNormal(i); };};
void showTriNormals() {vec N= new vec(0,0,0); for (int i=0; i<nt; i++) {N.setToVec(Nt[i]); N.makeUnit(); N.mul(20); N.show(triCenter(i)); };};
void writeTri (int i) {println("T"+i+": V = ("+V[3*i]+","+V[3*i+1]+","+V[3*i+2]+"), O = ("+O[3*i]+","+O[3*i+1]+","+O[3*i+2]+")"); };
void computeBox() {
  pt Lbox =  G[0].make();  pt Hbox =  G[0].make();
  for (int i=1; i<nv; i++) { 
    Lbox.x=min(Lbox.x,G[i].x); Lbox.y=min(Lbox.y,G[i].y); Lbox.z=min(Lbox.z,G[i].z);
    Hbox.x=max(Hbox.x,G[i].x); Hbox.y=max(Hbox.y,G[i].y); Hbox.z=max(Hbox.z,G[i].z); 
    };
  Cbox.setToPoint(midPt(Lbox,Hbox));
  Rbox=Cbox.disTo(Hbox);
  println("Box r="+Rbox); print("C="); Cbox.write(); print("L="); Lbox.write(); print("H="); Hbox.write();
  };

vec triOffNormal(int i) { 
  pt ctrPt = new pt(0,0,0); 
  pt newPt = new pt(0,0,0); 
  ctrPt = triCenterFromPts( G[V[3*i]], G[V[3*i+1]], G[V[3*i+2]]);
  newPt = midPt(ctrPt, G[V[3*i]]);
  return (triNormalFromPts(newPt, G[V[3*i+1]], G[V[3*i+2]]));
};

pt triOffCenter(int i) {
  pt ctrPt = new pt(0,0,0); 
  pt newPt = new pt(0,0,0); 
  ctrPt = triCenterFromPts( G[V[3*i]], G[V[3*i+1]], G[V[3*i+2]]);
  newPt = midPt(ctrPt, G[V[3*i]]);
  return(triCenterFromPts( newPt, G[V[3*i+1]], G[V[3*i+2]] )); 
};


void swap(int i){ //Swap orientation of triangle i
  int iTemp = V[3*i+1];  
  V[3*i+1] = V[3*i+2];
  V[3*i+2] = iTemp;}
  


void orientTrianglesEdges()
{
  for(int i=0; i<nt; i++) {  // for each triangle
    pt pCenter = triCenter(i);
    vec vNormal = triNormal(i);
    boolean bHit = false;
    int iHit;
   
    for(int j=0; j<nt; j++) {
      if(i != j){
        iHit = rayHitTriangleEdge(pCenter, vNormal, G[V[3*j]], G[V[3*j+1]], G[V[3*j+2]]);
         if (iHit == iTriHit){ bHit =! bHit; }
         if (iHit == iEdgeHit){        //Hit Edge? Try Again  
           pCenter = triOffCenter(i);  //Try with off center P
           vNormal = triOffNormal(i);  //Try with different normal
           iHit = rayHitTriangleEdge(pCenter, vNormal, G[V[3*j]], G[V[3*j+1]], G[V[3*j+2]]);
           if (iHit != iNoHit){ bHit =! bHit; }  //Assume hit if all values are the save
         }
     }
    }
      
    if(bHit) {               //Odd hits 
      rgb[i] = 5;            //Shade swaped triangle magenta
      swap(i);               //Swap orientation of triangle i
      println("Swap orientation of Triangle "+i);
    }
  }
}

int rayHitTriangleEdge(pt P, vec T, pt A, pt B, pt C) {

  vec PA = new vec(0,0,0);    PA = P.vecTo(A);
  vec PB = new vec(0,0,0);    PB = P.vecTo(B);
  vec PC = new vec(0,0,0);    PC = P.vecTo(C);
    
//This section determines if intersecting a triangle or edge
  int iP, iA, iB, iC;
  iP = PA.sign(PA, PB, PC);
  iA = T.sign( T, PB, PC);
  iB = PA.sign(PA,  T, PC);
  iC = PA.sign(PA, PB,  T);
  if( (iP == iA) && (iA == iB) && (iB == iC) ) { return abs(iP); }
    
  return iNoHit;
}

void shell()
{ 
  int iColor = 0;
  for( int i=0; i<nc; i++) {
    if(rgb[t(i)] == -1) { Visit(i, iColor); iColor++;}
  }
}

void Visit(int c, int iColor)
{ 
  rgb[t(c)] = iColor;                             //mark c.t;
  if(rgb[t(r(c))] == -1){ Visit(r(c), iColor);}   //IF NOT marked(c.r.t) THEN visit(c.r);
  if(rgb[t(l(c))] == -1){ Visit(l(c), iColor);}   //IF NOT marked(c.l.t) THEN visit(c.l); 
}

//**********************************
//***      corners
//**********************************
int t (int c) {int r=int(c/3); return(r);};
int n (int c) {int r=3*int(c/3)+(c+1)%3; return(r);};
int p (int c) {int r=3*int(c/3)+(c+2)%3; return(r);};
int v (int c) {return(V[c]);};
pt g (int c) {return(G[V[c]]);};
int o (int c) {return(O[c]);};
int l (int c) {return(o(n(c)));};
int r (int c) {return(o(p(c)));};
void showCorner(int c) {pt cPt = midPt(g(c),midPt(g(c),triCenter(t(c))));  cPt.show(3); };
void drawEdge(int c) {line(g(p(c)).x,g(p(c)).y,g(p(c)).z,g(n(c)).x,g(n(c)).y,g(n(c)).z); };

//**********************************
//***      CONTROL WITH KEYS
//**********************************
void keyPressed() {  
  if (key=='W') {println(nv+" vertices:"); for (int i=0; i<nv; i++) { print("V"+i+" = "+V[i]); G[i].write();}; 
                 println(nt+" triangles:"); for (int i=0; i<nt; i++) { writeTri(i);}; };  
  if (key=='N') {showNormals=!showNormals;  if (showNormals) {computeTriNormals(); }; };  
  if (key=='S') {saveMesh(); };  
  if (key=='G') {loadMesh();  computeBox();  orientTrianglesEdges(); computeO(); computeTriNormals(); shell();};  
  if (key=='t') {println("t("+c+")="+t(c));};  
  if (key=='n') {println("n("+c+")="+n(c)); c=n(c);};  
  if (key=='p') {println("p("+c+")="+p(c)); c=p(c);};  
  if (key=='o') {println("o("+c+")="+o(c)); if(o(c)!=-1) {c=o(c);}; };  
  if (key=='l') {println("l("+c+")="+l(c)); if(l(c)!=-1) {c=l(c);}; };
  if (key=='r') {println("r("+c+")="+r(c)); if(r(c)!=-1) {c=r(c);};}; 
  
  if (key=='m') {iMesh++; if(iMesh>2){iMesh=0;} c=0; 
                 if(iMesh==0){println("Load mesh.vts");} else {println("Load mesh"+iMesh+".vts"); }
                 loadMesh();  computeBox();  orientTrianglesEdges(); computeO(); computeTriNormals(); shell();}
  };
 
void saveMesh() {
  String [] inppts = new String [nv+1+nt+1];
  int s=0;
  inppts[s++]=str(nv);
  for (int i=0; i<nv; i++) {inppts[s++]=str(G[i].x)+","+str(G[i].y)+","+str(G[i].z);};
  inppts[s++]=str(nt);
  for (int i=0; i<nt; i++) {inppts[s++]=str(V[3*i])+","+str(V[3*i+1])+","+str(V[3*i+2]);};
  saveStrings("mesh.vts",inppts);
  println("saved");
  };

void loadMesh() {
  String [] ss;
 if(iMesh == 0) {ss = loadStrings("mesh.vts");}
 else if(iMesh ==1) {ss = loadStrings("mesh1.vts");}
 else {ss = loadStrings("mesh2.vts");}
  String subpts;
  int s=0;
  int comma1, comma2;
  float x, y, z;
  int a, b, c;
  
    for (int i=0; i<maxnt; i++) { rgb[i]=-1; };         //Reset color for each triangle

    nv = int(ss[s++]);
    println("nv="+nv);
    for(int k=0; k<nv; k++) {int i=k+s;   
      comma1=ss[i].indexOf(',');   
       x=float(ss[i].substring(0, comma1));
      String rest = ss[i].substring(comma1+1, ss[i].length());
      comma2=rest.indexOf(',');    y=float(rest.substring(0, comma2)); z=float(rest.substring(comma2+1, rest.length()));
      G[k].setTo(x,y,z);
    };
  s=nv+1;
  nt = int(ss[s]);
  println("nt="+nt);
  s++;
  for(int k=0; k<nt; k++) {int i=k+s;
      comma1=ss[i].indexOf(',');   a=int(ss[i].substring(0, comma1));  
      String rest = ss[i].substring(comma1+1, ss[i].length()); comma2=rest.indexOf(',');  
      b=int(rest.substring(0, comma2)); c=int(rest.substring(comma2+1, rest.length()));
      V[3*k]=a;  V[3*k+1]=b;  V[3*k+2]=c;
    };
  };
  
void mousePressed() {      // This only works it the model is not rotated and is on the z=o plane: or in ortho                                           
  if(keyPressed) {float bd=width; Mouse.setToMouse();    // save current mouse location
    for (int i=0; i<nv; i++) {float dd =Mouse.disTo(G[i]); if (dd<bd) {bd=dd; bi=i;  };};   // select closeest vertex, does not work if moved!!!
    if (bd>30) { bi=-1;};  }        // nothing found
  else { px=mouseX; py=mouseY;  };                                                   
  };
void mouseReleased() {if(keyPressed) {xr=0; yr=0;}; bi= -1; };



/* Not used anymore
void orientTriangles()
{
  for(int i=0; i<nt; i++) {  // for each triangle
    pt pCenter = triCenter(i);
    vec vNormal = triNormal(i);
    boolean bHit = false;
   
    for(int j=0; j<nt; j++) {
      if(i != j){
        if(rayHitTriangle(pCenter, vNormal, G[V[3*j]], G[V[3*j+1]], G[V[3*j+2]])) {
          bHit =! bHit;}}
    }
      
    if(bHit) {
      rgb[i] = 5;            //Shade swaped triangle magenta
      swap(i); }              //Swap orientation of triangle i
    else {
      rgb[i] = 0; }
  }
}

boolean rayHitTriangle(pt P, vec T, pt A, pt B, pt C) {
  boolean sP, sA, sB, sC;
  vec PA = new vec(0,0,0);    PA = P.vecTo(A);
  vec PB = new vec(0,0,0);    PB = P.vecTo(B);
  vec PC = new vec(0,0,0);    PC = P.vecTo(C);
  
  //This section determines if intersecting a triangle 
  sP = PA.cw(PA, PB, PC);
  sA = T.cw( T, PB, PC);
  sB = PA.cw(PA,  T, PC);
  sC = PA.cw(PA, PB,  T);
  if( (sP == sA) && (sA == sB) && (sB == sC) ) { return true; }  

  return false;
}
*/