// 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.*;
import javax.swing.JOptionPane;
// VERTICES
int w=6;                                    // size of initial Tmesh-grid made in setup
int nv = w*w, maxnv = 255;;               // 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 iMesh = 0;                        // toggle between mesh files to load

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

int iNumViews    = 200;              //Number of views to use to determine edge importance
int iPercentToShow = 5;              //Percentage of Edges to display
int iNumEdgesToShow = 0;             //Number of important edges needed to show
int iTotalNumEdges = 0;              //Total number of edges
int iMaxSilEdgeCnt = 0;              //Maximum value of edge that is seen most as a silhouette

vec labelD=new vec(-10,-10, 2);      // offset vector for labels

boolean bShowNormals =false;
boolean bShowLabels = false;
boolean bShowVertices = false;
boolean bJumps = true;
boolean bShowSilhouette = true;
boolean bShowImportant = false;
boolean bFillTriangles = true;
boolean bVisibleSilhouettes = true;

// CAMERA
pt pOrigin=new pt(0,0,0);
pt pEye=new pt(0,0,600);  // point from where you picked
cam C  = new cam(pEye, pOrigin);
cam C1 = new cam(pEye, pOrigin);
cam C2 = new cam(pEye, pOrigin);

pt pMark = new pt(0,0,0);  // point you pick on mesh

// 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[] Edge = new int [3*maxnt];        // Edge table (Edge made by corner and opposite corner indices)
int c = 0;                             // corner 
    
// GUI
int bi=-1;                             // index of selected vertex, -1 if none selected

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);};
    
  loadMesh();
  computeBox();     
  C.F.setToPoint(Cbox);       //Set Focus point
  C.pullE();                  //Move Eye towards Focus point
  orientTrianglesEdges();
  computeO();
  computeImportantEdges();
  } ;

void draw() { 
  background(255); sphereDetail(4); lights();
  translate(float(width)/2, float(height)/2, 0.0);     // center view wrt window
  
  if ((!keyPressed)&&(mousePressed)) {C.pan(); C.pullE(); };    //Move camera by pressing down mouse button
  C1.track(C); C2.track(C1);  C2.apply();                       //Smoothly transition camera to desired locatoin                                   

  noStroke();
  if(! bShowImportant && bFillTriangles) {
    fill(245, 238, 80, 40); for(int i=0; i<nt; i++) { shade(i); } }                          //Draw shaded triangles
      
  if(bShowVertices) {fill(green); for (int i=0; i<nc; i++) {if(i!=bi){G[V[i]].show(5);} };}  //Draw vertices
  if(bShowLabels){ fill(black); for (int i=0; i<nv; i++) { G[i].label(str(i),labelD); } }    //Draw vertex number for each vertex
  if(bShowNormals) {stroke(blue); showTriNormals();};                                       //Draw triangle Normals  noStroke(); fill(lightblue); shade(t(c)); fill(blue); showCorner(c);                                 //Shade selected triangle and corner blue  
  if(bi!= -1) {G[bi].setToMouse(); stroke(magenta);G[bi].show(5); }                         //Snap selected vertex to mouse position during dragging

  drawAllEdges();                              
};


void drawAllEdges() {                       // works only if triangles are properly oriented
  if( bShowImportant ) { drawImportantEdges(); }
  else {
    for(int i=0; i<3*nt; i++) {                                    //Check each corner
      if(i < o(i)){                                                //Check edge only once for a corner and its opposite
          if( bShowSilhouette && silhouetteEdge(C2.E, i) ) {strokeWeight(4);stroke(magenta);} //Color silhouette edge magenta
          else{strokeWeight(1);stroke(black);}                       //Edge is not silhouette, color black
          drawEdge(i); //Draw the edge
      }
    }
  }
  strokeWeight(1);
};


void drawImportantEdges() {
  int iNumEdgesShown = 0;
  int iSilValue = iMaxSilEdgeCnt;
  strokeWeight(4); stroke(blue); 
  while(iNumEdgesShown < iNumEdgesToShow) {              //See if more edges need to be shown
    for(int i=0; i<3*nt; i++) {                          //Check each corner
      if( (i < o(i)) && (Edge[i] == iSilValue) ) {       //Check edge only once for a corner and its opposite
         iNumEdgesShown++; drawEdge(i);}                 //Draw only important edges
      if(iNumEdgesShown >= iNumEdgesToShow) { i=3*nt; }  //Exit if found enough edges
    }
    iSilValue--;                                         //Search for lower silhouette hit values
  }
};

boolean silhouetteEdge (pt pViewPoint, int c) {
  boolean bcCW, boCW;
  int o = o(c);     //opposite of corner c
  bcCW = pViewPoint.cw(G[V[c]], G[V[n(c)]], G[V[p(c)]]);     // Determines if the triangle containing corner c is 
                                                             // clockwise from the perspective of the ViewPoint
  boCW = pViewPoint.cw(G[V[o]], G[V[n(o)]], G[V[p(o)]]);     // Determines if the triangle containing corner o is
                                                             // clockwise from the perspective of the ViewPoint
  if(bcCW == boCW){return false;}     //if the orientations are the same, then it is not a silhouette edge

   //Silhouette edge found, now see if it is visible
  if( bVisibleSilhouettes ) {  // Can ignore "only visible" silhouette option by pressing 'v'
    pt pMidEdge = new pt(0,0,0);  pMidEdge = midPt(g(p(c)), g(n(c)));   //Point in middle of silhouette edge
    vec vViewToMid = new vec(0,0,0);  vViewToMid = pViewPoint.vecTo(pMidEdge);
    float fNorm = vViewToMid.norm();                                    //Distance from middle of viewpoint to silhouette

    for(int j=0; j<nt; j++) {                                                            //For each triangle
      if( (j != t(c)) && (j != t(o)) ){   
        if(rayHitTri(pViewPoint, pMidEdge, G[V[3*j]], G[V[3*j+1]], G[V[3*j+2]]) == -1) {  //See if triangle is hit and is cw     
          float fDist = rayDistToTriPt(pViewPoint, pMidEdge, G[V[3*j]], G[V[3*j+1]], G[V[3*j+2]]);  //Determine the distance from viewpoint to the triangle
          if( fNorm > fDist ) { return false;}  //If triangle is closer that the edges midpoint (behind) return false
        }
      } 
    }
           
  }
  return true;  //Visible silhouette edge is found
}

int rayHitTri(pt pViewPoint, pt pMidEdge, pt A, pt B, pt C) { 
   boolean s  = pViewPoint.cw(A,B,C);  
   boolean sA = pViewPoint.cw(pMidEdge,B,C); 
   boolean sB = pViewPoint.cw(A,pMidEdge,C); 
   boolean sC = pViewPoint.cw(A,B,pMidEdge);
   
   if((s==sA) && (s==sB) && (s==sC)) {   //Triangle is hit if all triangles forming tetrahedron are the same orientation
     if(s) {return 1;} else {return -1;}}  //send back info as to whether it is cw or ccw
   else {return 0;}
}


float rayDistToTriPt(pt E, pt P, pt A, pt B, pt C) {
  vec EA = new vec(0,0,0);    EA = E.vecTo(A);
  vec AB = new vec(0,0,0);    AB = A.vecTo(B);
  vec AC = new vec(0,0,0);    AC = A.vecTo(C);
  vec EP = new vec(0,0,0);    EP = E.vecTo(P);
  vec EH = new vec(0,0,0);
  pt  H  = E.make(); 
  float fDistPH  =  mixed(AB,AC,EA) / mixed(AB,AC,EP);  //Determines distance to triangle
  
  H.addScaledVec(fDistPH,EP);
  EH = E.vecTo(H);
  
  return EH.norm();
}

void computeImportantEdges() {
  iTotalNumEdges = 0;
  for (int i=0; i<3*nt; i++) {
    Edge[i]=0;                              //Reset Edge's importance
    if( i < o(i) ) { iTotalNumEdges++; }    //Check edge only once for a corner and its opposite
  }
    
  iNumEdgesToShow = (iPercentToShow*iTotalNumEdges)/100;
  float fRadius = 2*Rbox;
  pt pViewArray = new pt(0,0,0);
  iMaxSilEdgeCnt = 0;
  
  for(int iView=0; iView<iNumViews; iView++)
  {
    //Create random camera location to determine silhouette edges
    float fLong = random(-fRadius, fRadius);
    float Psi = random(0,2*PI);
    pViewArray.x = Cbox.x + fRadius*(cos(fLong)*sin(Psi));
    pViewArray.y = Cbox.y + fRadius*(sin(fLong)*sin(Psi));
    pViewArray.z = Cbox.z + fRadius*(cos(Psi));
  
    for(int i=0; i<3*nt; i++) {                       //Check each corner
      if( i < o(i) ) {                                //Check edge only once for a corner and its opposite
        if( silhouetteEdge( pViewArray, i) ) {        //Check if silhouette edge from viewpoint
          Edge[i]++;                                  //Add to wieght of Edge's importance
          if(Edge[i] > iMaxSilEdgeCnt) {iMaxSilEdgeCnt = Edge[i];}   //Keep track of the highest importance
        }
      }
    }
  }
    
}

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


//**********************************
//***      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); };

int findCorner (int v) {int c = 0; while(v != v(c)) {c++;} return c; }  //Find a corner that is attached to the specfied vertex

//**********************************
//***      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=='S') {saveMesh(); };  
  if (key=='G') {iMesh++; if(iMesh>2){iMesh=0;} c=0; 
                 if(iMesh==0){println("Load mesh.vts");} else {println("Load mesh"+iMesh+".vts"); }
                 loadMesh();  computeBox(); C.F.setToPoint(Cbox); C.pullE(); 
                 orientTrianglesEdges(); computeO(); computeTriNormals();   computeImportantEdges(); 
                 };  
                 
  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)); opposite(); jump();};  
  if (key=='l') {println("l("+c+")="+l(c)); left(); jump();}
  if (key=='r') {println("r("+c+")="+r(c));  right(); jump();}

  if (key=='N') {bShowNormals=!bShowNormals;  if (bShowNormals) {computeTriNormals(); } }  
  if (key=='L') {bShowLabels=!bShowLabels; }                                                  
  if (key=='J') {bJumps=!bJumps; };  
  if (key=='V') {bShowVertices=!bShowVertices; }
  if (key=='f') {bFillTriangles =! bFillTriangles;}; 
    
  if (key=='v') {bVisibleSilhouettes=!bVisibleSilhouettes; }
    
  if (key=='z') {C.pose(); C.zoom(); C.pullE(); };
  if (key=='O') {C.setcam(pEye, pOrigin); C.F.setToPoint(Cbox); C.pullE();}               //Revert view close to original
  
  if (key=='s') {bShowSilhouette=!bShowSilhouette; }
  if (key=='I') {bShowImportant=!bShowImportant; }
  
  if (keyCode==DOWN) {   //decrease the percentage of shown edges
     iPercentToShow -= 5;
    if(iPercentToShow<0 ){ iPercentToShow = 0; }
    println("Important Edges to Show: "+iPercentToShow+"%");
    iNumEdgesToShow = (iPercentToShow*iTotalNumEdges)/100; } 
    
  if (keyCode==UP) {   //increase the percentage of shown edges
    iPercentToShow += 5;
    if(iPercentToShow>100){ iPercentToShow = 100; }
    println("Important Edges to Show: "+iPercentToShow+"%");
    iNumEdgesToShow = (iPercentToShow*iTotalNumEdges)/100; } 
  
  if (key=='%') { 
    String strPercent = JOptionPane.showInputDialog(null, "Enter Percentage of Most Important Edges to Display:");   //Show dialog to enter %
    if(strPercent != null) {                  
      int iPrevious = iPercentToShow;
      iPercentToShow = Integer.parseInt(strPercent);
      if(iPercentToShow>100 || iPercentToShow<0 ){ iPercentToShow = iPrevious; }
      println("Important Edges to Show: "+iPercentToShow+"%");
      iNumEdgesToShow = (iPercentToShow*iTotalNumEdges)/100;
    }
  }
}
 
void left()     {if(l(c)!=-1) {c=l(c);}}          //Find left corner if it exists
void right()    {if(r(c)!=-1) {c=r(c);}}          //Find right corner if it exists
void opposite() {if(o(c)!=-1) {c=o(c);}}          //Find opposite corner if it exists
void jump()     {if (bJumps) {C.jump(c);}}        //Jump to camera to corner if specified to jump 
 
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("bunny.vts");}
 else {ss = loadStrings("horse.vts");}
 
  String subpts;
  int s=0;
  int comma1, comma2;
  float x, y, z;
  int a, b, c;

    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]);
  nc = 3*nt;
  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() {      
  C.anchor(); C.pose(); //Save coordinates for the mouse, Eye, and Focus and determine new I, J, K axis and Upvector                                  
};
  
void mouseReleased() {
  C.anchor(); C.pose();  //Save coordinates for the mouse, Eye, and Focus and determine new I, J, K axis and Upvector
  bi= -1; 
};



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

boolean rayHitTriangle(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
  boolean bP, bA, bB, bC;
  bP = PA.cw(PA, PB, PC);
  bA = T.cw( T, PB, PC);
  bB = PA.cw(PA,  T, PC);
  bC = PA.cw(PA, PB,  T);
  if( (bP == bA) && (bA == bB) && (bB == bC) ) { return true; }
    
  return false;
}

/*
boolean silhouetteEdge (pt pViewPoint, int c) {
  boolean bcCW, boCW;
  int o = o(c);     //opposite of corner c
  bcCW = pViewPoint.cw(G[V[c]], G[V[n(c)]], G[V[p(c)]]);     // Determines if the triangle containing corner c is 
                                                             // clockwise from the perspective of the ViewPoint
  boCW = pViewPoint.cw(G[V[o]], G[V[n(o)]], G[V[p(o)]]);     // Determines if the triangle containing corner o is
                                                             // clockwise from the perspective of the ViewPoint
  if(bcCW == boCW){return false;}     //if the orientations are the same, then it is not a silhouette edge
  else { return true;}                //silhouette edge found
}
*/


/*   
void hitTriangle() {
   float fSmallestDepth=10000000;
   boolean bHit=false;
   for (int t=0; t<nt; t++) {                                                //For each triangle
     if (rayHitTri(G[V[3*t]], G[V[3*t+1]], G[V[3*t+2]])) {                   //If the ray from pEye to pMark hits the triangle
       bHit=true;                                                            //Hit a triangle!  Now see if it is the top-most triangle
       float fDepth = rayDistTriPlane(G[V[3*t]], G[V[3*t+1]], G[V[3*t+2]]);  //Determine the distance from pEye to the triangle
       if ((fDepth>0)&&(fDepth<fSmallestDepth)) {                            //If the distance is the smallest of all triangles (top-most triangle)
         fSmallestDepth=fDepth; c=3*t;};                                     //Store smallest distance and set the corner to this triangle
       };
     };
   if (bHit) {                                               //We have hit a triangle
     pt ptHit = pEye.make();                                 //Hit point is set to the Eye point coordinates
     ptHit.addScaledVec(fSmallestDepth,pEye.vecTo(pMark));   //Use depth and the vector from Eye to Mark to determine Hit point coordinates
     pMark.setToPoint(ptHit);                                //Mark point is set to the Hit point coordinates
     float fDist=pMark.disTo(g(c));                          //Determine the distance from the Mark point to the corner c
     int iNewC = c;                                          //Save current corner (default corner)
     if (pMark.disTo(g(n(c)))<fDist) {                       //Next corner is closest
       iNewC=n(c); fDist = pMark.disTo(g(iNewC));}           //Save this distance to compare with previous corner
     if (pMark.disTo(g(p(c)))<fDist) {iNewC=p(c);};          //Previous corner is closest
     c = iNewC;                                              //Set corner c
     };
   }
   
boolean rayHitTri(pt A, pt B, pt C) { 
   boolean s  = pEye.cw(A,B,C);  
   boolean sA = pEye.cw(pMark,B,C); 
   boolean sB = pEye.cw(A,pMark,C); 
   boolean sC = pEye.cw(A,B,pMark);
   
   return( (s==sA) && (s==sB) && (s==sC) );  //Triangle is hit if all triangles forming tetrahedron are the same orientation
}


float rayDistTriPlane(pt A, pt B, pt C) {
  vec AE = new vec(0,0,0);    AE = A.vecTo(pEye);
  vec AB = new vec(0,0,0);    AB = A.vecTo(B);
  vec AC = new vec(0,0,0);    AC = A.vecTo(C);
  vec EM = new vec(0,0,0);    EM = pEye.vecTo(pMark);
    
  return (- mixed(AE,AC,AB) / mixed(EM,AC,AB));  //Determines distance to triangle
}
*/