#include "colors.inc"
#include "stones.inc"
#include "finish.inc"

// ======================================================================
// CÂMERA 

camera {
  location  <  5.00, 15.00, 5.00 >  // Posição do observador.
  right     1.0*x                 // Largura RELATIVA da imagem.
  up        0.75*y                 // Altura RELATIVA da imagem.      
  sky       z                      // Qual direção é "para cima"?
  look_at   <  0.00, 0.00, 0.00 >  // Para onde a câmera está apontando.
} 
// Nota: os parâmetros "right" e "up" devem ter a mesma proporção
// que os parâmetros ${WIDTH} e ${HEIGHT} no Makefile.

// ======================================================================
// FONTES DE LUZ

light_source {
  10 * < +50.0, +50.0, +50.0 >              // Posição da lâmpada.
  color rgb 1.2 * < 1.00, 1.00, 1.00 >   // Intensidade e corda luz.
} 

light_source {
  10 * < +50.0, -10.0, +10.0 >             // Posição da lâmpada.
  color rgb 0.8 * < 1.00, 1.00, 1.00 >   // Intensidade e corda luz.
} 

// ======================================================================
// DESCRIÇÃO DA CENA 

background{ color rgb < 0.75, 0.80, 0.85 > }

#declare tinta_Verde = 
  texture {
    pigment { color rgb < 0.00, 0.80, 0.00 > }
    finish { diffuse 0.5 specular 0.5 roughness 0.005 ambient 0.1 }
  }

#declare chao =
  plane {
    <0,0,1>,
    -2.0
    texture { T_Stone25 scale 4 }
  }  

#declare corpo =
  union {
    cone {
      <0,0,0>,1.0
      <0,0,3>,0.5
      open
    }
    sphere {
      < 0.00, 0.00, 0.00 >, 1.00 
    }
    pigment { granite }
    scale <1.0,0.7,0.7>
    translate <0,0,3>
  }
  

#declare mao = 
  cone {
    <0,0,0>, 0.25
    <0.5,0,0>, 0.15
    texture { tinta_Verde }
  }

#macro antes_mao(alfa)
  union {
    cylinder {
      <0,0,0>,
      <1,0,0>
      0.15
      texture { tinta_Verde }
    }
    sphere {
      <1,0,0>,
      0.15
      texture { tinta_Verde }
    }
    object {
      mao
      rotate alfa*y
      translate <1,0,0>
    }
  }
#end

#macro quase_fim(alfa,beta)
  union {
    cylinder {
      <0,0,0>,
      <1,0,0>
      0.15
      texture { tinta_Verde }
    }
    sphere {
      <1,0,0>,
      0.15
      texture { tinta_Verde }
    }
    object {
      antes_mao(alfa)
      rotate beta*z
      translate <1,0,0>
    }
  }
#end

#macro membro(alfa,beta,gama)
  union {
    cylinder {
      <0,0,0>,
      <1,0,0>
      0.15
      texture { tinta_Verde }
    }
    sphere {
      <1,0,0>,
      0.15
      texture { tinta_Verde }
    }
    object {
      quase_fim(alfa,beta)
      rotate gama*z
      translate <1,0,0>
    }
  }
#end

#declare antena = 
  union {
    cylinder {
      <0,0,0>,
      <0,0,1>
      0.05
      texture { tinta_Verde }
      translate <0.2,0,5.6>
    }
    sphere {
      <0,0,0>,
      0.06
      texture { tinta_Verde }
      translate <0.2,0,6.6>
    }
  }

#declare olho =
  cylinder {
    <0,0,0>,
    <0,0.2,0>
    0.25
    pigment { checker color rgb <0,0,0>, color rgb <0.9,0.9,0.9> scale 0.15 }
    translate <-0.4,0.5,5.5>
  }

#declare cabeca =
  union {
    sphere {
      <0,0,0>, 0.7
      translate <0,0,5.2>
      texture { tinta_Verde }
    }
    //object { olho }
    //object { olho scale <-1,1,1> }
    object { antena }
    object { antena scale <-1,1,1> }
  }

// Cena:

#declare clock0 = clock;
#declare clock1 = mod(clock + 0.5,1);

object { chao }

#declare tudo =
union {
  object { corpo }
  object { cabeca }
  
  #declare posicoes = array[6]
  #declare posicoes[0] = <0.5,0,4.5>;
  #declare posicoes[1] = <-0.5,0,4.5>;
  #declare posicoes[2] = <0.5,0,3.5>;
  #declare posicoes[3] = <-0.5,0,3.5>;
  #declare posicoes[4] = <0.5,0,2.5>;
  #declare posicoes[5] = <-0.5,0,2.5>;

  #declare conta = 0;
  #while (conta < 6)
    #if ((conta=0)|(conta=3)|(conta=4))
      #declare clock_u = clock0;
    #end
    #if ((conta=1)|(conta=2)|(conta=5))
      #declare clock_u = clock1;
    #end

    #if (clock_u > 1/2)
      #declare alfa = 0;
    #else
      #declare alfa= -75*sin(2*pi*clock_u);
    #end
    #declare beta = 45;
    #declare gama = 45;
    #declare delta = -20*sin(pi*clock_u) + 10;

    object { 
      membro(alfa,beta,gama)
      rotate delta*y
      #if ((conta=1)|(conta=3)|(conta=5))
        scale <-1,1,1>
      #end
      translate posicoes[conta]
    }
    #declare conta = conta + 1;
  #end
}

  object { tudo rotate -90*x translate <0,0,0.3>}