import controlP5.*;


//for closth simulation
//for seaching 3D coordinnate from 2D coordinate
PGraphics bf;
float expo = 1;
float rotx, roty;
float rate = 0.01;
float c1_x = 0;
float c1_y = 0;
float c1_z = 0;

color c1, c2;
PFrame f;
secondApplet s;

ParticleSystem physics;
Particle[][] particles;
Particle currentParticle;
PVector currentParticle_2;
Particle [][] triangles;
Particle [][] quadrangles;
int [] quads;

int sizeOfCol = 25;//sizeOfCol = 30;
int sizeOfRow = 25;
float interval_col = 10.0;
float interval_row = 10.0;
float massOfParticle = 300/sizeOfCol*sizeOfRow;

public int Cloth_x = sizeOfCol;
public int Cloth_y = sizeOfRow;

public float SPRING_STRENGTH = 100;
public float SPRING_DAMPING = 0;

boolean cloth = true;
boolean startSim = true;
public boolean hunger_display = true;
boolean signOfHunger2 = false;
boolean isFaces = true;

int col = 0;
int row = 0;
int [][] displaySignOfParticles; 

public int hunger_x = 7;
public int hunger_y = 10;

int subWindow_x = int(sizeOfCol*interval_col*0.8);
int subWindow_y = int(sizeOfRow*interval_row*0.8);

ControlP5 controlP5;

public int TRANSPARENCY = 255;

int[] anchor  = new int[50];
int anchornum = 0;
int[] force = new int[50];
int forcenum = 0;
int[] skelton = new int[500];


public boolean sub_display = false;

void setup() {
  sizeOfCol = Cloth_x;
  sizeOfRow = Cloth_y;
  size(700, 700, P3D);
//  colorMode(HSB, 255);
  smooth();
  //for cloth simulation
  bf = createGraphics(width, height, P3D);
  physics = new ParticleSystem(0.0, 0.0, 9.8, 30);//(gravity,drag)
  setInitialCloth();
  //  drawSubWindow();
  setQuads();

  //  axis = new Axis(60,60,60);
  force[forcenum] = particles[sizeOfCol/2-1][sizeOfRow/2-1].id;
  forcenum = forcenum + 1;
  setController();
}

void draw() {
  background(100);
  lights();
  stroke(0);
  translate(width/2, height/1.6);
  rotateX(rotx);
  rotateY(roty);
  scale(expo);
  drawPointer();
  drawPGraphics();
  if (isFaces) drawFaces();
  if (cloth) drawCloth();
  if (startSim) physics.tick(1.5);//speed of simulation
  if (hunger_display) drawHunger(0);
  //  if(signOfHunger2) drawHunger(200);
  // axis.display();
  setQuads();
  gui();
}

void resize_cloth() {
  setSpring();
  setup();
}

void setSpring() {
  for (int i=0; i<physics.springs.size(); i++) {
    Spring tmp = (Spring)physics.springs.get(i);
    tmp.setStrength(SPRING_STRENGTH);
    tmp.setDamping(SPRING_DAMPING);
  }
}

void drawSubWindow() {
  float scaleRate = 0.6;
  pushMatrix();
  translate(width-(30+sizeOfCol*interval_col*scaleRate), 50, 0);

  for (int i=0; i<physics.springs.size(); i++) {
    Spring currentSpring = (Spring)physics.springs.get(i);
    Particle p1 = currentSpring.a;
    Particle p2 = currentSpring.b;
    stroke(0, 0, 0, 50);
    line(p1.initialPosition.x()*scaleRate, p1.initialPosition.y()*scaleRate, p2.initialPosition.x()*scaleRate, p2.initialPosition.y()*scaleRate);
  }

  for (int i=0; i<sizeOfCol; i++) {
    for (int j=0; j<sizeOfRow; j++) {
      if (particles[i][j].dead == false) {
        stroke(0);
        if (particles[i][j].isFixed()) {
          stroke(255, 255, 0, 100);
          fill(255, 255, 0, 100); 
          ellipse(particles[i][j].initialPosition().x()*scaleRate, particles[i][j].initialPosition().y()*scaleRate, 4, 4);
        }
        else { 
          point(particles[i][j].initialPosition().x()*scaleRate, particles[i][j].initialPosition().y()*scaleRate);
        }
      }
    }
  }
  fill(255, 255, 0);
  ellipse(c1_x*scaleRate, c1_y*scaleRate, 6*scaleRate, 6*scaleRate);
  popMatrix();
}

public class PFrame extends Frame {
  public PFrame() {
    setBounds(1000, 0, subWindow_x, subWindow_y);
    s = new secondApplet();
    add(s);
    s.init();
    show();
  }
}

public class secondApplet extends PApplet {
  public void setup() {
    size(subWindow_x, subWindow_y);
    noLoop();
  }
  public void draw() {
  }
}

void setCurrentParticle() {
  color c1 = bf.get(mouseX, mouseY);
  color c2 = color(0);

  if (c1 > c2) { //pointer visualizer 

    float c2_x = red(c1) * 3;
    float c2_y = green(c1) * 3;
    float c2_z = blue(c1) * 3;

    for (int i=0; i<sizeOfCol; i++) {
      for (int j=0; j<sizeOfRow; j++) {
        if (c2_x - 5 < particles[i][j].position.x() && particles[i][j].position.x() < c2_x + 5 &&
          c2_y - 5 < particles[i][j].position.y() && particles[i][j].position.y() < c2_y + 5 &&
          c2_z - 5 < particles[i][j].position.z() && particles[i][j].position.z() < c2_z + 5) {
          currentParticle = particles[i][j];
        }
      }
    }
    currentParticle_2.set(c2_x, c2_y, c2_z);
    currentParticle.position.set(currentParticle_2.x, currentParticle_2.y, currentParticle_2.z);
  }
}

void setInitialCloth() {
  particles = new Particle[sizeOfCol][sizeOfRow];
  displaySignOfParticles = new int[sizeOfCol][sizeOfRow];
  Spring[] currentSpring = new Spring[1];

  //initial arrangement of particles  
  int id = 1;
  for (int i = 0; i<sizeOfCol; i++) {
    for (int j = 0; j<sizeOfRow; j++) {
      particles[i][j] = physics.makeParticle(id, massOfParticle, i*interval_col+10, j*interval_row+10, 0.0 );
      if (j > 0) physics.makeSpring(particles[i][j-1], particles[i][j], SPRING_STRENGTH, SPRING_DAMPING, interval_col);//rows
      id = id + 1;
    }
  }

  //settings of springs of particles  
  for (int j = 0; j < sizeOfRow; j++) {
    for (int i = 0; i < sizeOfCol; i++) {
      if (i > 0) physics.makeSpring(particles[i - 1][j], particles[i][j], SPRING_STRENGTH, SPRING_DAMPING, interval_row);//colums
      if (i+1 < sizeOfCol && j+1 < sizeOfRow) physics.makeSpring(particles[i][j], particles[i+1][j+1], SPRING_STRENGTH, SPRING_DAMPING, interval_col*sqrt(2));//隴∵㈱�∬愾�ｳ
      if (j > 0 && i+1 < sizeOfCol) physics.makeSpring(particles[i][j], particles[i+1][j-1], SPRING_STRENGTH, SPRING_DAMPING, interval_row*sqrt(2));//隴∵㈱�∬淦�ｦ
    }
  }

  //settings of fixed points  
  particles[0][0].makeFixed();
  anchor[anchornum] = particles[0][0].id;
  anchornum = anchornum + 1;

  particles[0][sizeOfRow - 1].makeFixed();
  anchor[anchornum] = particles[0][sizeOfRow - 1].id;
  anchornum = anchornum + 1;

  particles[sizeOfCol - 1][0].makeFixed();
  anchor[anchornum] = particles[sizeOfCol - 1][0].id;
  anchornum = anchornum + 1;

  particles[sizeOfCol - 1][sizeOfRow - 1].makeFixed();
  anchor[anchornum] = particles[sizeOfCol - 1][sizeOfRow - 1].id;
  anchornum = anchornum + 1;

  currentParticle = particles[0][0];
  currentParticle_2 = new PVector(0, 0, 0);
}

void drawPGraphics() {
  bf.beginDraw();
  bf.background(255);
  bf.translate(width/2, height/1.6);
  bf.rotateX(rotx);
  bf.rotateY(roty);
  bf.scale(expo);

  for (int j = 0; j < sizeOfRow; j++) {
    for (int i = 0; i < sizeOfCol; i++) {
      bf.pushMatrix();
      bf.translate(-sizeOfCol*interval_col/2, -sizeOfRow*interval_row/2, 0);
      bf.translate(particles[i][j].position().x(), particles[i][j].position().y(), particles[i][j].position().z());
      bf.noStroke();
      bf.fill(particles[i][j].position().x()/3, particles[i][j].position().y()/3, particles[i][j].position().z()/3);
      bf.ellipse(0, 0, 10, 10);//box size determine the eria of pointer 
      bf.popMatrix();
    }
  }
}

void drawPointer() {
  c1 = bf.get(mouseX, mouseY);
  c2 = color(0);

  if (c1 > c2) { //pointer visualizer 
    c1_x = red(c1) * 3;
    c1_y = green(c1) * 3;
    c1_z = blue(c1) * 3;   
    pushMatrix();
    translate(-sizeOfCol*interval_col/2, -sizeOfRow*interval_row/2, 0);
    translate(c1_x, c1_y, c1_z);
    fill(c1_x, c1_y, c1_z);
    ellipse(0, 0, 10, 10);
    popMatrix();
  }
}

void drawCloth() {
  //  stroke(0);
  //  fill(0,0,0,100);
  //  float eSize = 0;
  //  for(int i=0; i<physics.particles.size(); i++) {
  //    Particle tempParticle = (Particle)physics.particles.get(i);
  //    if(tempParticle.isFixed()) {
  //      fill(255,255,255,100); 
  //      eSize = interval_col/3;
  //    }
  //    else {
  //      fill(0,0,0,100); 
  //      eSize = interval_col/6;
  //    }
  //    pushMatrix();
  //    translate(-sizeOfCol*interval_col/2,-sizeOfRow*interval_row/2,0);
  //    translate(tempParticle.position().x(), tempParticle.position().y(),tempParticle.position().z());
  ////    ellipse(0, 0, eSize, eSize);
  //    popMatrix();
  //  }

  stroke(0,100);
  pushMatrix();
  translate(-sizeOfCol*interval_col/2, -sizeOfRow*interval_row/2, 0);
  for (int i=0; i<physics.springs.size(); i++) {
    Spring currentSpring = (Spring)physics.springs.get(i);
    Particle p1 = currentSpring.a;
    Particle p2 = currentSpring.b;
    line(p1.position.x(), p1.position.y(), p1.position.z(), p2.position.x(), p2.position.y(), p2.position.z());
  }
  popMatrix();

  fill(255, 255, 0, 50);
  pushMatrix();
  translate(-sizeOfCol*interval_col/2, -sizeOfRow*interval_row/2, 0);
  translate(currentParticle.position.x, currentParticle.position.y, currentParticle.position.z);
  ellipse(0, 0, interval_col/2, interval_row/2);
  popMatrix();

  pushMatrix();
  translate(-sizeOfCol*interval_col/2, -sizeOfRow*interval_row/2, 0);
  translate(currentParticle_2.x, currentParticle_2.y, currentParticle_2.z);
  ellipse(0, 0, interval_col/2, interval_row/2);
  popMatrix();
}


void drawHunger(float height) {
  fill(200, 125);
  noStroke();
  float root = (float)Math.sqrt(3);

  for (int i=0; i<hunger_x; i++) {
    for (int j=0; j<hunger_y; j++) {
      pushMatrix();
      translate(-sizeOfCol*interval_col/2, -sizeOfRow*interval_row/2, 0);
      translate(30*root*i, 30*j, height);
      ellipse(0, 0, interval_col/2, interval_row/2);
      popMatrix();
    }
  }

  for (int i=0; i<hunger_x-1; i++) {
    for (int j=0; j<hunger_y-1; j++) {
      pushMatrix();
      translate(-sizeOfCol*interval_col/2, -sizeOfRow*interval_row/2, 0);
      translate(15 * root, 15, 0.0);
      translate(30 * root * i, 30*j, height);
      ellipse(0, 0, interval_col/2, interval_row/2);
      popMatrix();
    }
  }

  bf.noStroke();
  for (int i=0; i<hunger_x; i++) {
    for (int j=0; j<hunger_y; j++) {
      //      float root = (float)Math.sqrt(3);
      bf.pushMatrix();
      bf.translate(-sizeOfCol*interval_col/2, -sizeOfRow*interval_row/2, 0);
      bf.fill(30*root*i/3, 30*j/3, height/3);
      bf.translate(30*root*i, 30*j, height);
      bf.ellipse(0, 0, 10, 10);
      bf.popMatrix();
    }
  }

  for (int i=0; i<hunger_x-1; i++) {
    for (int j=0; j<hunger_y-1; j++) {
      //      float root = (float)Math.sqrt(3);
      bf.pushMatrix();
      bf.translate(-sizeOfCol*interval_col/2, -sizeOfRow*interval_row/2, 0);
      bf.fill((30*root*i+15*root)/3, (30*j + 15)/3, height/3);
      bf.translate(15 * root, 15, 0.0);
      bf.translate(30 * root * i, 30*j, height);
      bf.ellipse(0, 0, 10, 10);
      bf.popMatrix();
    }
  }
}

void drawFaces() {
  pushMatrix();
  noStroke();
  translate(-sizeOfCol*interval_col/2, -sizeOfRow*interval_row/2, 0);
  fill(255,0,0,180);
  for (int i=0; i<quadrangles.length; i++) {
    if (quadrangles[i][0] != null && quadrangles[i][1] != null  && quadrangles[i][2] != null && quadrangles[i][3] != null ) {
      Particle p1 = quadrangles[i][0];
      Particle p2 = quadrangles[i][1];
      Particle p3 = quadrangles[i][2];
      Particle p4 = quadrangles[i][3];
      beginShape(QUADS);
      vertex(p1.position.x, p1.position.y, p1.position.z);
      vertex(p2.position.x, p2.position.y, p2.position.z);
      vertex(p3.position.x, p3.position.y, p3.position.z);
      vertex(p4.position.x, p4.position.y, p4.position.z);
      endShape(CLOSE);
    }
  }
  popMatrix();
}

void setQuads() {
  int num = 0;
  quadrangles = new Particle[(sizeOfCol-1)*(sizeOfRow-1)][5];
  quads = new int[(sizeOfCol)*(sizeOfRow)];
  for (int i=0; i<sizeOfCol; i++) {
    for (int j=0; j<sizeOfRow; j++) {
      if (i+1<sizeOfCol && j+1<sizeOfRow) {
        if (particles[i][j].dead != true && particles[i][j+1].dead != true && particles[i+1][j+1].dead != true && particles[i+1][j].dead != true) {
          quadrangles[num][0] = particles[i][j];
          quadrangles[num][1] = particles[i][j+1];
          quadrangles[num][2] = particles[i+1][j+1];
          quadrangles[num][3] = particles[i+1][j]; 
          quads[num] = 1;     
          num++;
        }
        else {
          quadrangles[num][0] = null;
          quadrangles[num][1] = null;
          quadrangles[num][2] = null;
          quadrangles[num][3] = null;
        }
      }
    }
  }
}


void gui() {
  hint(DISABLE_DEPTH_TEST);
  PMatrix3D currCameraMatrix = new PMatrix3D(((PGraphics3D)g).camera);
  camera();
  controlP5.draw();
  if (sub_display) drawSubWindow();
  ((PGraphics3D)g).camera = currCameraMatrix;
  hint(ENABLE_DEPTH_TEST);
}