import processing.opengl.*;


int numPoints=10; //number of points in the container
int currentSelection=0;
// simple arrays to store the properties of the points
PVector[] points=new PVector[numPoints];// 
PVector[] vels=new PVector[numPoints];

HE_Mesh container;
// coordinates of the containervertices
float[][] containerVertices;
// simple face array for the container. Each subarray contains the indices of the vertices.
int[][] containerFaces;

float bufferMouseX, bufferMouseY;

//half-edge mesh, one for each voronoi cell
HE_Mesh[] voronoiCells=new HE_Mesh[numPoints];
PVector[] centers=new PVector[numPoints];
//representation of a plane, used to cut the mesh
Plane P=new Plane(new PVector(0,0,0),new PVector(0,1,0));

//size of box
int S=500;

void setup(){
  size(800,800,OPENGL);
  background(255);
  //smooth();
  hint(ENABLE_OPENGL_4X_SMOOTH);

  initializePoints();
  buildContainer();
  buildVoronoi();
}

void draw(){
  background(255);
  lights();
  drawVoronoiBox();
  updatePoints();
  buildVoronoi();
}

void initializePoints(){

  for (int i=0;i<numPoints;i++){
    points[i]=new PVector(random(-S,S),random(-S,S),random(-S,S));
    vels[i]=new PVector(random(-1,1),random(-1,1),random(-1,1));
    vels[i].normalize();
    vels[i].mult(2);
  } 
}


// container = cube, 8 vertices, 6 faces of 4 vertices each
void buildContainer(){
  float[][] tmpv={
    {
      S,S,S    }
    ,
    {
      -S,S,S    }
    ,
    {
      -S,S,-S    }
    ,
    {
      S,S,-S    }
    ,
    {
      S,-S,S    }
    ,
    {
      -S,-S,S    }
    ,
    {
      -S,-S,-S    }
    ,
    {
      S,-S,-S    }
  };
  containerVertices=tmpv;
  //  vertices need to be in a consistent order (clockwise, or counterclockwise around the face)
  int[][] tmpf={
    {
      0,1,2,3    }
    ,
    {
      1,0,4,5    }
    ,
    {
      0,3,7,4    }
    ,
    {
      2,1,5,6    }
    ,
    {
      5,4,7,6    }
    ,
    {
      3,2,6,7    }
  };
  containerFaces=tmpf;  
  container=new HE_Mesh();
  container.buildMesh(containerVertices, containerFaces);
  container.roundEdges(100);
  container.roundCorners(40);
}


// A hack-n-slash approach to voronoi, literally. The individual cells are created by iteratively splitting
// the container mesh by the bisector planes of all other points. (Bisector plane = plane perpendicular to line
// between two points, positioned halfway between the points)

void buildVoronoi(){
  for (int i=0;i<numPoints;i++){
    // each Voronoi cell starts as the entire container
    voronoiCells[i]=container.get();
  }
  for (int i=0;i<numPoints;i++){
    for(int j=0;j<numPoints;j++){
      if(i!=j){
        PVector N=PVector.sub(points[j],points[i]); // plane normal=normalized vector pinting from point i to point j
        N.normalize();
        PVector O=PVector.add(points[j],points[i]); // plane origin=point halfway between point i and point j
        O.mult(0.5f);
        P=new Plane(O,N);
        voronoiCells[i].splitMesh(P,points[i]);
      }
    }   


  } 

  for (int i=0;i<numPoints;i++){   
    centers[i]=new PVector();
    for(int j=0;j<voronoiCells[i].vertices.size();j++){
      HE_Vertex v=(HE_Vertex)voronoiCells[i].vertices.get(j);   
      centers[i].add(v);
    } 
    centers[i].div(voronoiCells[i].vertices.size());
  }
}

void drawVoronoiBox(){
  translate(width/2,height/2,-800);
  bufferMouseX=0.95f*bufferMouseX+0.05f*mouseX;
  bufferMouseY=0.95f*bufferMouseY+0.05f*mouseY;
  rotateY(bufferMouseX/(float)width*TWO_PI);
  rotateX(bufferMouseY/(float)height*TWO_PI);
  

  for (int i=0;i<numPoints;i++){
    //pushMatrix();
    //translate(0.2*centers[i].x,0.2*centers[i].y,0.2*centers[i].z);
    noFill();
    stroke(0,150);
    strokeWeight(2);
    voronoiCells[i].drawEdges();
voronoiCells[i].drawCurves();
    //popMatrix();
  }
}

void updatePoints(){
  for (int i=0;i<numPoints;i++){
    points[i].add(vels[i]);
    if(points[i].x<-S){ 
      points[i].x=-2*S-points[i].x;
      vels[i].x*=-1;
    }
    if(points[i].y<-S){ 
      points[i].y=-2*S-points[i].y;
      vels[i].y*=-1;
    }
    if(points[i].z<-S){ 
      points[i].z=-2*S-points[i].z;
      vels[i].z*=-1;
    }
    if(points[i].x>S){ 
      points[i].x=2*S-points[i].x;
      vels[i].x*=-1;
    }
    if(points[i].y>S){ 
      points[i].y=2*S-points[i].y;
      vels[i].y*=-1;
    }
    if(points[i].z>S){ 
      points[i].z=2*S-points[i].z;
      vels[i].z*=-1;
    }
  }  
}


void mouseClicked(){
  initializePoints();
  buildVoronoi();
}
void keyPressed(){
  currentSelection++;
  if(currentSelection==numPoints) currentSelection=0;

}