// M I D G A A R D * 0 2
// by mikkel . crone . koser
// http://proce55ing.beyondthree.com
// or more at : www.beyondthree.com
// oct. 2003
//
// trying to build worms without using trail-effects
// worms moving autonomousely along 
// the paths of vertex-curves.
//
// (1) tried to use the build-in sphere(int) function
// but found this to be much too CPU-consuming.
//
// (2) used TOXI's custom code for making spheres
// with varibale resolution (code can be found in
// the xspehere() method below.
//
// (3) ended up using ellipse's instead since the
// effect is very close to TOXI's spheres, and MUCH
// faster. 


Worm midgaard[];
static int WIDTH = 360;
static int HEIGHT = 360;
static int DEPTH = 360;
static int POP = 12;
int saveNum = 0;
int sphRes = 8;

void setup(){
  size(360, 360);
  ellipseMode(CENTER_RADIUS);
  noStroke();
  fill(255, 200, 0);

  // populate midgaard
  midgaard = new Worm[POP];
  for(int i=0; i<POP; i++){
    midgaard[i] = new Worm(WIDTH, HEIGHT, DEPTH, 25, 8, random(5)/1000f + 0.007);
  }
}

void loop(){
  background(0, 0, 0);
  translate(0, 0, -DEPTH/2);

  for(int i=0; i<POP; i++){
    midgaard[i].update();
  }

  //save("midgaard_02/" + saveNum++ + ".jpg");
}

class Worm{
  int w, h, d, dim;
  float x, y, z;
  int x1,y1,z1, x2,y2,z2, x3,y3,z3, x4,y4,z4;
  float step = 0f;
  float speed;
  int memLength;
  float memX[];
  float memY[];
  float memZ[];

  Worm(int wwidth, int hheight, int ddepth, int mmemlength, int ddim, float sspeed){
    w = wwidth;
    h = hheight;
    d = ddepth;
    dim = ddim;
    speed = sspeed;
    x1 = x2 = x3 = x4 = w/2;
    y1 = y2 = y3 = y4 = h/2;
    z1 = z2 = z3 = z4 = -d;
    memLength = mmemlength;
    initMem();
  }

  void initMem(){
    memX = new float[memLength];
    memY = new float[memLength];
    memZ = new float[memLength];

    for(int i = 0; i < memLength; i++){
      memX[i] = 0f;
      memY[i] = 0f;
      memZ[i] = 0f;
    }
  }

  void updateMem(){
    for(int i = memLength-1; i>0; i--){
      memX[i] = memX[i-1];
      memY[i] = memY[i-1];
      memZ[i] = memZ[i-1];
    }
    memX[0] = x;
    memY[0] = y;
    memZ[0] = z;
  }

  void update(){
    step += speed;
    if(step >= 1f){
      generateCoords();
      step = 0f;
    }

    updateMem();

    x = curvePoint(x1, x2, x3, x4, step);
    y = curvePoint(y1, y2, y3, y4, step);
    z = curvePoint(z1, z2, z3, z4, step);

    // draw the mutha!
    draw();
  }

  void draw(){
    for(int i = 0; i<memLength; i++){
      push();
      translate(memX[i], memY[i], memZ[i]);
      
      fill((memZ[i]/(float)DEPTH)*255, (memZ[i]/(float)DEPTH)*200, 0);
      //xsphere(dim, sphRes);
      ellipse(0, 0, dim, dim);
      pop();
    }
    
    push();
    translate(x, y, z);
    
    fill((z/(float)DEPTH)*255, (z/(float)DEPTH)*200, 0);
    //xsphere(dim, sphRes);
    ellipse(0, 0, dim, dim);  
    pop();
  }

  void generateCoords(){
    x1 = x2;
    x2 = x3;
    x3 = x4;
    x4 = (int)random(0, w);

    y1 = y2;
    y2 = y3;
    y3 = y4;
    y4 = (int)random(0, h);

    z1 = z2;
    z2 = z3;
    z3 = z4;
    z4 = (int)random(0, d);
  }
}

// ALTERNATIVE SPHERE CODE BY TOXI
int currRes=0;
float[] cx,cz,sphereX,sphereY,sphereZ;

void xsphere(float radius,  int res) {
  float delta=360f/res;
  float rad=PI/180;
  if (res!=currRes) {
    cx=new float[res];
    cz=new float[res];
    // calc unit circle
    for(int i=0; i<res; i++) {
      cx[i]=cos(i*delta*rad);
      cz[i]=sin(i*delta*rad);
    }
    // computing vertexlist
    // vertexlist starts at south pole
    int vertCount=res*(res-1)+2;
    int currVert=0;

    sphereX=new float[vertCount];
    sphereY=new float[vertCount];
    sphereZ=new float[vertCount];

    // radius angle is used for scaling circle
    float angle_step=180.0/res;
    float angle=angle_step;
    float[] ringVertsX=new float[res];
    float[] ringVertsZ=new float[res];

    for(int i=1; i<res; i++) {
      float curradius=sin(angle*rad);
      float currY=-cos(angle*rad);
      for(int j=0; j<res; j++) {
        sphereX[currVert]=cx[j]*curradius;
        sphereY[currVert]=currY;
        sphereZ[currVert++]=cz[j]*curradius;
      }
      angle+=angle_step;
    }
    currRes=res;
  }

  int v1,v2,v3,v4;
  push();
  scale(radius);
  beginShape(TRIANGLES);
  // 1st ring from south pole
  for(int i=1; i<=res; i++) {
    v2=i%res;
    v3=(i+1)%res;
    vertex(0,-1,0);
    vertex(sphereX[v2],sphereY[v2],sphereZ[v2]);
    vertex(sphereX[v3],sphereY[v3],sphereZ[v3]);
  }

  // middle rings
  int voff=res;
  for(int i=1; i<res-1; i++) {
    for(int j=0; j<res; j++) {
      v1=voff-res+j;
      v2=voff+j;
      v3=(j+1)%res+voff;
      v4=voff-res+(j+1)%res;
      vertex(sphereX[v1],sphereY[v1],sphereZ[v1]);
      vertex(sphereX[v2],sphereY[v2],sphereZ[v2]);
      vertex(sphereX[v3],sphereY[v3],sphereZ[v3]);
      // 2nd part of quad
      vertex(sphereX[v1],sphereY[v1],sphereZ[v1]);
      vertex(sphereX[v3],sphereY[v3],sphereZ[v3]);
      vertex(sphereX[v4],sphereY[v4],sphereZ[v4]);
    }
    voff+=res;
  }
  // undo the last update
  voff-=res;
  // add the northern cap
  for(int i=1; i<=res; i++) {
    v2=voff+i%res;
    v3=voff+(i+1)%res;
    vertex(0,1,0);
    vertex(sphereX[v2],sphereY[v2],sphereZ[v2]);
    vertex(sphereX[v3],sphereY[v3],sphereZ[v3]);
  }
  endShape();
  pop();
}

// IMAGE-FILE SAVER BY MARTIN AND KONIE
public void save(String filename) {
  BufferedImage img = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
  img.setRGB(0, 0, width, height, pixels, 0, height);
if(filename.toLowerCase().endsWith(".jpg")) {try {File file = new File(filename); javax.imageio.ImageIO.write(img, "jpg", file);} catch(Exception e) {}}
else if(filename.toLowerCase().endsWith(".png")) {try {File file = new File(filename); javax.imageio.ImageIO.write(img, "png", file);} catch(Exception e) {}}
else {g.save(filename);}
}