boolean init;

void setup() {
  size(400,400,P3D); 
  //smooth();
  init=true;
}

float lastMS=0;

void draw() {
  if (init) { init=false;
    initBush(); mousevec=new Mousevec();
  }
  
  background(166,124,81);
  if (mouseX!=0||mouseY!=0) { mousevec.update(); }
  updateBush();
//  println(1000/(millis()-lastMS));
//  saveFrame("g:/!temp/hairfield6_####.tga");
  lastMS=millis();
}

void keyPressed() {
  if (key==' ') {init=true;}
}

////////////////////////////// Mousevec class //////////////////////////////

Mousevec mousevec;

class Mousevec {
  float deg=0, len=0;
  int col=0, row=0;
  Mousevec() {}
  void update() {
    float mx=mouseX, my=mouseY, pmx=pmouseX, pmy=pmouseY;
    float dx=mx-pmx, dy=my-pmy;
    len=sqrt(sq(dx)+sq(dy));
    if (mx!=pmx&&my!=pmy) { deg=atan2(dy,dx); }
    col=widthToCol(mouseX); row=heightToRow(mouseY);
  }
}

////////////////////////////// end Mousevec //////////////////////////////




////////////////////////////////////////////////////////////////////////
////////////////////////////// Bush class //////////////////////////////

int nr_col=100, nr_row=100, nr_bush;  // number of rows/columns
float colWid, rowHei;                 // column width/row height
float baseLen=10, randLen=10;         // basic bush length plus random length
int nrHairPerBush=5;
float randDir=radians(45);
int range=8; float maxD=sqrt(2)*8;    // range rows/cols for mouse
Bush[] bush; 

void initBush() {
  nr_bush=nr_col*nr_row;
  colWid=width/(float)nr_col; rowHei=height/(float)nr_row;
  bush=new Bush[nr_bush];
  for (int x=0;x<nr_col;x++) { for (int y=0;y<nr_row;y++) {
    int i=y*nr_col+x;
    float p=noise(20*x/(float)nr_col,10*y/(float)nr_row,millis()*0.01);
    bush[i]=new Bush(x,y,(p<0.5));
  } }
}

void updateBush() {
  // set distance Bush to mouse = "no mouse"
  for (int i=0;i<nr_bush;i++) { bush[i].mouseDistance=-1; }
  
  // set distance Bush to mouse if mouse within range:
  int x1=mousevec.col-range; if (x1<0) {x1=0;}  int x2=mousevec.col+range; if (x2>=nr_col) {x2=nr_col-1;}
  int y1=mousevec.row-range; if (y1<0) {y1=0;}  int y2=mousevec.row+range; if (y2>=nr_row) {y2=nr_row-1;}
  for (int x=x1;x<=x2;x++) { for (int y=y1;y<=y2;y++) { int i=y*nr_col+x;
      bush[i].mouseDistance=10+100*sqrt(sq(x-mousevec.col)+sq(y-mousevec.row))/maxD;
  } }

  // update Bushes:
  for (int i=0;i<nr_bush;i++) { 
    bush[i].rotateLikeNeighbour();
    if (bush[i].mouseDistance!=-1) { bush[i].rotateToMouse(); }
    bush[i].setNewRotation();
    bush[i].drawMe(); 
  } 
}

class Bush {
  boolean white; color c;
  
  int col, row;
  float x, y;
  float len, lenMin=8, lenMax=20;
  float dir, rot;  
  Hair[] hair; int nrHair;
  float mouseDistance=-1;
  
  
  Bush(int col, int row, boolean white) {
    this.col=col; this.row=row;
    x=colToWidth(col)+random(-colWid/2.0,colWid/2.0); y=rowToHeight(row)+random(-rowHei/2.0,rowHei/2.0);
    this.white=white;
    if (white) { c=color(255,255,255); } else { c=color(0,0,0); }
    len=baseLen+random(randLen);
    dir=TWO_PI*noise(col*0.02,row*0.02)*noise(col*0.2,row*0.2)-PI; rot=0;
    
    nrHair=nrHairPerBush; hair=new Hair[nrHair];
    for (int i=0;i<nrHair;i++) {
      float xo=random(-colWid/2.0,colWid/2.0);
      float yo=random(-rowHei/2.0,rowHei/2.0);
      float p=random(1); color hc;
      if (p<0.9) {
        hc=c;
      } else {
        hc=invert(c);
      }
      hair[i]=new Hair(x+xo,y+yo,baseLen+random(randLen),random(-randDir/2.0,randDir/2.0),hc);
    }
  }
  
  void rotateLikeNeighbour() {
    int x1=col-1; if (x1<0) {x1=0;}
    int x2=col+1; if (x2>=nr_col) {x2=nr_col-1;}
    int y1=row-1; if (y1<0) {y1=0;}
    int y2=row+1; if (y2>=nr_row) {y2=nr_row-1;}
    for (int x=x1;x<=x2;x++) { for (int y=y1;y<=y2;y++) {
      if (!(x==0&&y==0)) {
        int i=y*nr_col+x;
        rot+=0.01*(getTurnDirection(dir,bush[i].dir));
      }
    } }
  }
  
  void rotateToMouse() {
    rot+=0.9*(getTurnDirection(dir,mousevec.deg)/mouseDistance); 
  }
  
  void setNewRotation() {
    rot*=0.95;
    dir+=rot; 
    while (dir>PI) {dir-=TWO_PI;} while (dir<-PI) {dir+=TWO_PI;}
  }
  
  void drawMe() { 
    dirLine(x,y,len,dir,c);
    for (int i=0;i<nrHair;i++) {
      hair[i].toScreen(dir);
    }
  }
}
////////////////////////////// end Bush class //////////////////////////////
////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////
////////////////////////////// Hair class //////////////////////////////////

class Hair {
  color c;
  float x,y,len,dir;
  Hair() { x=0; y=0; len=0; dir=0; c=color(0,0,0);}
  Hair(float _x, float _y, float _len, float _dir, color _c) { x=_x; y=_y; len=_len; dir=_dir; c=_c; }
  void toScreen(float rd) {
    dirLine(x,y,len,dir+rd,c);
  }
}

////////////////////////////// end Hair class //////////////////////////////
////////////////////////////////////////////////////////////////////////////


color invert(color c) {
  colorMode(RGB,255);
  return color(255-red(c),255-green(c),255-blue(c));
}

// columns to x position and vice versa
float colToWidth(float c) { return width*(c+0.5)/(float)nr_col; }
int widthToCol(float x) { return int((x/(float)width)*nr_col-0.5); }
// rows to y position and vice versa
float rowToHeight(float r) { return height*(r+0.5)/(float)nr_row; }
int heightToRow(float y) { return int((y/(float)height)*nr_row-0.5); }

// calculate shortest degree from deg1 to deg2
float getTurnDirection(float deg1, float deg2) {
  float rdeg=(deg1>deg2)?deg2-(deg1-TWO_PI):deg2-deg1;
  if (rdeg<PI) { return rdeg; } else { return (rdeg-TWO_PI); }
}

void dirLine(float x1, float y1, float len, float dir, color c) {
  float COS=cos(dir), SIN=sin(dir);
  
//  stroke(c);
//  line(x1,y1,x1+len*COS,y1+len*SIN);
  
  for (float r=0;r<=len;r+=1.5) {
    float x=x1+r*COS, y=y1+r*SIN;
    softSet(int(x),int(y),c,0.3);
  }
  
}


void softSet(int x, int y, int c1, float p1) {
  float p2=1.0-p1; int c2=get(x,y);
  int r=int((c1>>16&255)*p1 + (c2>>16&255)*p2);
  int g=int((c1>>8&255)*p1 + (c2>>8&255)*p2);
  int b=int((c1&255)*p1 + (c2&255)*p2);
  set(x,y,(r<<16|g<<8|b));
}