// Sketch for animation for mobile phone company "3".
// Time-based computational animation.
//
// See http://www.unlekker.net/proj/DREIx3x2x2D/


int numObj,numEvent,cnt;
float scaleIt,colors[][],zMax,zMin;
float tri[][],penta[][],dodo[][];
int dodoNum=30;
Event event[];

void setup() {
//  size(240,320);
  size(576,768);
  size(300,400);
//  framerate(25);


  smooth();
  background(255);
  ellipseMode(CENTER_DIAMETER);
  rectMode(CENTER_DIAMETER);
  
  scaleIt=(float)width/576.0f;
  initShapes();
  colors=new float[5][3];
  addColor(0, 100,0,0);
  addColor(0, 40,0,60);
  addColor(0, 20,80,40);

  addColor(0, 80,30,10);
  addColor(1, 255,60,0);
  addColor(2, 0,100,255);
  addColor(3, 255,255,255);

  cnt=0;
  zMax=400;
  zMin=0;
  
  numEvent=200;
  event=new Event[numEvent];
  for(int i=0; i<numEvent; i++) 
    event[i]=new Event(i);
    
  noStroke();
}

void addColor(int id,float r,float g,float b) {
  colors[id][0]=r;
  colors[id][1]=g;
  colors[id][2]=b;
}

void loop() {
  background(255);
  
  translate(width/2-20,height/2-10);
  scale(scaleIt,scaleIt,scaleIt);
  
  push();
  for(int i=0; i<numEvent; i++) 
    if(!mousePressed && cnt<675 && cnt>=event[i].start && event[i].stateCnt!=-1) 
      event[i].draw();
  pop();  
  
    
    
  if(cnt%10==0) println("cnt "+cnt);
  cnt++;
  
// Run only to 675 frames == 3*3*3 seconds / 25 fps
// then reset
  if(cnt>675) {
    cnt=0;
    for(int i=0; i<numEvent; i++) event[i]=new Event(i);
  }
}


class Event {
  int id,start,stateCnt,moveCnt,drawCnt;
  int type,col,numV;
  float D,rad,currRad,fract,T;
  int num;
  Vec3D v[],vD;
  float rotD;
  
  public Event(int _id) {
    id=_id;
    
    stateCnt=120+(int)random(100);
    D=1/(float)(stateCnt-1);
    start=(int)random(675-stateCnt);

    num=stateCnt/3;
    v=new Vec3D[num];
    v[num-1]=new Vec3D(random(width/5)-width/10,random(height/5)-height/10,0);
    for(int i=0; i<num-1; i++) v[i]=new Vec3D(v[num-1]);
    

    float prob=random(100);
    if(start<90) col=0;
    else if(start<300) {
      if(prob<45) col=1;
      else if(prob<90) col=2;
      else col=0;
    }
    else if(start<500) {
      if(prob<40) col=1;
      else if(prob<80) col=2;
      else col=0;
    }
    else if(start<600) {
      if(prob<60) col=2;
      else if(prob<80) col=0;
      else col=1;
    }
    else col=2;

    if(prob>100 && start>120) col=3;
    type=0;
    if(start<200) type=0;
    else if(start<300 && random(100)>99) type=(int)random(100)%4+1;
    else if(start<400 && random(100)>90) type=(int)random(100)%4+1;
    else if(start<500 && random(100)>70) type=(int)random(100)%4+1;
    else if(random(100)>50) type=(int)random(100)%4+1;
    type=0;
    rad=(int)(random(4)+1)*3;
    if(random(100)>98) rad+=10;
    
    vD=new Vec3D(rad*0.7,0,0);
    vD.rotateZ(random(PI*2));
    newMove();    
    rotD=1+random(2);//+(random(2)-1)*0.2;
    if(random(100)>50) rotD=-rotD;
  }
  
  void newMove() {
//    vD.set(random(2)-1,random(2)-1,random(2)-1);
//    vD.rotateX(random(PI/6.0f)-PI/12.0f);
//    vD.rotateY(random(PI/6.0f)-PI/12.0f);
    if(random(100)>50) vD.rotateZ(PI/2);
    else vD.rotateZ(-PI/2);
    moveCnt=(int)random(6)+6;
  }
  
  public void draw() {      
    T=1-D*(float)stateCnt;
//    if(T<0.2) fract=1-T*5.0f;
    if(T>=0.8) fract=1-(1-T)*5.0f;
    else fract=0;
    fill(colors[col][0],colors[col][1],colors[col][2],
        225-225*fract);
//      200-abs(200*cos(PI+PI*D*(float)stateCnt)));    


    fract=abs(sin(PI*0.5+PI*0.5*D*(float)stateCnt));//
    fract=T;
    fract*=fract;
    
    if(drawCnt<num) drawCnt++;
    for(int i=num-drawCnt; i<num; i++) {
      currRad=rad*(0.75+fract*0.5);

      if(i<num-1) v[i].set(v[i+1]);
      else {
        v[i].add(vD);
        vD.rotateZ(radians(1));
        moveCnt--;
        if(moveCnt==0) newMove();    
      }
      push();
      rotate(T*PI*0.25*rotD);
      if(start>200) rotate(PI*2*(float)(start-200)/475);
//      if(start>100) rotateY(PI*0.4*(float)(start-100)/575);
      scale(1+T*T*3,1+T*T*3);
      translate(v[i].x,v[i].y,v[i].z);

      if(type==0) ellipse(0,0,currRad,currRad);
      else if(type==1) pentagon(0,0,currRad,currRad*0.6);
      else if(type==2) dodogon(0,0,currRad,currRad*0.4,2);
      else if(type==3) trigon(0,0,currRad,currRad*0.75);
      else if(type==4) cross(0,0,currRad/2,currRad/6);
      pop();
    }
    stateCnt--;
  }
}

void initShapes() {
  tri=new float[3][2];
  penta=new float[5][2];
  dodo=new float[dodoNum][2];
  for(int i=0; i<dodoNum; i++) {
    if(i<3) {
      tri[i][0]=cos(radians(i*120));
      tri[i][1]=sin(radians(i*120));
    }
    if(i<5) {
      penta[i][0]=cos(radians(i*72));
      penta[i][1]=sin(radians(i*72));
    }
    dodo[i][0]=cos(radians(i*(360/dodoNum)));
    dodo[i][1]=sin(radians(i*(360/dodoNum)));
  }
}

void pentagon(float x,float y,float rad,float rad2) {
  int d1,d2;

  for(int i=0; i<5; i++) {
    d1=i;
    d2=(i+1)%5;
    quad(x+penta[d1][0]*rad,y+penta[d1][1]*rad, 
      x+penta[d2][0]*rad,y+penta[d2][1]*rad,
      x+penta[d2][0]*rad2,y+penta[d2][1]*rad2,
      x+penta[d1][0]*rad2,y+penta[d1][1]*rad2);
  }  
}

void trigon(float x,float y,float rad,float rad2) {
  int d1,d2;

  for(int i=0; i<3; i++) {
    d1=i;
    d2=(i+1)%3;
    quad(x+tri[d1][0]*rad,y+tri[d1][1]*rad, 
      x+tri[d2][0]*rad,y+tri[d2][1]*rad,
      x+tri[d2][0]*rad2,y+tri[d2][1]*rad2,
      x+tri[d1][0]*rad2,y+tri[d1][1]*rad2);
  }  
}

void dodogon(float x,float y,float rad,float rad2,int step) {
  int d1,d2;

  for(int i=0; i<dodoNum; i+=step) {
    d1=i;
    d2=(i+1)%dodoNum;
    quad(x+dodo[d1][0]*rad,y+dodo[d1][1]*rad, 
      x+dodo[d2][0]*rad,y+dodo[d2][1]*rad,
      x+dodo[d2][0]*rad2,y+dodo[d2][1]*rad2,
      x+dodo[d1][0]*rad2,y+dodo[d1][1]*rad2);
  }  
}

void cross(float x,float y,float rad,float rad2) {
  float radHalf;
  x-=rad;
  y-=rad;
  radHalf=rad;
  rad*=2;
  quad(x+radHalf-rad2,y, x+radHalf+rad2,y, x+radHalf+rad2,y+rad, x+radHalf-rad2,y+rad); 
  quad(x,y+radHalf-rad2, x+radHalf-rad2,y+radHalf-rad2, x+radHalf-rad2,y+radHalf+rad2, x,y+radHalf+rad2); 
  quad(x+radHalf+rad2,y+radHalf-rad2, x+rad,y+radHalf-rad2, x+rad,y+radHalf+rad2, x+radHalf+rad2,y+radHalf+rad2);
}

void fatLine(float x1,float y1,float x2,float y2,float rad) {
  x2-=x1;
  y2-=y1;
  push();
  translate(x1,y1);
  rotate(atan2(y2,x2));
  x1=sqrt(x2*x2+y2*y2);
  quad(0,rad, x1,rad, x1,-rad, 0,-rad);
  pop();
}

// General vector class for 3D vectors
class Vec3D {
  float x,y,z;

  Vec3D(float _x,float _y,float _z) {
    x=_x;
    y=_y;
    z=_z;
  }

  Vec3D(Vec3D v) {
    x=v.x;
    y=v.y;
    z=v.z;
  }

  void set(float _x,float _y,float _z) {
    x=_x;
    y=_y;
    z=_z;
  }

  void set(Vec3D v) {
    x=v.x;
    y=v.y;
    z=v.z;
  }

  void add(float _x,float _y,float _z) {
    x+=_x;
    y+=_y;
    z+=_z;
  }

  void add(Vec3D v) {
    x+=v.x;
    y+=v.y;
    z+=v.z;
  }

  void sub(float _x,float _y,float _z) {
    x-=_x;
    y-=_y;
    z-=_z;
  }

  void sub(Vec3D v) {
    x-=v.x;
    y-=v.y;
    z-=v.z;
  }

  void mult(float m) {
    x*=m;
    y*=m;
    z*=m;
  }

  void div(float m) {
    x/=m;
    y/=m;
    z/=m;
  }

  float length() {
    return sqrt(x*x+y*y+z*z);
  }

  void normalise() {
    float l=length();
    if(l!=0) {
      x/=l;
      y/=l;
      z/=l;
    }
  }

  void rotateX(float val) {
    // Due to float not being precise enough, double is used for the calculations
    double cosval=Math.cos(val);
    double sinval=Math.sin(val);
    double tmp1=y*cosval - z*sinval;
    double tmp2=y*sinval + z*cosval;

    y=(float)tmp1;
    z=(float)tmp2;
  }

  void rotateY(float val) {
    // Due to float not being precise enough, double is used for the calculations
    double cosval=Math.cos(val);
    double sinval=Math.sin(val);
    double tmp1=x*cosval - z*sinval;
    double tmp2=x*sinval + z*cosval;

    x=(float)tmp1;
    z=(float)tmp2;
  }

  void rotateZ(float val) {
    // Due to float not being precise enough, double is used for the calculations
    double cosval=Math.cos(val);
    double sinval=Math.sin(val);
    double tmp1=x*cosval - y*sinval;
    double tmp2=x*sinval + y*cosval;

    x=(float)tmp1;
    y=(float)tmp2;
  }
}