/*
  this demo showcases several things:
  - tiling cellular textures ala http://www.blackpawn.com/texts/cellular/ (added colour support)
  - generic texturemapped sphere routine
  
  usage:
  keep mouse pressed to only see texture
  hold down shift to toggle cell mode

  author: info@toxi.co.uk

*/

int numPoints=20;
int texW=128;
int texH=128;
int w2=texW/2;
int h2=texH/2;

int[] distBuffer;
int[] pointBuffer;

Particle[] points;

BImage tex;

void setup() {
  size(400,400);
  // setup particles and delta buffer
  points=new Particle[numPoints];
  for(int i=0; i<numPoints; i++) {
    points[i]=new Particle(texW,texH);
  }
  tex=new BImage(texW,texH);
  distBuffer=new int[texW*texH];
  pointBuffer=new int[texW*texH];

  sphereDetail(50);
  textureMode(IMAGE_SPACE);
  noStroke();
}

void loop() {
  // update particle positions
  for(int i=0; i<numPoints; i++) points[i].update();

  // pass 1 : update distances
  int minD=1000000000;
  int maxD=0;
  int currD;
  // index in delta buffer
  int idx=0;
  for(float y=0; y<texH; y++) {
    for(float x=0; x<texW; x++) {
      int[] d=distToNearestParticle(x,y);
      distBuffer[idx]=currD=d[0];
      pointBuffer[idx++]=d[1];
      if (currD<minD) minD=currD;
      else if (currD>maxD) maxD=currD;
    }
  }

  // pass 2 : scale & render results
  idx=0;
  float contrast=1f/(maxD-minD);
  while(idx<tex.pixels.length) {
    float col=1-(distBuffer[idx]-minD)*contrast;
    // invert colors if key is pressed
    if (keyPressed) col=1-col;
    // use color of current pixel's related particle
    int rr=(int)(points[pointBuffer[idx]].colR*col);
    int gg=(int)(points[pointBuffer[idx]].colG*col);
    int bb=(int)(points[pointBuffer[idx]].colB*col);
    tex.pixels[idx++]=0xff000000|rr<<16|gg<<8|bb;
  }
  background(102,0,0);
  // draw only texture image (tiled) if mouse is pressed
  if (mousePressed) {
    for(int y=0; y<height; y+=texH) {
      for(int x=0; x<width; x+=texW) {
        image(tex,x,y,texW,texH);
      }
    }
  } else {
  // ...or show texturemapped sphere
    translate(200,200,0);
    rotateX(mouseY*0.02);
    rotateY(mouseX*0.02);
    texturedSphere(150,tex);
  }
}

// find closest particle to current pixel
// returns distance and particle index
int[] distToNearestParticle(float x, float y) {
  float mindist = 1000000000;
  int minIdx=0;
  for(int i=0; i<numPoints; i++) {
    float dist = wrapDist(x,y,points[i].xx,points[i].yy);
    if (dist < mindist) {
      mindist = dist;
      minIdx=i;
    }
  }
  return new int[] {
    (int)Math.sqrt(mindist),
    minIdx
  };
}

// converts distance to wrapped space dimensions
float wrapDist(float x, float y, float px, float py) {
  float dx = abs(x-px);
  float dy = abs(y-py);
  if (dx > w2) dx = texW-dx;
  if (dy > h2) dy = texH-dy;
  return dx*dx + dy*dy;
}

// generic routine to draw textured sphere,
// based on current settings of sphereDetail()
void texturedSphere(float r, BImage t) {
  int v1,v11,v2;
  float[] sphereX=g.sphereX;
  float[] sphereY=g.sphereY;
  float[] sphereZ=g.sphereZ;
  int sphere_detail=g.sphere_detail;

  beginShape(TRIANGLE_STRIP);
  texture(t);
  float iu=(float)(t.width-1)/(sphere_detail);
  float iv=(float)(t.height-1)/(sphere_detail);
  float u=0,v=iv;
  for (int i = 0; i < sphere_detail; i++) {
    vertex(0, -r, 0,u,0);
    vertex(sphereX[i]*r, sphereY[i]*r, sphereZ[i]*r,u,v);
    u+=iu;
  }
  vertex(0, -r, 0,u,0);
  vertex(sphereX[0]*r, sphereY[0]*r, sphereZ[0]*r,u,v);
  endShape();

  // middle rings
  int voff = 0;
  for(int i = 2; i < sphere_detail; i++) {
    v1=v11=voff;
    voff += sphere_detail;
    v2=voff;
    u=0;
    beginShape(TRIANGLE_STRIP);
    texture(t);
    for (int j = 0; j < sphere_detail; j++) {
      vertex(sphereX[v1]*r, sphereY[v1]*r, sphereZ[v1++]*r,u,v);
      vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2++]*r,u,v+iv);
      u+=iu;
    }
    // close each ring
    v1=v11;
    v2=voff;
    vertex(sphereX[v1]*r, sphereY[v1]*r, sphereZ[v1]*r,u,v);
    vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2]*r,u,v+iv);
    endShape();
    v+=iv;
  }
  u=0;
  // add the northern cap
  beginShape(TRIANGLE_STRIP);
  texture(t);
  for (int i = 0; i < sphere_detail; i++) {
    v2 = voff + i;
    vertex(0, r, 0,u,v+iv);
    vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2]*r,u,v);
    u+=iu;
  }
  vertex(0, r, 0,u,v+iv);
  vertex(sphereX[voff]*r, sphereY[voff]*r, sphereZ[voff]*r,u,v);
  endShape();
}

// simple particle class used by the cell algorithm
class Particle {
  float cx,cy,xx,yy;
  float r,angle,speed;
  float colR,colG,colB;

  Particle(int ww, int hh) {
    cx=xx=random(ww);
    cy=yy=random(hh);
    r=random(10,50);
    angle=random(TWO_PI);
  int[] colors=new int[]{0xffcccc,0xff9999,0xcc3380,0xff0000,0x990000,0xcc0033,0xff66cc};
    speed=random(0.02,0.1);
    if (random(1)<0.5) speed=-speed;
    int c=colors[(int)random(colors.length-0.1)];
    colR=c>>16;
    colG=c>>8&0xff;
    colB=c&0xff;
  }

  void update() {
    angle+=speed;
    xx=cx+cos(angle)*r;
    yy=cy+sin(angle)*r;
  }
}