// soni(a)c hair
// strang based soundreactive particle systems
// author: info@toxi.co.uk

// requires SONIA v2.4 or later by mr.amit pitaru
// http://pitaru.com/sonia/

Hair[] h;
int hCount=0;
float XSPREAD=8;
float YSPREAD=200;
float HAIR_MOVEMENT=0.15;
float w2,h2;

// audio input sensitivity threshold
float sensThresh=0.15;
float prevLevel;

void setup() {
  size(200,323);
  w2=width*0.5;
  h2=height*0.5;
  ellipseMode(CENTER_DIAMETER);
  rectMode(CORNERS);
  h=new Hair[800];
  liveInput.start(512);
}

void loop() {
  background(220,208,192);
  // compute input level derivative (delta level to previous frame)
  // hair will only react if the input volume is changing rapidly,
  // based on the delta level and the sensitivity threshold
  // if input volume is clipping (too loud) the delta will be reduced
  // and might not reach threshold even though the audio signal is very strong
  // in this case please reduce input gain via the system control panel 
  float currLevel = float(liveInput.getLevel(0)+liveInput.getLevel(1));
  float deltaLevel=currLevel-prevLevel;
  // show current input and delta level
  stroke(160,148,132);
  line(1,height,1,height-deltaLevel*height);
  line(3,height,3,height-currLevel*h2);
  prevLevel=currLevel;
  // switch to 3d mode
  translate(w2,h2,0);
  if (hCount<h.length) {
    // new random position
    float newy=random(-1,1)*YSPREAD;
    float newx=random(-1,1)*XSPREAD*((YSPREAD-abs(newy))/YSPREAD);
    // always grow along positive Z, but randomized XY
    float nx=random(-1,1);
    float ny=random(-1,1);
    float nz=1;
    // varying length
    float l=random(5,10);
    // grow another hair strain/bundle
    for(int i=0; i<5; i++) {
      h[hCount++]=new Hair(newx+random(-2,2),newy+random(-2,2),0,nx,ny,nz,l);
    }
  }
  // if sound impulse strong enough, thrust hair towards top of screen
  if (deltaLevel>sensThresh) {
    for(int i=0; i<hCount; i++) {
      h[i].update(random(-1,1)*5,-currLevel,0.01);
      h[i].draw();
    }
  } else if (mousePressed) {
    // if clicked, align hair towards mouse position
    float wx,wy;
    wx=-(float)(w2-mouseX)/w2;
    wy=-(float)(h2-mouseY)/h2;
    for(int i=0; i<hCount; i++) {
      h[i].update(random(wx-HAIR_MOVEMENT*2,wx+HAIR_MOVEMENT*2),random(wy-HAIR_MOVEMENT*2,wy+HAIR_MOVEMENT*2),0.01);
      h[i].draw();
    }
    // ...or randomly disperse if idle
  } else {
    for(int i=0; i<hCount; i++) {
      h[i].update(random(-1,1)*HAIR_MOVEMENT,random(-1,1)*HAIR_MOVEMENT,0.05);
      h[i].draw();
    }
  }
}

// strang based particle system class

class Hair {
  // vertex list arrays
  float[] vx, vy, vz;
  // current directional vector
  float nx, ny, nz;
  // segment length params
  float seg_len, max_len, grow_speed;
  // base colour and shift
  float baseR, baseG, baseB, shiftR, shiftG, shiftB;
  // responsiveness to directional changes
  float smoothness,straightness;
  // curl parameters
  float curlR,curlAngle,curlStrength;
  int nVert;
  // number of particles in the system
  int maxSegments=15;

  Hair(float x,float y, float z, float nvx, float nvy, float nvz, float len) {
    vx=new float[maxSegments];
    vy=new float[maxSegments];
    vz=new float[maxSegments];
    nx=nvx; ny=nvy; nz=nvz;
    max_len=len;
    seg_len=1;
    // randomize basic looks/behaviour
    grow_speed=random(0.008,0.015);
    smoothness=random(0.75,0.85)+0.05;
    straightness=random(0.88,0.94)+0.02;
    // curl radius and rotation speed
    curlR=random(2);
    curlStrength=random(0.05,0.3)*20;
    // set base colour
    // 25% chance for gray hair
    if (random(1)>0.75) {
      baseR=baseG=baseB=random(40,80);
      shiftR=shiftG=shiftB=random(4,10);
    } else {
      baseR=random(60,88);
      baseG=baseR*0.5;
      baseB=0;
      shiftR=random(4,10);
      shiftG=shiftR*0.5;
      shiftB=0.5;
    }
    // build initial segments
    nVert=0;
    addSegment(x,y,z);
    while(nVert<maxSegments) {
      // change direction randomly
      nx+=random(-1,1); ny+=random(-1,1); nz+=random(-1,1);
      // normalize vector
      float d=sqrt(nx*nx+ny*ny+nz*nz);
      if (d>0) {
        d=1/d; nx*=d; ny*=d; nz*=d;
      }
      // add to vertex list
      addSegment(x+=seg_len*nx,y+=seg_len*ny,z+=seg_len*nz);
    }
  }

  void addSegment(float x,float y, float z) {
    vx[nVert]=x; vy[nVert]=y; vz[nVert++]=z;
  }

  // align hair to new direction vector
  // applies smoothness, curling and gravity

  void update(float nnx,float nny, float nnz) {
    // increase hair length
    seg_len+=(max_len-seg_len)*grow_speed;
    // add new direction to existing vector
    nx+=nnx; ny+=nny; nz+=nnz;
    // normalize new vector
    float d=sqrt(nx*nx+ny*ny+nz*nz);
    if (d>0) d=(1/d)*seg_len;
    nx*=d; ny*=d; nz*=d;
    // iterate and update all vertices with decreasing effect
    float sm=smoothness*(seg_len/max_len);
    float grav=0;
    curlAngle=0;
    for(int i=1; i<nVert; i++) {
      vx[i]+=(vx[i-1]+nx-vx[i])*sm+curlR*cos(curlAngle);
      vy[i]+=(vy[i-1]+ny-vy[i])*sm+grav;
      vz[i]+=(vz[i-1]+nz-vz[i])*sm+curlR*sin(curlAngle);
      sm*=straightness;
      grav+=0.15;
      curlAngle+=curlStrength;
    }
  }

  // draw the entire strang
  void draw() {
    float r=baseR,g=baseG,b=baseB;
    float alpha_decay=(seg_len/max_len)*8;
    // mark the hair root
    fill(128,0,0,20);
    noStroke();
    ellipse(vx[0],vy[0],5,5);
    beginShape(LINE_STRIP);
    for(int i=0; i<nVert; i++) {
      stroke(r,g,b,(nVert-i-1)*alpha_decay);
      vertex(vx[i],vy[i],vz[i]);
      r+=shiftR;
      g+=shiftG;
      b+=shiftB;
    }
    endShape();
  }
}