// sphere city

color[] mainColor = { 
  0x715F2C, 0x857031, 0x9B853B, 0x5E451D, 0x655422, 0x422B0E, 0x564520 };
float mainScale=0.5;  // global variable for drawspeed
float mainLen;      
float mainRot;

int[][] usedBy;//  // array that keeps track of draw-lines (who drew which pixel?)
int unique_id;                     // unique id's for curves

void setup() {
  size(800,400,P3D); 
  background(255);
  usedBy =new int[800][400];
  for (int x=0;x<width;x++) { 
    for (int y=0;y<height;y++) { 
      usedBy[x][y]=-1; 
    } 
  }
  initCurves();
  mainLen=1; 
  mainRot=0.01;
  unique_id=0;
}

void draw() { 
  mainLen-=0.0002; 
  mainRot+=0.00001;
  if (mainLen>0.3&&random(1)<0.04) { 
    findAndCreateCurve(mainLen);  
  }  
  updateCurvedrawers();
}

void mousePressed() {
  setup();
}

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


int nr_curves=1000;
int maxChildren=8;
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;
  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);
  }
  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;
  }
  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:
    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); 
        //        set(sx,sy,mainColor[colorIndex]);
        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 //////////////////////////////


void darken(int x,int y, color c) {
  set(x,y,c);
}

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);
}