// 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[];
boolean paused=false;

void setup() {
//  size(240,320);
  size(576,768);
  size(300,400);
//  size(130,173);

  smooth();
  background(255);
  framerate(25);
  ellipseMode(CENTER_DIAMETER);
  rectMode(CENTER_DIAMETER);
  
  scaleIt=(float)width/576.0f;
  initShapes();
  colors=new float[5][3];
  addColor(0, 100,0,0);
  addColor(1, 255,00,0);
  addColor(2, 255,255,0);

  addColor(0, 0,50,128);
  addColor(1, 200,40,0);
  addColor(2, 100,200,0);
  addColor(3, 255,255,255);

  cnt=0;
  zMax=400;
  zMin=0;
  
  numEvent=250;
  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-10,height/2-10);
  scale(scaleIt,scaleIt,scaleIt);
  rotate((float)cnt/675.0f*PI);
  push();
  for(int i=0; i<numEvent; i++) 
    if(cnt>=event[i].start && event[i].stateCnt!=-1) event[i].draw();
  pop();  
      
  if(!paused) 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;
  float rot,rotD;
  int num;
  Vec3D v[],vD;
  float vRot,xD,yD;
    
  public Event(int _id) {
    id=_id;
    
    stateCnt=80+(int)random(200);
    if(random(100)>80) stateCnt+=(int)random(75)+25;
    D=1/(float)(stateCnt-1);
    start=(int)random(670-stateCnt);

    num=100;
    v=new Vec3D[num];
    v[num-1]=new Vec3D(random(width/10),0,0);
    v[num-1].rotateZ(radians(random(360)));
    for(int i=0; i<num-1; i++) v[i]=new Vec3D(v[num-1]);
    

    float prob=random(100);
    if(start<40) col=0;
    else if(start<250) {
      if(prob<60) col=0;
      else if(prob<80) col=1;
      else col=2;
    }
    else if(start<500) {
      if(prob<40) col=1;
      else if(prob<60) 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>95) col=3;
    col=(int)random(100)%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=random(6)+2;
    prob=random(100);
    if(prob>95) rad*=2;
    else if(prob>90) rad*=4;
    
    vD=new Vec3D(rad*0.75,0,0);
    vD.rotateZ(random(PI*2));
    vRot=radians(random(720)+540)/(float)stateCnt;
    if(random(100)>50) vRot-=vRot;
    vRot=radians(random(6)-3);
    xD=(random(2)-1)*rad*0.075; 
    yD=(random(2)-1)*rad*0.075; 
    
    rot=radians((int)random(20)*36);
    rotD=radians(random(720)-360-rot);
    rotD/=(float)(stateCnt-1);
  }
  
  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);
//    vD.rotateZ(PI/2);
    if(v[num-1].z>-10) vD.z=-abs(vD.z);
    moveCnt=(int)random(10)+10;
  }
  
  public void draw() {      
    T=1-D*(float)stateCnt;
    fract=T;
    if(fract<0.2) fract=1-fract*5.0f;
    else if(fract>=0.8) fract=1-(1-fract)*5.0f;
    else fract=0;
    fill(colors[col][0],colors[col][1],colors[col][2],
        150-150*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(!paused) {
      rot+=rotD;
      if(drawCnt<num) drawCnt++;
    }
    
    for(int i=num-drawCnt; i<num; i++) {
      currRad=rad*(0.5+fract*0.5);

      if(!paused) {
        if(i<num-1) v[i].set(v[i+1]);
        else {
          v[i].add(vD);
          vD.rotateY(vRot/2);
          vD.rotateZ(vRot);
        }
      }
      push();
      rotate(rot);
      scale(1+T*3,1+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();
    }
    if(!paused) 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;
  }
}