// UdK Computational design
// Marius Watz 2003
// http://www.evolutionzone.com/udk/
//
// UDK04_01_weeds
//
// A simulation of weeds moving in the wind.
// Uses the Vec2D library and demonstrates how to dynamically change
// a force, in this case wind.
//
// Note that the use of Vec2D objects to represent the wind is actually
// redundant since we don't use the y values...

Weed weeds[];
int num;
int reduceWindCnt;
float maxWindChange,maxWind;
Vec2D wind,windD,userWind,userWindD;
Vec2D mouseStart;

void setup() {
  size(400,400);
  background(255,255,255);

  num=75;
  weeds=new Weed[num];
  for(int i=0; i<num; i++) 
    weeds[i]=new Weed(((float)width/(float)num)*i+random(-5,5));
    
  userWind=new Vec2D(0,0);
  userWindD=new Vec2D();
  wind=new Vec2D(0,0);
  windD=new Vec2D(0,0);
  maxWindChange=2;
  maxWind=100;
  
  mouseStart=new Vec2D();
  ellipseMode(CENTER_DIAMETER);
}

void loop() {
  background(255,255,255);
  
  if(!mousePressed && reduceWindCnt>0) {
    userWind.add(userWindD);
    reduceWindCnt--;
  }
  
  windD.add(random(-0.5,0.5),0);
  if(windD.x<-maxWindChange) windD.x=-maxWindChange;
  else if(windD.x>maxWindChange) windD.x=maxWindChange;  
  if(wind.x>maxWind) windD.x-=0.1;
  else if(wind.x<-maxWind) windD.x+=0.1;
  wind.x+=windD.x;
  
  for(int i=0; i<num; i++) weeds[i].drawWeed();
}

void mousePressed() {
  mouseStart.set(mouseX,mouseY);
}

void mouseDragged() {
  userWind.set(mouseX,mouseY);
  userWind.sub(mouseStart);
}

void mouseReleased() {
  // Initialise countdown to reduce the user's wind input
  reduceWindCnt=60;
  userWindD.set(-userWind.x,-userWind.y);
  userWindD.div(reduceWindCnt);
}


class Weed {
  float D;
  float h;
  float bend,bendMod;
  float x;
  int vnum;
  Vec2D v[];
  
  Weed(float _x) {
    x=_x;
    if(x<0) x=0;
    else if(x>width) x=width;
    
    h=random(175,250);
    bend=random(-20,20);
    bendMod=1+random(-0.5,2.5);
    
    vnum=20;
    v=new Vec2D[vnum];
    for(int i=0; i<vnum; i++) v[i]=new Vec2D(); 
    
    D=(1/(float)(vnum-1));
  }

  void drawWeed() {
    bend=(-(wind.x+userWind.x)/20)*bendMod;
    for(int i=0; i<vnum; i++) {
      v[i].set(0,h*D*(float)i);
      v[i].rotate(radians((bend*D*(float)i)));
      v[i].add(x,0);
    }
    
    noFill();
    stroke(0,200,0);
    for(int i=0; i<vnum-1; i++) 
      line(v[i].x,height-v[i].y, v[i+1].x,height-v[i+1].y);
      
    noStroke();
    for(int i=0; i<vnum; i++) {
      fill(255*D*(float)i,150+100*D*(float)i,0);    
      ellipse(v[i].x,height-v[i].y, 18-13*D*(float)i,18-13*D*(float)i);
    }
  }
}



// General vector class for 2D vectors
class Vec2D {
  float x,y;

// Constructor with no parameters
  Vec2D() {
    x=0;
    y=0;
  }
  
  Vec2D(float _x,float _y) {
    x=_x;
    y=_y;
  }

  Vec2D(Vec2D v) {
    x=v.x;
    y=v.y;
  }

  void set(float _x,float _y) {
    x=_x;
    y=_y;
  }

  void set(Vec2D v) {
    x=v.x;
    y=v.y;
  }

  void add(float _x,float _y) {
    x+=_x;
    y+=_y;
  }

  void add(Vec2D v) {
    x+=v.x;
    y+=v.y;
  }

  void sub(float _x,float _y) {
    x-=_x;
    y-=_y;
  }

  void sub(Vec2D v) {
    x-=v.x;
    y-=v.y;
  }

  void mult(float m) {
    x*=m;
    y*=m;
  }

  void div(float m) {
    x/=m;
    y/=m;
  }

  float length() {
    return sqrt(x*x+y*y);
  }

  float angle() {
    return atan2(y,x);
  }

  void normalise() {
    float l=length();
    if(l!=0) {
      x/=l;
      y/=l;
    }
  }

  Vec2D tangent() {
    return new Vec2D(-y,x);
  }

  void rotate(float val) {
    // Due to float not being precise enough, double is used for the calculations
    double cosval=Math.cos(val);
    double sinval=Math.sin(val);
    double tmpx=x*cosval - y*sinval;
    double tmpy=x*sinval + y*cosval;

    x=(float)tmpx;
    y=(float)tmpy;
  }
}