// Hairfield 7

/*

  [SHIFT]-[A] anti-aliasing on/off
  [SHIFT]-[B] bugs visible on/off
  [SHIFT]-[B] toggle bugs visibility
  [SHIFT]-[H] toggle hair visibility
  
  [Q] randomize hair direction
  [SHIFT]-[Q] randomize hair sliders
  [W] randomize bug position
  [SHIFT]-[W] randomize bug sliders
  [E] randomize everything
  [SHIFT]-[E] randomize everything & clear

  [R] clear screen
  
*/

int MOUSE_INFLUENCE_RADIUS = 4;
float MOUSE_INFLUENCE_STRENGTH = 12.0;

Hair[][] hair;
Vector bugs;
SliderGroup sliders, slidersTop;

boolean HAIR_VISIBLE;
boolean BUGS_VISIBLE;
boolean SIMULATION_IS_RUNNING;
boolean SHIFT_IS_PRESSED = false;
boolean CONTROL_IS_PRESSED = false;
boolean ALT_IS_PRESSED = false;


int BACKGROUND = 0xFFFFFF;

QImage drawImage;

String SLIDER_NAME_ANTIALIASING = "Anti-aliasing";
KeyBinding KEY_TOGGLE_ANTI_ALIASING = new KeyBinding(KeyBinding.SPECIALKEY_SHIFT,'a',"Toggle anti-aliasing");

String SLIDER_NAME_CHANNEL_DEPTH = "Channel Depth";
KeyBinding KEY_TOGGLE_CHANNEL_DEPTH = new KeyBinding(KeyBinding.SPECIALKEY_SHIFT,'c',"Toggle channel depth");

String SLIDER_NAME_BUG_VISIBILITY = "Bugs visible";
KeyBinding KEY_TOGGLE_BUG_VISIBILITY = new KeyBinding(KeyBinding.SPECIALKEY_SHIFT,'b',"Toggle bugs visibility");

String SLIDER_NAME_HAIR_VISIBILITY = "Hair visible";
KeyBinding KEY_TOGGLE_HAIR_VISIBILITY = new KeyBinding(KeyBinding.SPECIALKEY_SHIFT,'h',"Toggle hair visibility");

String SLIDER_NAME_TOGGLE_SIMULATION = "Simulation";
KeyBinding KEY_TOGGLE_SIMULATION_RUNNING = new KeyBinding(KeyBinding.SPECIALKEY_SHIFT,'s',"Toggle simulation running");

String SLIDER_NAME_HAIR_DENSITY = "Hair density";
String SLIDER_NAME_HAIR_ALIGNMENT = "Hair alignment";
String SLIDER_NAME_HAIR_LENGTH = "Hair->Bug influence";

String SLIDER_NAME_BUG_AMOUNT = "Bug amount";
String SLIDER_NAME_BUG_DRAG = "Bug drag";
String SLIDER_NAME_BUG_PRESSURE = "Bug pressure";


KeyBinding KEY_RANDOMIZE_HAIR_DIRECTIONS = new KeyBinding('q',"Randomize hair directions");
KeyBinding KEY_RANDOMIZE_HAIR_SLIDERS = new KeyBinding(KeyBinding.SPECIALKEY_SHIFT,'q',"Randomize hair settings");

KeyBinding KEY_RANDOMIZE_BUG_POSITIONS = new KeyBinding('w',"Randomize bug positions");
KeyBinding KEY_RANDOMIZE_BUG_SLIDERS = new KeyBinding(KeyBinding.SPECIALKEY_SHIFT,'w',"Randomize bug settings");

KeyBinding KEY_RANDOMIZE_EVERYTHING = new KeyBinding('e',"Randomize everything");
KeyBinding KEY_RANDOMIZE_EVERYTHING_AND_CLEAR = new KeyBinding(KeyBinding.SPECIALKEY_SHIFT,'e',"Randomize everything & clear");

KeyBinding KEY_CLEAR_SCREEN = new KeyBinding('r',"Clear drawing screen");

Vector KEY_COMMANDS;






/*
*
*
*  VOID SETUP
*  initialisation of all variables and stuff
*
*
*/





void setup() {
  size(800,570,P3D);

  drawImage = new QImage(800,450);
  drawImage.setChannelDepth(QImage.CHANNEL_DEPTH_16BIT);
  drawImage.background(BACKGROUND);
  
  KEY_COMMANDS = new Vector();
  KEY_COMMANDS.add(KEY_RANDOMIZE_HAIR_DIRECTIONS);
  KEY_COMMANDS.add(KEY_RANDOMIZE_HAIR_SLIDERS);
  KEY_COMMANDS.add(KEY_RANDOMIZE_BUG_POSITIONS);
  KEY_COMMANDS.add(KEY_RANDOMIZE_BUG_SLIDERS);
  KEY_COMMANDS.add(KEY_RANDOMIZE_EVERYTHING);
  KEY_COMMANDS.add(KEY_RANDOMIZE_EVERYTHING_AND_CLEAR);
  KEY_COMMANDS.add(KEY_CLEAR_SCREEN);
  
  HAIR_VISIBLE = false;
  BUGS_VISIBLE = false;
  SIMULATION_IS_RUNNING = true;
  
  // SETUP SLIDERS
  
  Slider s;
  
  slidersTop = new SliderGroup();
  
  s = new Slider(10,10,22,0,1,1,Slider.ORIENTATION_HORIZONTAL,SLIDER_NAME_ANTIALIASING);
  s.setNumberMode(Slider.NUMBER_MODE_BOOLEAN);
  s.addPreName(KEY_TOGGLE_ANTI_ALIASING.toCommand());
  slidersTop.add(s);
  
  s = new Slider(10,25,22,0,1,1,Slider.ORIENTATION_HORIZONTAL,SLIDER_NAME_CHANNEL_DEPTH);
  s.setNumberMode(Slider.NUMBER_MODE_BOOLEAN);
  s.addPreName(KEY_TOGGLE_CHANNEL_DEPTH.toCommand());
  s.setBooleanStrings("8bit","16bit");
  slidersTop.add(s);
  
  s = new Slider(10,40,22,0,1,0,Slider.ORIENTATION_HORIZONTAL,SLIDER_NAME_BUG_VISIBILITY);
  s.setNumberMode(Slider.NUMBER_MODE_BOOLEAN);
  s.addPreName(KEY_TOGGLE_BUG_VISIBILITY.toCommand());
  slidersTop.add(s);
  
  s = new Slider(10,55,22,0,1,0,Slider.ORIENTATION_HORIZONTAL,SLIDER_NAME_HAIR_VISIBILITY);
  s.setNumberMode(Slider.NUMBER_MODE_BOOLEAN);
  s.addPreName(KEY_TOGGLE_HAIR_VISIBILITY.toCommand());
  slidersTop.add(s);
  
  s = new Slider(10,70,22,0,1,1,Slider.ORIENTATION_HORIZONTAL,SLIDER_NAME_TOGGLE_SIMULATION);
  s.setNumberMode(Slider.NUMBER_MODE_BOOLEAN);
  s.addPreName(KEY_TOGGLE_SIMULATION_RUNNING.toCommand());
  s.setBooleanStrings("stopped","running");
  slidersTop.add(s);
  
  slidersTop.createFrameFromSliders(220,0);
  slidersTop.move(270,450);
  
  
  
  
  sliders = new SliderGroup();
  
  s = new Slider(10,0,80,0.01,0.3,0.1,Slider.ORIENTATION_HORIZONTAL,SLIDER_NAME_HAIR_DENSITY);
  s.setStepSize(0.001);
  sliders.add(s);
  
  s = new Slider(10,15,80,-0.5,1.0,0.15,Slider.ORIENTATION_HORIZONTAL,SLIDER_NAME_HAIR_ALIGNMENT);
  s.setSlideMode(Slider.SLIDE_MODE_SQUARE_ROOT);
  s.setStepSize(0.005);
  sliders.add(s);
  
  s = new Slider(10,30,80,1,80,15,Slider.ORIENTATION_HORIZONTAL,SLIDER_NAME_HAIR_LENGTH);
  s.setStepSize(0.1);
  s.setDigits(2,1);
  sliders.add(s);
  
  s = new Slider(10,45,80,10,5000,1500,Slider.ORIENTATION_HORIZONTAL,SLIDER_NAME_BUG_AMOUNT);
  s.setNumberMode(Slider.NUMBER_MODE_INT);
  s.setStepSize(10);
  s.setDigits(4,0);
  sliders.add(s);
  
  s = new Slider(10,60,80,0.5,0.990,0.98,Slider.ORIENTATION_HORIZONTAL,SLIDER_NAME_BUG_DRAG);
  s.setStepSize(0.002);
  s.setDigits(1,3);
  sliders.add(s);
  
  s = new Slider(10,75,80,0,0.5,0.1,Slider.ORIENTATION_HORIZONTAL,SLIDER_NAME_BUG_PRESSURE);
  s.setDigits(0,3);
  s.setStepSize(0.01);
  sliders.add(s);
  
  sliders.createFrameFromSliders(170,0);
  sliders.move(0,460);
  
  // SETUP HAIR
  makeHairFromSliders();

  // SETUP BUGS
  bugs = new Vector();
  makeBugsFromSliders(int(sliders.getValueOfSlider(SLIDER_NAME_BUG_AMOUNT)));
}






/*
*
*
*  VOID DRAW
*
*
*/






void draw() {
  
  background(128,128,128);

  for (int i=0;i<slidersTop.size();i++) ((Slider)slidersTop.elementAt(i)).update();
  for (int i=0;i<sliders.size();i++) ((Slider)sliders.elementAt(i)).update();

  if (slidersTop.hasChanged(SLIDER_NAME_ANTIALIASING)) {
    boolean aa = slidersTop.getBooleanOfSlider(SLIDER_NAME_ANTIALIASING);
    for (int i=0;i<bugs.size();i++) ((Bug)bugs.elementAt(i)).setDotMode(aa?Bug.DOT_MODE_ANTIALIASED:Bug.DOT_MODE_NORMAL);
  }
  
  if (slidersTop.hasChanged(SLIDER_NAME_CHANNEL_DEPTH)) {
    boolean b = slidersTop.getBooleanOfSlider(SLIDER_NAME_CHANNEL_DEPTH);
    drawImage.setChannelDepth(!b?QImage.CHANNEL_DEPTH_8BIT:QImage.CHANNEL_DEPTH_16BIT);
  }
  
  if (slidersTop.hasChanged(SLIDER_NAME_BUG_VISIBILITY)) {
    boolean b = slidersTop.getBooleanOfSlider(SLIDER_NAME_BUG_VISIBILITY);
    BUGS_VISIBLE = b;
  }
  
  if (slidersTop.hasChanged(SLIDER_NAME_HAIR_VISIBILITY)) {
    boolean b = slidersTop.getBooleanOfSlider(SLIDER_NAME_HAIR_VISIBILITY);
    HAIR_VISIBLE = b;
  }
  
  if (slidersTop.hasChanged(SLIDER_NAME_TOGGLE_SIMULATION)) {
    boolean b = slidersTop.getBooleanOfSlider(SLIDER_NAME_TOGGLE_SIMULATION);
    SIMULATION_IS_RUNNING = b;
  }

  
  
  
  if (sliders.hasChanged(SLIDER_NAME_HAIR_DENSITY)) {
    makeHairFromSliders(hair);
    for (int i=0;i<bugs.size();i++) ((Bug)bugs.elementAt(i)).updateHair(hair);
  }

  if (sliders.hasChanged(SLIDER_NAME_HAIR_ALIGNMENT)) {
    float v = sliders.getValueOfSlider(SLIDER_NAME_HAIR_ALIGNMENT);
    for (int xi=0;xi<hair.length;xi++) for (int yi=0;yi<hair[0].length;yi++) hair[xi][yi].setAlignment(v);
  }

  if (sliders.hasChanged(SLIDER_NAME_HAIR_LENGTH)) {
    float v = sliders.getValueOfSlider(SLIDER_NAME_HAIR_LENGTH);
    for (int xi=0;xi<hair.length;xi++) for (int yi=0;yi<hair[0].length;yi++) hair[xi][yi].setLength(v);
  }

  if (sliders.hasChanged(SLIDER_NAME_BUG_AMOUNT)) {
    int nFut = int(sliders.getValueOfSlider(SLIDER_NAME_BUG_AMOUNT));
    int nNow = bugs.size();
    if (nFut<nNow) {
      for (int i=nFut;i<nNow;i++) bugs.remove(bugs.size()-1);
    } 
    else if (nFut>nNow) {
      makeBugsFromSliders(nFut-nNow);
    }
  }

  if (sliders.hasChanged(SLIDER_NAME_BUG_PRESSURE)) {
    float p = sliders.getValueOfSlider(SLIDER_NAME_BUG_PRESSURE);
    for (int i=0;i<bugs.size();i++) ((Bug)bugs.elementAt(i)).setPressure(p);
  }

  if (sliders.hasChanged(SLIDER_NAME_BUG_DRAG)) {
    float d = sliders.getValueOfSlider(SLIDER_NAME_BUG_DRAG);
    for (int i=0;i<bugs.size();i++) ((Bug)bugs.elementAt(i)).setDrag(d);
  }




  // MAKE NEW HAIR DIRECTION FROM NEIGHBOURS:
  for (int xi=0;xi<hair.length;xi++) for (int yi=0;yi<hair[0].length;yi++) hair[xi][yi].makeNewDirection(hair);



  // MODIFY NEW HAIR DIRECTION FROM MOUSE:
  if (mousePressed&&!sliders.isManipulated()&&!slidersTop.isManipulated()) {
    float mouseSpeed = sqrt(sq(pmouseX-mouseX)+sq(pmouseY-mouseY));
    for (int xo=-MOUSE_INFLUENCE_RADIUS;xo<=MOUSE_INFLUENCE_RADIUS;xo++) for (int yo=-MOUSE_INFLUENCE_RADIUS;yo<=MOUSE_INFLUENCE_RADIUS;yo++) {
      float distMouse = sqrt(sq(xo)+sq(yo)) / (float) (sqrt(2)*MOUSE_INFLUENCE_RADIUS);  // 0..1
      float stren = (0.1 + 0.9*(1-distMouse)) * MOUSE_INFLUENCE_STRENGTH;
      if (mouseSpeed!=0) stren/=mouseSpeed;
      int ix = xo+int(hair.length*mouseX/(float)drawImage.width);
      int iy = yo+int(hair[0].length*mouseY/(float)drawImage.height);
      if (ix>=0&&ix<hair.length&&iy>=0&&iy<hair[0].length) hair[ix][iy].addNewDir(mouseX-pmouseX,mouseY-pmouseY,stren);
    }
  }

  
  if (SIMULATION_IS_RUNNING) {

    // UPDATE NEW HAIR DIRECTION
    for (int xi=0;xi<hair.length;xi++) for (int yi=0;yi<hair[0].length;yi++) hair[xi][yi].updateNewDirection();
  
    // UPDATE BUG POSITIONS
    for (int i=0;i<bugs.size();i++) ((Bug)bugs.elementAt(i)).update();
  
    // DRAW BUGS LINES
    for (int i=0;i<bugs.size();i++) ((Bug)bugs.elementAt(i)).drawOn(drawImage);
  
  }
  
  image(drawImage,0,0);
  
  if (HAIR_VISIBLE) for (int xi=0;xi<hair.length;xi++) for (int yi=0;yi<hair[0].length;yi++) hair[xi][yi].draw();
  if (BUGS_VISIBLE) for (int i=0;i<bugs.size();i++) ((Bug)bugs.elementAt(i)).show();  
  
  
  rectMode(CORNER);
  noStroke();
  fill(128,128,128);
  rect(0,450,width,580);
  
  slidersTop.draw();
  sliders.draw();
  
  fill(255,255,255);
  rect(537,457,255,123-15);
  fill(64,64,64);
  for (int i=0;i<KEY_COMMANDS.size();i++) {
    KeyBinding kb = (KeyBinding)KEY_COMMANDS.elementAt(i);
    text(kb.toCommand(),540,469+i*15);
    text(kb.getString(),610,469+i*15);
    
  }
  
}







/*
*
*
*  FEW INITIALISATION ROUTINES
*
*
*/







void makeBugsFromSliders(int amount) {
  float aa = slidersTop.getValueOfSlider(SLIDER_NAME_ANTIALIASING);//sliderAntialiased.getValue();
  float p = sliders.getValueOfSlider(SLIDER_NAME_BUG_PRESSURE);
  float v = sliders.getValueOfSlider(SLIDER_NAME_BUG_DRAG);
  for (int i=0;i<amount;i++) {
    Bug b = new Bug(hair,p,v,drawImage.width,drawImage.height);
    b.setDotMode(aa==0?Bug.DOT_MODE_NORMAL:Bug.DOT_MODE_ANTIALIASED);
    bugs.add(b);
  }
}



void makeHairFromSliders() {
  float dens = sliders.getValueOfSlider(SLIDER_NAME_HAIR_DENSITY);
  float alignment = sliders.getValueOfSlider(SLIDER_NAME_HAIR_ALIGNMENT);
  float hairlength = sliders.getValueOfSlider(SLIDER_NAME_HAIR_LENGTH);
  int amountX = 0;
  int amountY = 0;
  for (float x=0;x<drawImage.width;x+=1/dens) amountX++;
  for (float y=0;y<drawImage.height;y+=1/dens) amountY++;
  hair = new Hair[amountX][amountY];
  for (int xi=0;xi<amountX;xi++) {
    for (int yi=0;yi<amountY;yi++) {
      float x = xi/dens;
      float y = yi/dens;
      //x += random(-0.5,0.5)/dens;
      //y += random(-0.5,0.5)/dens;
      hair[xi][yi] = new Hair(x,y,xi,yi,alignment,hairlength);
    }
  }
}


void makeHairFromSliders(Hair[][] _oldhair) {
  Hair[][] oldhair = new Hair[_oldhair.length][_oldhair[0].length];
  for (int i=0;i<_oldhair.length;i++) for (int j=0;j<_oldhair[0].length;j++) oldhair[i][j] = _oldhair[i][j].clone();
  int oldAmountX = oldhair.length;
  int oldAmountY = oldhair[0].length;
  
  float dens = sliders.getValueOfSlider(SLIDER_NAME_HAIR_DENSITY);
  float alignment = sliders.getValueOfSlider(SLIDER_NAME_HAIR_ALIGNMENT);
  float hairlength = sliders.getValueOfSlider(SLIDER_NAME_HAIR_LENGTH);
  int amountX = 0;
  int amountY = 0;
  for (float x=0;x<drawImage.width;x+=1/dens) amountX++;
  for (float y=0;y<drawImage.height;y+=1/dens) amountY++;
  hair = new Hair[amountX][amountY];
  for (int xi=0;xi<amountX;xi++) {
    for (int yi=0;yi<amountY;yi++) {
      int xiOld = int(round(oldAmountX*xi/(float)amountX));
      int yiOld = int(round(oldAmountY*yi/(float)amountY));
      if (xiOld<0) xiOld=0;
      if (yiOld<0) yiOld=0;
      if (xiOld>=oldAmountX) xiOld=oldAmountX-1;
      if (yiOld>=oldAmountY) yiOld=oldAmountY-1;
      float x = xi/dens;
      float y = yi/dens;
      x += random(-0.5,0.5)/dens;
      y += random(-0.5,0.5)/dens;
      hair[xi][yi] = new Hair(x,y,x+oldhair[xiOld][yiOld].getDirX(),y+oldhair[xiOld][yiOld].getDirY(),xi,yi,alignment,hairlength);
    }
  }
}






/*
*
*
*  MOUSE AND KEYBOARD ROUTINES
*
*
*/







void keyPressed() {

  if (keyCode==SHIFT) SHIFT_IS_PRESSED = true;
  if (keyCode==CONTROL) CONTROL_IS_PRESSED = true;
  if (keyCode==ALT) ALT_IS_PRESSED = true;  

  int specialKey = (new KeyBinding(SHIFT_IS_PRESSED,CONTROL_IS_PRESSED,ALT_IS_PRESSED)).getSpecialKey();


  // TOGGLE ANTIALIASING:
  if (KEY_TOGGLE_ANTI_ALIASING.isPressed(specialKey,keyCode)) {
    int index = slidersTop.findIndexOfSliderNamed(SLIDER_NAME_ANTIALIASING);
    if (index!=-1) ((Slider)slidersTop.elementAt(index)).invertValue(); //slidersAntialiased.invertValue();
  }


  // TOGGLE CHANNEL DEPTH:
  if (KEY_TOGGLE_CHANNEL_DEPTH.isPressed(specialKey,keyCode)) {
    int index = slidersTop.findIndexOfSliderNamed(SLIDER_NAME_CHANNEL_DEPTH);
    if (index!=-1) ((Slider)slidersTop.elementAt(index)).invertValue();
  }


  // TOGGLE BUG VISIBILITY
  if (KEY_TOGGLE_BUG_VISIBILITY.isPressed(specialKey,keyCode)) {
    int index = slidersTop.findIndexOfSliderNamed(SLIDER_NAME_BUG_VISIBILITY);
    if (index!=-1) ((Slider)slidersTop.elementAt(index)).invertValue();
  }
  
  
  // TOGGLE HAIR VISIBILITY
  if (KEY_TOGGLE_HAIR_VISIBILITY.isPressed(specialKey,keyCode)) {
    int index = slidersTop.findIndexOfSliderNamed(SLIDER_NAME_HAIR_VISIBILITY);
    if (index!=-1) ((Slider)slidersTop.elementAt(index)).invertValue();
  }
  
  
  // TOGGLE SIMULATION RUNNIGN:
  if (KEY_TOGGLE_SIMULATION_RUNNING.isPressed(specialKey,keyCode)) {
    int index = slidersTop.findIndexOfSliderNamed(SLIDER_NAME_TOGGLE_SIMULATION);
    if (index!=-1) ((Slider)slidersTop.elementAt(index)).invertValue();
  }
  
  
  
  // CLEAR SCREEN
  if (KEY_CLEAR_SCREEN.isPressed(specialKey,keyCode)) drawImage.background(BACKGROUND);
  
  
  
  // RANDOMIZE BUG POSITIONS
  if (KEY_RANDOMIZE_BUG_POSITIONS.isPressed(specialKey,keyCode)) {
   for (int i=0;i<bugs.size();i++) ((Bug)bugs.elementAt(i)).randomizePosition();
  }
  
  // RANDOMIZE BUG SLIDERS:
  if (KEY_RANDOMIZE_BUG_SLIDERS.isPressed(specialKey,keyCode)) {  
    sliders.randomize(SLIDER_NAME_BUG_AMOUNT);
    sliders.randomize(SLIDER_NAME_BUG_PRESSURE);
    sliders.randomize(SLIDER_NAME_BUG_DRAG);
  }
  
    
  // RANDOMIZE HAIR DIRECTIONS
  if (KEY_RANDOMIZE_HAIR_DIRECTIONS.isPressed(specialKey,keyCode)) {
   for (int xi=0;xi<hair.length;xi++) for (int yi=0;yi<hair[0].length;yi++) hair[xi][yi].randomizeDirection();
  }
  
  
  // RANDOMIZE HAIR SLIDERS
  if (KEY_RANDOMIZE_HAIR_SLIDERS.isPressed(specialKey,keyCode)) {
    sliders.randomize(SLIDER_NAME_HAIR_DENSITY);
    sliders.randomize(SLIDER_NAME_HAIR_ALIGNMENT);
    sliders.randomize(SLIDER_NAME_HAIR_LENGTH);
  }
  
  
  if (KEY_RANDOMIZE_EVERYTHING.isPressed(specialKey,keyCode)) {
    sliders.randomizeAll();
    for (int i=0;i<bugs.size();i++) ((Bug)bugs.elementAt(i)).randomizePosition();
    for (int xi=0;xi<hair.length;xi++) for (int yi=0;yi<hair[0].length;yi++) hair[xi][yi].randomizeDirection();
  }
  
  if (KEY_RANDOMIZE_EVERYTHING_AND_CLEAR.isPressed(specialKey,keyCode)) {
    sliders.randomizeAll();
    for (int i=0;i<bugs.size();i++) ((Bug)bugs.elementAt(i)).randomizePosition();
    for (int xi=0;xi<hair.length;xi++) for (int yi=0;yi<hair[0].length;yi++) hair[xi][yi].randomizeDirection();
    drawImage.background(BACKGROUND);
  }
  
}

void keyReleased() {
  if (keyCode==SHIFT) SHIFT_IS_PRESSED = false;
  if (keyCode==CONTROL) CONTROL_IS_PRESSED = false;
  if (keyCode==ALT) ALT_IS_PRESSED = false;
}


void mousePressed() {
  sliders.startManipulation();
  slidersTop.startManipulation();
}
void mouseReleased() {
  sliders.stopManipulation();
  slidersTop.stopManipulation();
}