//import processing.opengl.*;

int leng=120;
float amplitude=20, rootFrequency=TWO_PI/120, frequency=rootFrequency, wanderingFrequency=rootFrequency/(12*PI), phase=0, k=0.1, mult=1;
final int LOOPED=0, FIXED=1, FREE=2, MIXED=3, TOP=0, SIDE=1;
int ends=LOOPED, view=2;    
boolean circular=true, frequencyWandering=true, frameBlending=true;
color colour;
color colours[]=new color[leng];
Particle particles[]=new Particle[leng];
//int sinArray[]=new int[721];

int xPos, yPos, oldxPos, oldyPos, c, i, t, colMul=2;
float tinc = TWO_PI/150;
float finc = TWO_PI/1000;
int drawStyle=2, mode=2, frame=0, repeats=3;
int dp=leng*3/4; // driver position
float tension=0.5, g=0.01, damping=0.005, ff=TWO_PI/1800, fAmp=0.01, restLength=1;
float dolly=120,turnRate=0.01, xRot=PI/4, yRot=0, xOld=0, yOld=0;
void draw(){
  //if(t<-10.0 && t>-10.2) println ("fps: " t*10000/millis());
  t=0;
  if (frameBlending){
    fill(0,4);
    translate(width/2, height/2, dolly+100);
    noStroke();
    box(width,height,1);
    translate(-width/2, -height/2, -dolly-100);
  }
  else background(0);
  translate(width/2, height*0.5*(1-cos(xRot)), dolly); // 0 if cos (xRot)=1, 0.5 if cos (xRot)=0
  //rotateX(xRot);
  //rotateY(yRot);
for (int repeat=0; repeat<repeats; repeat++){
  simulateStep();
  fill (colours[frame*colMul%leng], 80);
  if (drawStyle==2) beginShape(TRIANGLE_STRIP);
  else beginShape();
  for (int i=1; i<leng-1; i++) {
      vertex(particles[i].ox,particles[i].oy*cos(xRot)+particles[i].oz*sin(xRot),0);
      vertex(particles[i].x,particles[i].y*cos(xRot)+particles[i].z*sin(xRot),0);
      /*if (view==TOP) vertex(particles[i].x+width/2,particles[i].z+height/2,0);
      else if (view==SIDE) vertex(particles[i].x+width/2,particles[i].y,0);
      else vertex(particles[i].x+width/2,particles[i].z/2+particles[i].y/2+height/4,0);*/
  }
  endShape();
  if (keyPressed){
    if (keyCode==UP) amplitude+=0.5;
    if (keyCode==RIGHT) rootFrequency+=0.001;    
    if (keyCode==DOWN) amplitude-=0.5;
    if (keyCode==LEFT) rootFrequency-=0.001;    
  }
  frame++;
}
}


class Particle {
  public float x,y,z,vx,vy,vz,ox,oy,oz;

  Particle (float x, float y, float z, float vx, float vy, float vz){
    this.x=x;  this.y=y;  this.z=z;  this.vx=vx;  this.vy=vy;  this.vz=vz; 
  }

  Particle (float y){
    new Particle (0,y,0,0,0,0);
  }

  Particle (){
    new Particle (0,0,0,0,0,0);
  }

  void move(){
    ox=x; oy=y; oz=z;
    x+=vx; y+=vy; z+=vz;
  }
  
  void damp(){
    vx*=1-damping;
    vy*=1-damping;
    vz*=1-damping;
  }
}
float getDistance (float x, float y, float z){
  return sqrt(x*x+y*y+z*z);
}

float getDistance(Particle p1, Particle p2){
  float x=p1.x-p2.x;
  float y=p1.y-p2.y;
  float z=p1.z-p2.z;
  return sqrt(x*x+y*y+z*z);
}

void attract(Particle p1, Particle p2){
  /*force=tension*(getDistance(p1,p2)-restLength);*/
  mult=1-restLength/getDistance(p1,p2);
  p1.vx+=tension*(p2.x-p1.x)*mult;
  p1.vy+=tension*(p2.y-p1.y)*mult;
  p1.vz+=tension*(p2.z-p1.z)*mult;
  p2.vx+=tension*(p1.x-p2.x)*mult;
  p2.vy+=tension*(p1.y-p2.y)*mult;
  p2.vz+=tension*(p1.z-p2.z)*mult;
}

void simulateStep(){
    particles[0].x=amplitude*cos(phase);
    particles[0].z=amplitude*sin(phase);
    particles[0].y=0;
    if (ends==FIXED) {
      particles[leng-1].x=0;
      particles[leng-1].y=height;      
      particles[leng-1].z=0;
        }
    for (i=0;i<leng-1;i++){
        // Forces between neighbours:
        attract (particles[i%particles.length], particles[i+1%particles.length]);
        // Gravity:
        particles[i].vy+=g;
        // Damping:
        particles[i].damp();
    }
    particles[leng-1].vy+=g;    
   for (i=0;i<leng;i++){
    	particles[i].move();
    }

    phase+=frequency;
    if (frequencyWandering) {
      frequency=rootFrequency*(cos(ff));
      ff+=wanderingFrequency;
    }
    else frequency=rootFrequency;

 }

public void reset(){
        for (i=0; i<leng; i++){
           particles[i]=new Particle(0,(float)i, 0, 0,0,0);
        }
        if (ends==FIXED) particles[leng-1].y=height;      
        phase=0;
}

void setup() { 
  frameRate(60); 
  size(400,400,P3D);
  background(0);
  i=0;
  /*while (i<720){
    sinArray[i]=sin(PI/360)*100;
    i++;
  }*/
  setColours(mode);
  fill(0,leng,leng);
  noStroke();
  reset();
  draw();
} 

void setColours(int mode){

  if (mode==0){
    colorMode(HSB,leng);
    i=0;
    while (i<leng){
      colours[i]=color(i,0,leng);
      i++;
    }   
  }
  if (mode==1){
    colorMode(HSB,leng);
    i=0;
    while (i<leng){
      colours[i]=color(i,leng/2,leng);
      i++;
    }   
  }
  if (mode==2){
    colorMode(HSB,leng);
    i=0;
    while (i<leng){
      colours[i]=color(i,leng,leng);
      i++;
    }   
  }    
}

void keyPressed(){
    if (key=='d') drawStyle=(drawStyle+1)%3;
    if (key=='c') circular=!circular;
    if (key=='e') ends=(ends+1)%2;
    if (key=='v') view=(view+1)%3;
    if (key=='p') setColours((mode++)%3);   
    if (key=='f') frameBlending=!frameBlending;   
    if (key=='w') frequencyWandering=!frequencyWandering;   
    if (keyCode==' ') reset();
    if (key=='q' && damping<0.83) damping*=1.2;
    if (key=='a') damping/=1.2;
    if (key=='m') repeats+=1;
    if (key=='n' && repeats>1) repeats-=1;
    if (key=='-'||key=='_') { dolly-=8; background (0); }
    if (key=='='||key=='+') { dolly+=8; background (0); }
}

void mousePressed() { 
  xOld=mouseX;
  yOld=mouseY;
}

void mouseDragged() {
  rootFrequency+=0.001*(mouseX-xOld);
  xRot-=turnRate*(mouseY-yOld);
  xOld=mouseX;
  yOld=mouseY;
}