// sphere city

color[] mainColor = { 0x715F2C, 0x857031, 0x9B853B, 0x5E451D, 0x655422, 0x422B0E, 0x564520 };
color[][] fillColor = { { 0x6F6AAC, 0x7B71AE, 0x8477BC, 0x9084B4, 0x8076B3, 0x7F76B9 },
                        { 0xC7749E, 0xCE739F, 0xCA719D, 0xCB78A2, 0xD67FAC, 0xD279A5 },
//                        { 0xE584AD, 0xF08EB7, 0xF091B1, 0xF990B8, 0xF58FBE, 0xEF8AB4 },
                        { 0xF38F9B, 0xFC96A3, 0xF995A1, 0xFFA8AE, 0xFA9AA6, 0xF8939B },
                        { 0xFADB80, 0xFADC7A, 0xFCDF79, 0xF8DB75, 0xFFE181, 0xFDDE81 },
                        { 0x85AE07, 0x7EA400, 0x83AE07, 0x7C9F07, 0x7AA800, 0x7FA406 },
                        { 0x697728, 0x677623, 0x627B16, 0x6B811F, 0x657D1B, 0x6E8326 } };
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();
  initFillers();
  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();
  updateFillers();
}

void mousePressed() {
  setup();
}

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

int nr_fillers=20000;
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;
    active=true;
  }
  void update() {
    if (active) {
      spd*=1.01;
      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);
      setDarken(sx,sy,c,0.2*f);
      f-=0.005; 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=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;
  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,mainLen,c);
    findAndCreateFiller(id,x,y,dir+(HALF_PI+fillerDir),len*0.5,mainLen,c);
    fillerDir+=(noise(x,y)*0.2-0.1);
    
    // 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 //////////////////////////////


void setDarken(int x, int y, color c, float f) {
  setSmooth(x,y,c,f);
}

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