// Círculo Fractal
// Emiliano Causa
// hecho con Processing 0068
// 25-Jun-2006
// www.proyecto-biopus.com.ar
//
Arrastrar[] circu;
Fractalizador fractal;
int cantidad;
float transparencia;
Mouse mouse;
color col1 , col2 ;
int start=400;
BImage titu,b; 
//--------------------------------------------------------------------------
void setup(){
  size(800,600);

  transparencia = 100;
  col1 = color(0,0,255,transparencia);
  col2 = color(150,0,255,transparencia);

  cantidad = 10;

  fractal = new Fractalizador(cantidad);

  circu = new Arrastrar[ cantidad ];
  for(int i=0 ; i<cantidad ; i++){
    circu[i] = new Arrastrar(100,100,50,0.5,col1,col2);
    circu[i].estaVivo = false;
  }

  mouse = new Mouse();
  background(0);
  imageMode(CENTER_DIAMETER);
  titu = loadImage("titu.jpg"); 
  b = loadImage("biopus.jpg"); 
}
//--------------------------------------------------------------------------
void loop(){

  if(start>0){
    start--;
    logo(400,250);
    tint(255,255,255);
    image(b,400,300);
    int t=500-start;
    if(t<0)t=0;
    tint(t,t,t);
    image(titu,400,400);

  }else{
    background(0);
    mouse.actualizar();
    //mouse.string();

    fractalizar();
    dibuja_y_mueve();
    agrega_nuevos();
    quita_los_de_afuera();
  }
}
//--------------------------------------------------------------------------
void fractalizar(){

  int elegido = -1;
  float maximo = 0;
  for(int i=0 ; i<cantidad ; i++){
    if(circu[i].estaVivo){
      if(circu[i].diametro > maximo){
        maximo = circu[i].diametro;
        elegido = i;
      }
    }
  }
  //println(elegido);
  if(elegido>-1){

    fractal.reiniciar();

    float cx = circu[ elegido ].x;
    float cy = circu[ elegido ].y;
    float ct = circu[ elegido ].diametro;
    float ca = circu[ elegido ].angulo;

    for(int i=0 ; i<cantidad ; i++){
      if(circu[i].estaVivo && i!=elegido){
        float ex = circu[i].x - cx;
        float ey = circu[i].y - cy;
        float er = circu[i].diametro / ct;
        float ea = circu[i].angulo - ca;

        fractal.cargarPunto( ex , ey , circu[i].diametro , er , ea );

      }
    }

    push();
    translate(cx,cy);
    fractal.calcularProfundidad();
    fractal.fractalizar( 1 , 0 , 1 );
    pop();

  }

}
//--------------------------------------------------------------------------
void quita_los_de_afuera(){
  for(int i=0 ; i<cantidad ; i++){
    if(circu[i].estaVivo){
      if((circu[i].x < 0 || circu[i].x > width) || (circu[i].y < 0 || circu[i].y > height)){
        circu[i].estaVivo = false;
        mouse.capturado = false;
      }
    }
  }
}
//--------------------------------------------------------------------------
void dibuja_y_mueve(){
  for(int i=0 ; i<cantidad ; i++){
    circu[i].mover();
    circu[i].dibujar();
  }
}
//--------------------------------------------------------------------------
void agrega_nuevos(){
  if(mouse.down && !mouse.capturado){
    for(int i=0 ; i<cantidad ; i++){
      if(!circu[i].estaVivo){
        circu[i] = new Arrastrar(mouseX,mouseY,50,0.5,col1,col2);
        circu[i].clickEnCentro();
        break;
      }
    }
  }
}
//--------------------------------------------------------------------------
float linea(float x , float x1 , float x2 , float y1 , float y2 ){
  return (x-x1)/(x2-x1)*(y2-y1)+y1;
}
//--------------------------------------------------------------------------
void logo(int x,int y){
  int lado=15;
  int alto=10;
  rectMode(CORNER);

  noStroke();
  for(int i=0;i<5;i++){
    for(int j=0;j<5;j++){
      if(j==2 || ((i==1 || i==3) && (j==0 || j==4)) || (i==2 && (j==1 || j==3))){
        fill(0,255-random(start),0);
      }else{
        fill(0,0+random(start),0);
      }
      rect(x+i*lado-lado*2.5,y+j*alto-alto*2.5,lado*0.8,alto*0.8);
    }
  }
}
//------------------------------------------------------------------------------------------------------
// FRACTALIZADOR -  FRACTALIZADOR - FRACTALIZADOR - FRACTALIZADOR - FRACTALIZADOR - FRACTALIZADOR -
//------------------------------------------------------------------------------------------------------
class Fractalizador{

  float[] x,y,tam,rel,angu;
  int canti;
  int cont;
  int maxProfundidad;

  float rojoIni, rojoFin , verdeIni , verdeFin , azulIni , azulFin;

  Fractalizador(int canti_){
    canti = canti_;
    reiniciar();

    rojoIni = 255;
    verdeIni = 0;
    azulIni = 0;

    rojoFin = 255;
    verdeFin = 255;
    azulFin = 0;
  }

  void reiniciar(){
    cont = 0;
    x = new float[canti];
    y = new float[canti];
    tam = new float[canti];
    rel = new float[canti];
    angu = new float[canti];
  }

  void cargarPunto(float x_, float y_, float tam_, float rel_, float angu_){
    x[cont] = x_;
    y[cont] = y_;
    tam[cont] = tam_;
    rel[cont] = rel_;
    angu[cont] = angu_;
    cont++;
  }

  void calcularProfundidad(){
    int total=1;
    int j;
    for(j=0;j<30;j++){
      total*=cont;
      if(total>3000){
        break;
      }
    }
    maxProfundidad = j-1;
  }

  void fractalizar( float factor , float rotacion , int profundidad){
    rotate(rotacion);

    for(int i=0; i<cont ; i++){
      push();
      translate( x[i] * factor , y[i] * factor );

      float rojo = linea(profundidad,1,maxProfundidad,rojoIni,rojoFin);
      float verde = linea(profundidad,1,maxProfundidad,verdeIni,verdeFin);
      float azul = linea(profundidad,1,maxProfundidad,azulIni,azulFin);

      fill(rojo , verde , azul , transparencia);

      if(profundidad>1) ellipse( 0 , 0 , tam[i] * factor , tam[i] * factor );

      if(profundidad < maxProfundidad){
        fractalizar( rel[i] * factor , angu[i] , profundidad + 1 );
      }
      pop();
    }
  }

  void string(){
    println("------------------------------------------------------------");
    for(int i=0; i<cont ; i++){
      println(i+" / x="+x[i]+" / y="+y[i]+" / tam="+tam[i]+" / rel="+rel[i]+" / angu="+angu[i] );
    }
  }

}
//------------------------------------------------------------------------------------------------------
// ARRASTRAR - ARRASTRAR - ARRASTRAR - ARRASTRAR - ARRASTRAR - ARRASTRAR - ARRASTRAR - ARRASTRAR -
//------------------------------------------------------------------------------------------------------
class Arrastrar{
  float x,y;
  float diametro;
  float porcCentro;

  float prevAngu;
  float angulo;
  float dife;
  float difeInter;

  float diametroOriginal;
  float lim1 = 0.5;
  float lim2 = 4;

  color colorFondo;
  color colorCentro;

  boolean activado;
  boolean centro;
  boolean estaVivo;

  boolean girando;

  int cont;

  Arrastrar(float x_, float y_, float diametro_, float porcCentro_, color colorFondo_, color colorCentro_){
    x = x_;
    y = y_;

    diametro = diametro_;
    diametroOriginal = diametro_;
    porcCentro = porcCentro_;

    angulo = HALF_PI * 3;
    colorFondo = colorFondo_;
    colorCentro = colorCentro_;

    activado = false;
    estaVivo = true;
    girando = false;
  }

  void clickEnCentro(){
    activado = true;
    centro = true;
    mouse.capturado = true;
  }

  void mover(){
    if(estaVivo){

      if( !activado ){
        float distancia = dist(mouseX,mouseY,x,y);
        if(mouse.down && distancia < diametro * 0.5 ){
          activado = true;
          mouse.capturado = true;
          centro = (distancia < diametro * 0.5 * porcCentro );
          dife = 0;
          prevAngu = angulo;
        }else{
          if(girando){
            angulo += difeInter;
          }
        }
      }else{

        if(mouse.up){
          activado=false;
          mouse.capturado = false;

          //println("----------------------------------");

        }else{
          if(centro){
            x = mouseX;
            y = mouseY;
          }else{
            angulo = atan2(mouseY-y,mouseX-x);
            diametro = dist(mouseX,mouseY,x,y) * (1/(porcCentro + (1-porcCentro)/2)) * 2;
            diametro = (diametro > diametroOriginal*lim2 ? diametroOriginal*lim2 : diametro);
            diametro = (diametro < diametroOriginal*lim1 ? diametroOriginal*lim1 : diametro);
          }
        }

        //girando = (prevAngu != angulo );
        float factor = 0.5;
        float iFactor = 0.5;
        float estaDife = (angulo-prevAngu);

        cont++;
        cont = cont % 5;

        estaDife = (estaDife > PI ? estaDife - PI : estaDife);
        estaDife = (estaDife < -PI ? estaDife + PI : estaDife);

        dife = dife * (1-factor) + estaDife * factor;

        if(cont==0){
          difeInter = difeInter * iFactor + dife * (1-iFactor);
        }

        /*
        println("estaDife="+int(degrees(estaDife)*100)/100);
        println("Dife="+int(degrees(dife)*100)/100);
        println("DifeInter="+int(degrees(difeInter)*100)/100);
        */

        girando = (abs(degrees(difeInter)) > 2);

        prevAngu = angulo;

      }
    }
  }

  void dibujar(){
    if(estaVivo){
      ellipseMode(CENTER_DIAMETER);
      noStroke();
      fill(colorFondo);
      ellipse(x,y,diametro,diametro);
      if(activado || girando){
        fill(colorCentro);
        ellipse(x , y , diametro * porcCentro , diametro * porcCentro );
        float diam2 = diametro * 0.3 * (1-porcCentro) ;
        float radio2 = diametro * 0.5 * (porcCentro + (1-porcCentro)/2);
        ellipse( x + radio2 * cos(angulo) , y + radio2 * sin(angulo) , diam2 , diam2 );
      }
    }
  }

}
//-----------------------------------------------------------------------------------------------------
// MOUSE - MOUSE - MOUSE - MOUSE - MOUSE - MOUSE - MOUSE - MOUSE - MOUSE - MOUSE - MOUSE - MOUSE -
//-----------------------------------------------------------------------------------------------------
class Mouse{
  boolean down;
  boolean up;
  boolean drag;
  boolean capturado;

  Mouse(){
    down = false;
    up = false;
    drag = false;
    capturado = false;
  }

  void actualizar(){
    if(mousePressed){
      if( !drag){
        drag = true;
        down = true;
      }else{
        down = false;
      }
    }else{
      if(drag){
        up = true;
        drag = false;
      }else{
        up = false;
      }
    }
  }

  void string(){
    println("Up="+(up ? "ON ": "off")+" Down="+(down ? "ON ": "off")+" Drag="+(drag ? "ON ": "off")+" Capturado="+(capturado ? "ON ": "off"));
  }
}