import processing.opengl.*;
//
// viewport
float eyeX;
float eyeY;
float eyeZ = -100.0;
float eyeTargetX = 75.0;
float eyeTargetY = 75.0;
float eyeTargetZ = 0.0;
float eyeDragX;
float eyeDragY;
float eyeDragZ;
float eyeDragRotation;
float eyeRotation;
int mouseDragX;
int mouseDragY;
int cycle = 10;
boolean dragFlag = false;
// max nodes, 25*25 for example
int nodeAmount = 624;
// nodes array: x,y,z,force
float[][] nodes = new float[nodeAmount][4];  
// nodesFixed array: x,y,z
float[][] nodesFixed = new float[nodeAmount][3];  
// nodesTarget array: xtaret,ytarget,ztarget
float[][] nodesTarget = new float[nodeAmount][3];  
// connections array: node1, node2, orginaldistance
float[][] connections = new float[nodeAmount*5][4];  

// casey image example
PImage a;
int imageSize = 25;
int[][] aPixels;
int currentImage = 0;
int maxImage = 5;






//


void setup() {
  size(800, 600, OPENGL);
  colorMode(HSB, 100); 
  framerate(30);
  eyeRotation = PI/3;
  eyeX = sin(eyeRotation)*100;
  eyeY = cos(eyeRotation)*100; 
  generateNodes();
  generateConnections();
  //noFill(); 
  setCamera();

}

void draw() {
  background(0,0,20);
  calcForces();
  drawNodes();
  drawConnections();
  drawCarbonSticks();
  //
  if(keyPressed) { 
    if(key == 'r' || key == 'R') { 
      randomForces();
    } 
    if(key == 's' || key == 'S') { 
      resetForces();
    } 
    if(key == 'c' || key == 'C') { 
      cycleForces();
    }
    if(key == 'p' || key == 'P') { 
      patternForces();
    }
    if(key == 'i' || key == 'I') { 
      loadMyImage();
      displayMyImage();
    }
    if((keyCode == UP) || (keyCode == DOWN) || (keyCode == LEFT) || (keyCode == RIGHT)){
      moveCamTarget();
    }

  }

}


// generate data ***********************************************************************************
void generateNodes() {
  float x = 0;
  float y = 0;
  float z = 0;
  for (int i=0; i<nodeAmount; i++) {
    x += 6;
    if ((x>144) && (x%2==0) ) {
      x = 3;
      y += sqrt(27);
    } 
    else if (x>147){
      x = 0;
      y += sqrt(27);
    }
    if (false && (y > 20) && ((z/sqrt(27))%2==0) ){
      y = -73;
      z -= sqrt(27);
    } 
    if (false && (y > 20) && ((z/sqrt(27))%2!=0) ){
      y = -70;
      z -= sqrt(27);

    }

    //z = 0;
    nodes[i][0] = x;
    nodes[i][1] = y;
    nodes[i][2] = z;
    // and force
    nodes[i][3] = 0;
    //nodes[i][3] = random(200)-100;
    // store initial position
    nodesFixed[i][0] = x;
    nodesFixed[i][1] = y;
    nodesFixed[i][2] = z;
    // store targets
    nodesTarget[i][0] = x;
    nodesTarget[i][1] = y;
    nodesTarget[i][2] = z;
  }
}


// data for all connected nodes, with their original distance stored
void generateConnections() {
  int connectionCounter = 0;
  for (int nodei=0; nodei<nodeAmount; nodei++) {
    for (int nodej=0; nodej<nodeAmount; nodej++) {
      if (nodei != nodej) {
        float mydistance = dist(nodes[nodei][0], nodes[nodei][1],nodes[nodei][2],nodes[nodej][0],nodes[nodej][1],nodes[nodej][2]);
        if (mydistance<7) {
          //println("dist= "+mydistance);
          boolean skipThis = false;
          for (int noDouble=0; noDouble<connections.length; noDouble++) {
            if (connections[noDouble][0] == nodej) {
              skipThis = true;
              //println("skipping ");
              break;
            } 
            else {
              skipThis = false;
            }
          }
          if (!skipThis) {
            connections[connectionCounter][0] = nodei;
            connections[connectionCounter][1] = nodej;
            connections[connectionCounter][2] = mydistance;
            connectionCounter +=1;
            //println("saving connection nr "+connectionCounter+", "+nodei+" to "+nodej+" with dist "+mydistance);
          }
        }
      }
    }
  }
}

// Change forces *********************************************************************************************


void randomForces(){
  for (int i=0; i<nodeAmount; i++) {
    nodes[i][3] = random(200)-100;
  }
}

void resetForces(){
  for (int i=0; i<nodeAmount; i++) {
    nodes[i][3] = 0;
  }
}

void cycleForces(){
  cycle += 5;
  for (int i=0; i<10; i++){
    nodes[(cycle-i)][3] = 50-(i*10);
  }
  if (cycle >= nodeAmount-10){
    cycle = 10;
  }
}


void patternForces(){
  float offset = random(20)+1;
  for (int i=0; i<nodeAmount; i++){
    nodes[(i)][3] = (i%offset)*20-40;
  }

}
// Display images

void loadMyImage(){
  aPixels = new int[imageSize][imageSize];
  a = loadImage("pattern"+currentImage+".gif");
  for(int i=0; i<imageSize; i++) {
    for(int j=0; j<imageSize; j++) {
      aPixels[j][i] = a.pixels[(i*imageSize)+j];
    }
  }
  currentImage ++;
  if (currentImage > maxImage){
    currentImage = 0;
  }
}

void displayMyImage(){
float rr, gg, bb, tt;
  for(int i=0; i<imageSize; i++) {
    for(int j=0; j<imageSize; j++) {
      rr = red(aPixels[j][i]); 
      gg = green(aPixels[j][i]);
      bb = blue(aPixels[j][i]);
      tt = rr+gg+bb;
      //stroke(rr, gg, gg);
      //line(i, j, tt/10-20, i, j, tt/10 );
      int fix = 0;
      if (((i*imageSize)+j+fix)<nodeAmount && ((i*imageSize)+j+fix)>0){
        nodes[(i*imageSize)+j+fix][3] = tt-50;
      }
    }
  }
}



// Calculate forces *********************************************************************************************



// iterate a to b with speed
void iterate(int a, int b, float speed) {
  nodesTarget[a][0] -= (nodesTarget[a][0]-nodesTarget[b][0])/speed;
  nodesTarget[a][1] -= (nodesTarget[a][1]-nodesTarget[b][1])/speed;
  nodesTarget[a][2] -= (nodesTarget[a][2]-nodesTarget[b][2])/speed;
}
// iterate a to its origin with speed
void stayFixed(int a, float speed) {
  float offset;
  offset = ((nodesTarget[a][0]-nodesFixed[a][0])+(nodesTarget[a][1]-nodesFixed[a][1]))/2;
  nodesTarget[a][0] -= (nodesTarget[a][0]-nodesFixed[a][0])/speed;
  nodesTarget[a][1] -= (nodesTarget[a][1]-nodesFixed[a][1])/speed;
  nodesTarget[a][2] -= (nodesTarget[a][2]-(nodesFixed[a][2]-offset))/speed;
}
// iterate a target values with speed
void applyPositions(int a, float speed) {
  nodes[a][0] -= (nodes[a][0]-nodesTarget[a][0])/speed;
  nodes[a][1] -= (nodes[a][1]-nodesTarget[a][1])/speed;
  nodes[a][2] -= (nodes[a][2]-nodesTarget[a][2])/speed;
}
void followFriend(int a, int b, float defaultDistance, float speed) {
  defaultDistance = defaultDistance-(nodes[a][3]+nodes[b][3])/2;
  if (dist(nodes[a][0], nodes[a][1],nodes[a][2],nodes[b][0],nodes[b][1],nodes[b][2])>defaultDistance) {
    iterate(a, b, speed);
    iterate(b, a, speed);
  }
}
void calcForces(){

  for (int j=0; j<connections.length; j++) {
    followFriend(int(connections[j][0]), int(connections[j][1]), connections[j][2], 10); 
  }
  for (int i=0; i<nodeAmount; i++){
    stayFixed(i, 30);

  }
  for (int k=0; k<connections.length; k++) {
    applyPositions(int(connections[k][0]), 50);
  }

}
// Draw ***************************************************************************************************************
void drawNodes(){
  for (int i=0; i<nodeAmount; i++) {
    float myForce;
    pushMatrix();
    translate(nodes[i][0], nodes[i][1], nodes[i][2]-1.5);
    //stroke(0,0,50);
    myForce = nodes[i][3];
    fill(40+myForce/5, myForce, myForce);
    noStroke();
    box(0.5,0.5,3);
    popMatrix(); 
  }
  // and shadows
  for (int i=0; i<nodeAmount; i++) {
    pushMatrix();
    translate(nodes[i][0], nodes[i][1], 10);
    //stroke(0,0,50);
    fill(10,10,35);
    noStroke();
    //box(0.5,0.5,0);
    popMatrix(); 
  }
}
//
void drawConnections(){
  float x1;
  float y1;
  float z1;
  float x2;
  float y2;
  float z2;
  int stress; 
  for (int j=0; j<connections.length; j++) {
    x1 = nodes[int(connections[j][0])][0];
    y1 = nodes[int(connections[j][0])][1];
    z1 = nodes[int(connections[j][0])][2];
    x2 = nodes[int(connections[j][1])][0];
    y2 = nodes[int(connections[j][1])][1];
    z2 = nodes[int(connections[j][1])][2];
    //println("connecting nr "+j+", ("+x1+","+y1+") to ("+x2+","+y2+")");
    stress = int(connections[j][2]/dist(x1,y1,z1,x2,y2,z1)*60)-10;
    stroke(6,30,stress);
    //stroke(0,0,40);
    line(x1,y1,z1,x2,y2,z2); 
    // ground
    //stroke(0,0,40);
    // line(x1,y1,10,x2,y2,10); 

  }
}
//
//
void drawCarbonSticks(){
  float groundLevel = 20.0;
  for (int i=0; i<nodeAmount; i++){
    // anchor control control anchor nodesFixed
    stroke(0,0,5);
    bezier(nodesFixed[i][0], nodesFixed[i][1], groundLevel, nodesFixed[i][0], nodesFixed[i][1], groundLevel, 
    nodesFixed[i][0], nodesFixed[i][1], nodesFixed[i][2], nodes[i][0], nodes[i][1], nodes[i][2]);
  }
}

// 3d space control *************************************************************************************************
void setCamera(){
  //perspective();
  camera(eyeX, eyeY, eyeZ, eyeTargetX, eyeTargetY, eyeTargetZ, 0.0, 0.0, 1.0); 
}

void mousePressed(){ 
  if(!dragFlag) { 
    dragFlag = true;
    mouseDragX = mouseX;
    mouseDragY = mouseY;
    eyeDragX = eyeX;
    eyeDragY = eyeY;
    eyeDragZ = eyeZ;
    eyeDragRotation = eyeRotation;
  } 
} 

void mouseReleased(){ 
  dragFlag = false;
}

void mouseDragged(){
  if (true){
    eyeZ = eyeDragZ + (mouseDragY - mouseY)/3;
    eyeRotation = eyeDragRotation-(mouseDragX - float(mouseX))/120;
    eyeX = sin(eyeRotation)*40;
    eyeY = cos(eyeRotation)*40; 
    setCamera();
  }
} 

void moveCamTarget(){
  float nudge = 10;
  if(keyCode ==UP){
    eyeTargetY += nudge;
  }
  if(keyCode ==DOWN){
    eyeTargetY -= nudge;
  }
  if(keyCode ==LEFT){
    eyeTargetX -= nudge;
  }
  if(keyCode ==RIGHT){
    eyeTargetX += nudge;
  }
  setCamera();
}