class Fpoint {
  Fpoint(){
    x = y = 0;
  }
  float x,y;
}

class Pea {
  float pr,pt,pz;
  float vr,vt,vz;
  float r;
  int holeId;

  Pea (int i){
    holeId = i;
    pr = random(0.1, 0.9); 
    pt = random(TWO_PI); 
    pz = random(-ZZ, ZZ);
    vr = 0; 
    vt = 0.075; 
    vz = 0;
  }
  void update(){
    pr += vr;
    pt += vt;
    pz += vz;
  }
  void render (float rx, float ry){
    float sx = 0.5 * holeSizes[holeId].x;
    float sy = 0.5 * holeSizes[holeId].y;
    float px = sx * pr * cos(pt);
    float py = sy * pr * sin(pt);
    pushMatrix();
    translate(px,py,pz);
    rotateY(0-ry);
    rotateX(0-rx);

    fill(0.0, 0.35, 0.2);
    ellipse(0,0,  7,7);
    fill(0.0, 0.5, 0.4);
    ellipse(0.5,-0.5, 5,5);
    fill(0.0, 0.7, 0.5);
    ellipse(1,-1, 3,3);
    fill(0.0, 0.8, 0.7);
    ellipse(1,-1, 1.5,1.5);

    popMatrix();
  }
}

PFont  myFont;
Pea    peas[];
int    nPeas;
Fpoint paths[][];
Fpoint mainCentroid;
Fpoint holeCentroids[];
Fpoint holeSizes[];
int nPaths;
int pathLengths[];
boolean loadedData = false;
float mx,  my;
float pmx, pmy;
float ZZ = 50;
float vang = 0;


//===========================================================================
void setup(){
  size(320,240, P3D);
  colorMode(RGB, 1.0);

  myFont = loadFont("BellCentennial-SubCaption-16.vlw");
  textFont(myFont, 16);

  loadPathData();
  computePathCentroids();
  makePeasThackeray();

}
//===========================================================================
void makePeasThackeray(){
  nPeas = 50;
  peas = new Pea[nPeas];
  for (int i=0; i<nPeas; i++){
    int id = (i < (nPeas/2)) ? 0:1;
    peas[i] = new Pea(id); 
  }
}



//===========================================================================
void draw(){
  background (0.7, 0.925, 0.85);

  pmx = mx;
  pmy = my;
  float A = 0.8;
  float B = 1.0 - A;
  mx = A*mx + B*mouseX;
  my = A*my + B*mouseY;
  float midX = width/2.0;
  float midY = height/2.0;
  float xswivel = ((midY-my)/2000.0) + 0.55 + 0.12*sin(millis()/1500.0);
  float yswivel = ((mx-midX)/2000.0);
  updateVang();

  pushMatrix();
  translate(midX,midY);
  rotateX(xswivel);
  rotateY(yswivel);
  // scale(1.0,1.0,1.0);
  translate (0-mainCentroid.x, 0-mainCentroid.y);


  drawColumns();
  drawPeas(xswivel, yswivel);
  drawEdges();

  popMatrix();
  noStroke();
  fill(0,0.4,0.3, 0.5);
  text("whirled peas in 06", 100, height-16); 

}

//===========================================================================
void updateVang(){
  float cx = width/2.0;
  float cy = height/2.0;

  float ax = pmx - cx;
  float ay = pmy - cy;
  float bx = mx - pmx;
  float by = my - pmy;
  float cross = ax*by - ay*bx;
  cross = min(600, max(-600, cross));

  vang = 0.975*vang + 0.025*cross;
  if (abs(vang)>50.0){
    float dvang = vang/100000.0;
    for (int i=0; i<nPeas; i++){
      peas[i].vt += dvang;
      peas[i].vt *= 0.98;
    }
  }
}

//===========================================================================
void drawPeas(float rx, float ry){
  float cx,cy;
  float sx,sy;
  int nPeasd2 = nPeas/2;


  noStroke();


  pushMatrix();
  cx = holeCentroids[0].x;
  cy = holeCentroids[0].y;  
  translate(cx,cy);
  for (int i=0; i<nPeasd2; i++){
    pushMatrix();
    peas[i].render(rx,ry);
    peas[i].update();
    popMatrix();
  }
  popMatrix();

  pushMatrix();
  cx = holeCentroids[1].x;
  cy = holeCentroids[1].y;  
  translate(cx,cy);
  for (int i=nPeasd2; i<nPeas; i++){
    peas[i].render(rx,ry);
    peas[i].update();
  }
  popMatrix();
}


//===========================================================================
void drawEdges(){
  if (loadedData){
    float px, py;
    stroke(0,0,0, 0.125);
    strokeWeight(1.0);

    for (int i=0; i<nPaths; i++){
      beginShape(LINE_LOOP);
      for (int j=0; j<pathLengths[i]; j+=2){
        px = paths[i][j].x;
        py = paths[i][j].y;
        vertex(px,py,-ZZ);
      }
      endShape();

      beginShape(LINE_LOOP);
      for (int j=0; j<pathLengths[i]; j++){
        px = paths[i][j].x;
        py = paths[i][j].y;
        vertex(px,py,ZZ);
      }
      endShape();

    }
  }
}

//===========================================================================
void drawColumns(){
  if (loadedData){

    float pz = 0;
    float px, py;
    noStroke();

    float cg = 0.5* 0.925;
    float cb = 0.5* 0.850;
    fill(0,cg,cb, 0.08);

    for (int i=0; i<nPaths; i++){
      beginShape(QUAD_STRIP);
      for (int j=0; j<pathLengths[i]; j+=2){
        px = paths[i][j].x;
        py = paths[i][j].y;
        vertex(px,py,pz-50);
        vertex(px,py,pz+50);
      }
      px = paths[i][0].x;
      py = paths[i][0].y;
      vertex(px,py,pz-50);
      vertex(px,py,pz+50);
      endShape();
    }
  }
}


//===========================================================================
void loadPathData(){

  String iline[];
  float  fline[];
  String lines[] = loadStrings("06.txt"); 

  // count the number of paths
  int pathCount = 0;
  for (int i=0; i < lines.length; i++) { 
    iline = (split(lines[i])); 
    if (iline[0].charAt(0) == 'Z'){ // the endpath character
      pathCount++; 
    }  
  }
  paths = new Fpoint[pathCount][];

  // allocate the necessary number of points for each path
  pathCount = 0;
  int pathLength = 0;
  for (int i=0; i < lines.length; i++) { 
    iline = (split(lines[i])); 
    if (iline[0].charAt(0) == 'Z'){
      paths[pathCount] = new Fpoint[pathLength];
      pathCount++;
      // println ("pathLength = " + pathLength); 
      pathLength = 0;
    } 
    else {
      pathLength ++;
      // println (iline[0].charAt(0) + " " + fline[1] + " " + fline[2]);
    }
  }
  // println("pathCount = " + pathCount);
  nPaths = pathCount;
  pathLengths = new int[nPaths];

  // fill the arrays
  int currentPath = 0;
  int currentPathPoint = 0;
  float currentPathX = 0;
  float currentPathY = 0;
  for (int i=0; i < lines.length; i++) { 
    iline = (split(lines[i])); 
    char firstChar = iline[0].charAt(0);
    if (firstChar == 'Z'){
      pathLengths[currentPath] = currentPathPoint;
      currentPath++;
      currentPathPoint = 0;
    } 
    else {
      fline = float(split(lines[i]));
      if (fline.length == 3){
        if ((firstChar == 'M') || (firstChar == 'L')) { // absolute moveto or lineto
          currentPathX = fline[1];
          currentPathY = fline[2];
        } 
        else if (firstChar == 'l'){ // relative moveto
          currentPathX += fline[1];
          currentPathY += fline[2];
        }
        // println (currentPath + " " + currentPathPoint + " " + currentPathX + " " + currentPathY); 
        if (currentPathPoint < paths[currentPath].length){
          paths[currentPath][currentPathPoint] = new Fpoint();
          paths[currentPath][currentPathPoint].x = currentPathX;
          paths[currentPath][currentPathPoint].y = currentPathY;
          currentPathPoint++;
        }
      }
    }
  }
  loadedData = true;

}


//===========================================================================
void computePathCentroids(){
  float mcn = 0;
  float cn0 = 0;
  float cn1 = 0;
  float px, py;

  mainCentroid  = new Fpoint();
  holeCentroids = new Fpoint[2];
  holeCentroids[0] = new Fpoint();
  holeCentroids[1] = new Fpoint();

  for (int i=0; i<nPaths; i++){
    for (int j=0; j<pathLengths[i]; j++){
      px = paths[i][j].x;
      py = paths[i][j].y;
      mainCentroid.x += px;
      mainCentroid.y += py;
      mcn ++;

      if (i==1){
        holeCentroids[0].x += px;
        holeCentroids[0].y += py;
        cn0++;
      } 
      else if (i==3) {
        holeCentroids[1].x += px;
        holeCentroids[1].y += py;
        cn1++;
      }
    }
  }

  mainCentroid.x /= mcn;
  mainCentroid.y /= mcn;
  holeCentroids[0].x /= cn0;
  holeCentroids[0].y /= cn0;
  holeCentroids[1].x /= cn1;
  holeCentroids[1].y /= cn1;

  float h0L =  9999;
  float h0R = -9999;
  float h0T =  9999;
  float h0B = -9999;
  float h1L =  9999;
  float h1R = -9999;
  float h1T =  9999;
  float h1B = -9999;
  holeSizes  = new Fpoint[2];
  holeSizes[0] = new Fpoint();
  holeSizes[1] = new Fpoint();

  for (int i=0; i<nPaths; i++){
    for (int j=0; j<pathLengths[i]; j++){
      px = paths[i][j].x;
      py = paths[i][j].y;

      if (i==1){
        if (px < h0L) h0L = px;
        if (px > h0R) h0R = px;
        if (py < h0T) h0T = py;
        if (py > h0B) h0B = py;
      } 
      else if (i==3) {
        if (px < h1L) h1L = px;
        if (px > h1R) h1R = px;
        if (py < h1T) h1T = py;
        if (py > h1B) h1B = py;
      }
    }
  }
  holeSizes[0].x = h0R - h0L;
  holeSizes[0].y = h0B - h0T;
  holeSizes[1].x = h1R - h1L;
  holeSizes[1].y = h1B - h1T;
}