// sphere city

float mainScale=0.5;  // global variable for drawspeed
float mainLen, mainLenMin=0.65, mainLenDec=0.00012;
float mainRot;
float randomBirth, randomBirthDec=0.00001;
int[][] usedBy=new int[600][300];  // array that keeps track of draw-lines (who drew which pixel?)
int unique_id;                     // unique id's for curves
boolean initAll;

void setup() {
  size(600,300,P3D); background(255);
  setupColors();
  initAll=true;
}

void draw() { 
  if (initAll) {
    background(255); initAll=false;
    for (int x=0;x<width;x++) { for (int y=0;y<height;y++) { usedBy[x][y]=-1; } }
    initCurves();
    initFillers();
    randomBirth=0.04;
    mainLen=1.0; mainRot=0.012;
    unique_id=0;  
  }
  
  mainLen-=mainLenDec; mainRot+=0.000012;
  randomBirth-=randomBirthDec;
  if (mainLen>mainLenMin&&random(1)<randomBirth) { findAndCreateCurve(mainLen); }  
  updateCurvedrawers();
  updateFillers();
}

void mousePressed() { initAll=true; }




////////////////////////////// color setup //////////////////////////////
color[] mainColor = { 0x715F2C, 0x857031, 0x9B853B, 0x5E451D, 0x655422, 0x422B0E, 0x564520 };
color[][] fillColor;
void setupColors() {
  PImage[] textures=new PImage[3];
  textures[0]=loadImage("wood1.jpg");
  textures[1]=loadImage("wood2.jpg");
  textures[2]=loadImage("glass_lead.jpg");
  fillColor=new color[3][30];
  for (int t=0;t<2;t++) { for (int i=0;i<30;i++) {
      fillColor[t][i]=textures[t].pixels[(int)random(textures[t].pixels.length)];
  } }
}
////////////////////////////// end color setup //////////////////////////////





////////////////////////////// class Filler //////////////////////////////

int nr_fillers=30000;
Filler[] filler;

void initFillers() {
  filler=new Filler[nr_fillers];
  for (int i=0;i<nr_fillers;i++) { filler[i]=new Filler(); filler[i].active=false; }
}

void updateFillers() {
  for (int i=0;i<nr_fillers;i++) {
    if (filler[i].active) { filler[i].update(); }
  }
}

void findAndCreateFiller(int id, float x, float y, float dir, float spd, float f, color c) { // find available filler:
  int i=getAvailableFiller();
  if (i!=-1) { filler[i]=new Filler(id,x,y,dir,spd,f,c); }
}

int getAvailableFiller() {
  int i=0; boolean found=false;
  while (!found&&i<nr_fillers) {
    if (!filler[i].active) {
      found=true;
    } else { i++; }
  }
  if (found) { return i; } else { return -1; }
}

class Filler {
  float x,y,dir,spd,f;  // position, direction, speed, force(pressure)
  int id;  // parent id;
  color c;
  boolean active;
  Filler() {}
  Filler(int id, float x, float y, float dir, float spd, float f, color c) {
    this.id=id;
    this.x=x; this.y=y;
    this.dir=dir; this.spd=spd;
    this.f=f;
    this.c=c;
    this.active=true;
  }
  void update() {
    if (active) {
      spd*=1.01;
      dir+=0.1*(noise(x,y)-0.5);
      x+=spd*cos(dir); y+=spd*sin(dir);
      while (x<0) {x+=width;} while (x>=width) {x-=width;}
      while (y<0) {y+=height;} while (y>=height) {y-=height;}
      int sx=int(x), sy=int(y);
      setSmooth(sx,sy,c,0.1*f);
      f-=0.002; if (f<=0) {active=false;}
      int use=usedBy[sx][sy];
      if (use!=-1&&use!=id) {active=false;}
    }
  }
}

////////////////////////////// end Filler //////////////////////////////





////////////////////////////// class Curvedrawer //////////////////////////////

int nr_curves=1000;
int maxChildren=12;
Curvedrawer[] curvedrawer;

void initCurves() { 
  curvedrawer=new Curvedrawer[nr_curves];
  for (int i=0;i<nr_curves;i++) { 
    curvedrawer[i]=new Curvedrawer(i,mainLen);
    curvedrawer[i].active=false; 
  }
}

void updateCurvedrawers() {
  for (int i=0;i<nr_curves;i++) {
    if (curvedrawer[i].active) {
      curvedrawer[i].update();
    }
  } 
}

void findAndCreateCurve(float l) { // find available curvedrawer:
  int i=getAvailableCurvedrawer();
  if (i!=-1) { curvedrawer[i]=new Curvedrawer(unique_id,l); unique_id++; }
}

void findAndCreateCurve(float x, float y, float dir, float l, int colIndex) { // find available curvedrawer:
  int i=getAvailableCurvedrawer();
  if (i!=-1) { curvedrawer[i]=new Curvedrawer(unique_id,x,y,dir,l,colIndex); unique_id++; }
}

int getAvailableCurvedrawer() {
  int i=0; boolean found=false;
  while (!found&&i<nr_curves) {
    if (!curvedrawer[i].active) {
      found=true;
    } else { i++; }
  }
  if (found) { return i; } else { return -1; }
}

class Curvedrawer {
  int id;  // identification index
  float x, y, dir;       // position, direction, 
  float rot, fullrot;  // rotation and fullrotation
  float len;  // length
  boolean active;
  int children;
  int colorIndex;
  int fillColorIndex;
  float fillerDir;
  Curvedrawer(int id, float len) {
    active=true;
    this.id=id;
    x=random(width); y=random(height);
    dir=random(TWO_PI); rot=random(-mainRot,mainRot); 
    this.len=len*mainScale;
    children=0;
    colorIndex=(int)random(mainColor.length);
    fillColorIndex=(int)random(fillColor.length);
    fillerDir=0.0;
  }
  Curvedrawer(int id, float x, float y, float dir, float len, int colorIndex) { 
    active=true;
    this.id=id;
    this.x=x; this.y=y; 
    this.dir=dir; rot=random(-mainRot,mainRot);
    this.len=len;
    children=0;
    this.colorIndex=colorIndex;
    fillColorIndex=(int)random(fillColor.length);
    fillerDir=0.0;
  }
  void setXY(float x, float y) { this.x=x; this.y=y; }
  void update() {
    // create child
    if (random(1)<0.01/len&&children<maxChildren) { createChild(); }    
    
    // move:
    dir+=rot;
    x+=len*cos(dir); y+=len*sin(dir);
    while (x<0) {x+=width;} while (x>=width) {x-=width;}
    while (y<0) {y+=height;} while (y>=height) {y-=height;}
    
    // check for full circle:
    fullrot+=rot;
    if (fullrot>TWO_PI) {active=false;}
    
    // draw filler:
    color c=fillColor[fillColorIndex][(int)random(fillColor[fillColorIndex].length)];
    findAndCreateFiller(id,x,y,dir-(HALF_PI+fillerDir),len*0.5,0.1+mainLen-mainLenMin,c);
    findAndCreateFiller(id,x,y,dir+(HALF_PI+fillerDir),len*0.5,0.1+mainLen-mainLenMin,c);
    
    // draw:
    int sx=int(x), sy=int(y);
    if (sx>=0&&sx<width&&sy>=0&sy<height) {
      int use=usedBy[sx][sy];
      if (use!=-1&&use!=id) {
        active=false;
      } else {
        setSmooth(sx,sy,mainColor[colorIndex],0.99*len); 
        usedBy[sx][sy]=id;
      }
    }
  }
  
  void createChild() {
    children++;
    int dr=rot>0?1:-1;
    float ndir=dir+dr*HALF_PI;
    float nx=x+len*cos(ndir), ny=y+len*sin(ndir);
    float nlen=len;
    int ncol;//=(int)random(mainColor.length);
    do { ncol=colorIndex+(random(1)<0.5?-1:1); } while (ncol<0||ncol>=mainColor.length);
    findAndCreateCurve(nx,ny,ndir,nlen,ncol);
  }
}

////////////////////////////// end Curvedrawer //////////////////////////////





////////////////////////////// drawing routines //////////////////////////////
void setSmooth(int x, int y, color c1, float p1) {
  float p2=1.0-p1; color c2=get(x,y);
  int rr=int(p1*(c1>>16&255)+p2*(c2>>16&255));
  int gg=int(p1*(c1>>8&255)+p2*(c2>>8&255));
  int bb=int(p1*(c1&255)+p2*(c2&255));
  set(x,y,rr<<16|gg<<8|bb);
}
////////////////////////////// end drawing routines //////////////////////////////