// SteelWool01
// David Bollinger
// http://www.davebollinger.com
// for Processing 0109 Beta
/**
Click to advance to next pattern.<br>
*/

FixedPointBuffer buf;
Attractor attractor;
ParticleTrail [] trails;
int currentseed = 0;

int nframes;
int ntrails = 3;
int partiespertrail = 100;
int itersperframe = 10;
int framestillnext = 500;

void setup() {
  size(480,480,P3D);
  buf = new FixedPointBuffer(width,height);
  attractor = new Attractor();
  trails = new ParticleTrail[ntrails];
  for (int i=0; i<ntrails; i++)
    trails[i] = new ParticleTrail(partiespertrail);
  next();
}

void draw() {  
  for (int i=0; i<itersperframe; i++) {
    attractor.move();
    for (int j=0; j<ntrails; j++) {
      trails[j].move(attractor);
      trails[j].draw();
    }
  }
  buf.render();
  if (++nframes > framestillnext)
    next();
}

void next() {
  randomSeed(currentseed++);
  attractor.make();
  for (int i=0; i<ntrails; i++)
    trails[i].make();
  buf.background(0,0,0);
  nframes = 0;
}

void mousePressed() {
  next();
}

float rand1() {
  return random(-1.0,1.0);
}
  
// attractor definition class
class Attractor {
  int ncoefs = 9;
  float [] coefs;
  float [] thetas;
  float [] deltas;
  Attractor() {
    coefs = new float[ncoefs];
    thetas = new float[ncoefs];
    deltas = new float[ncoefs];
    make();
  }
  void make() {
    for (int i=0; i<ncoefs; i++) {
      thetas[i] = random(-PI,PI);
      deltas[i] = rand1() * 0.01;
      coefs[i] = sin(thetas[i]);
    }
  }
  void move() {
    for (int i=0; i<ncoefs; i++) {
      coefs[i] = sin(thetas[i]);
      thetas[i] += deltas[i];
    }
  }
}

// particle class
class Particle {
  float [] pos = new float[3];
  float [] vel = new float[3];
  Particle() {
    make();
  }
  void make() {
    for (int i=0; i<3; i++) {
      pos[i] = rand1();
      vel[i] = rand1();
    }
  }
  void move(Attractor a) {
    float [] newpos = new float[3];
    for (int i=0; i<3; i++)
      newpos[i] = ( sin(pos[0] * a.coefs[i*3+0]) + sin(pos[1] * a.coefs[i*3+1]) + sin(pos[2] * a.coefs[i*3+2]) + vel[i] ) * 0.5;
    for (int i=0; i<3; i++)
      pos[i] = newpos[i];
  }
  void draw() {
    float sx = (width/2) + pos[0] * (width/2);
    float sy = (height/2) + pos[1] * (height/2);
    buf.add(sx,sy);
  }
}

// many particles class
class ParticleTrail {
  int nparticles;
  Particle [] particles;
  int r,g,b;
  ParticleTrail(int n) {
    nparticles = n;
    particles = new Particle[nparticles];
    for (int i=0; i<nparticles; i++)
      particles[i] = new Particle();
  }
  void make() {
    for (int i=0; i<nparticles; i++)
      particles[i].make();   
    r = (int)random(32,128);
    g = (int)random(32,128);
    b = (int)random(32,128);
  }
  void move(Attractor a) {
    for (int i=0; i<nparticles; i++)
      particles[i].move(a);
  }
  void draw() {
    buf.stroke(r,g,b,0.1);
    for (int i=0; i<nparticles; i++)
      particles[i].draw();
  }
}

class FixedPointBuffer {
  static final int shift = 16;
  static final int fixone = 1<<shift;
  static final int maxrgb = (256<<shift)-1;
  int wid, hei, area;
  int [] redbuf;
  int [] grnbuf;
  int [] blubuf;
  int curred, curgrn, curblu;
  float curalf;
  FixedPointBuffer(int w, int h) {
    wid = w;
    hei = h;
    area = wid * hei;
    redbuf = new int[area];
    grnbuf = new int[area];
    blubuf = new int[area];
    curred = curgrn = curblu = 0;
    curalf = 0.0;
    loadPixels();
  }
  void background(int r, int g, int b) {
    for (int idx=0; idx<area; idx++) {
      redbuf[idx] = r;
      grnbuf[idx] = g;
      blubuf[idx] = b;
    }
  }        
  void stroke(int r, int g, int b, float a) {
    curred = r << shift;
    curgrn = g << shift;
    curblu = b << shift;
    curalf = a;
  }
  // plot additively
  void add(float x, float y) {
    // convert to continuous coordinates
    x -= 0.5;
    y -= 0.5;
    // bounds check
    if ((x<0.0) || (y<0.0) || (x>=wid-1.0) || (y>=hei-1.0)) return;
    // integral coordinates
    int ix1 = (int)(x);
    int iy1 = (int)(y);
    int ix2 = ix1 + 1;
    int iy2 = iy1 + 1;
    // fractional coordinates
    float fractx = x - (float)(ix1);
    float fracty = y - (float)(iy1);
    // reciprocal of fractional coordinates
    float recipx = 1.0 - fractx;
    float recipy = 1.0 - fracty;
    // preconvert color values to floats
    float fr = (float)(curred);
    float fg = (float)(curgrn);
    float fb = (float)(curblu);
    // plot it
    float ratio;
    int idx, c;
    // upper-left
    ratio = recipx * recipy * curalf;
    idx = iy1 * width + ix1;
    c = (int)((ratio*fr) + redbuf[idx]); if (c>maxrgb) c=maxrgb; redbuf[idx] = c;
    c = (int)((ratio*fg) + grnbuf[idx]); if (c>maxrgb) c=maxrgb; grnbuf[idx] = c;
    c = (int)((ratio*fb) + blubuf[idx]); if (c>maxrgb) c=maxrgb; blubuf[idx] = c;
    // upper-right
    ratio = fractx * recipy * curalf;
    idx = iy1 * width + ix2;
    c = (int)((ratio*fr) + redbuf[idx]); if (c>maxrgb) c=maxrgb; redbuf[idx] = c;
    c = (int)((ratio*fg) + grnbuf[idx]); if (c>maxrgb) c=maxrgb; grnbuf[idx] = c;
    c = (int)((ratio*fb) + blubuf[idx]); if (c>maxrgb) c=maxrgb; blubuf[idx] = c;
    // lower-left
    ratio = recipx * fracty * curalf;
    idx = iy2 * width + ix1;
    c = (int)((ratio*fr) + redbuf[idx]); if (c>maxrgb) c=maxrgb; redbuf[idx] = c;
    c = (int)((ratio*fg) + grnbuf[idx]); if (c>maxrgb) c=maxrgb; grnbuf[idx] = c;
    c = (int)((ratio*fb) + blubuf[idx]); if (c>maxrgb) c=maxrgb; blubuf[idx] = c;
    // lower-right            
    ratio = fractx * fracty * curalf;
    idx = iy2 * width + ix2;
    c = (int)((ratio*fr) + redbuf[idx]); if (c>maxrgb) c=maxrgb; redbuf[idx] = c;
    c = (int)((ratio*fg) + grnbuf[idx]); if (c>maxrgb) c=maxrgb; grnbuf[idx] = c;
    c = (int)((ratio*fb) + blubuf[idx]); if (c>maxrgb) c=maxrgb; blubuf[idx] = c;
  }
  // render converts 8.shift format back down to 8 bit rgb
  void render() {
    for (int idx=area-1; idx>=0; idx--) {
      pixels[idx] = 0xFF000000 |
                    (redbuf[idx] & 0xFF0000) |
                    ((grnbuf[idx] & 0xFF0000) >> 8) |
                    ((blubuf[idx] & 0xFF0000) >> 16);
    }
    updatePixels();
  }
}