// Exemplo de arquivo de descricao de ANIMAÇÃO para POV-ray
// Last edited on 2009-09-24 15:40:22 by stolfi

#macro quadro(tt)
// Gera o quadro do filme (cena, luzes e câmera) 
// para o instante {tt} -- um número real entre 0 e 1.

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

camera {
  location  <  10.00, 6.00, -2.00 >  // Posição do observador.
  right     -1.00*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, +30.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 raio = 2.000;

// Um parãmetro que varia {+1, 00, -1, 00, +1}:
#declare ctt = cos(2*pi*tt);

// Um parâmetro que varia {00, +1, 00, -1, 00}:  
#declare stt = sin(2*pi*tt);

#declare tinta_A = 
  texture {
    pigment { color rgb < 0.55 + 0.45*ctt, 0.80, 0.55 - 0.5*ctt > }
    finish { diffuse 0.5 specular 0.5 roughness 0.005 ambient 0.1 }
  }

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


#macro pe () 
  cylinder {
    < 0.0, 0.0, 0.0 >,
    < 0.00, 0.8, 0.0 >,
    0.2
    texture { tinta_A }
  }
 #end
 
 #macro canela (gama) 
 union{
  cylinder {
    < 0.0, 0.0, 0.1 >,
    < 0.00, 0.0, -1.0 >,
    0.2
    texture { tinta_A }
  }
  object {pe() rotate gama*x translate -0.9*z}
  }
 #end
    
#macro perna (beta, gama) 
union{
  cylinder {
    < 0.0, 0.0, 0.2 >,
    < 0.00, 0.0, -1.50 >,
    0.2
    texture { tinta_B }
  }
  object {canela (gama) rotate beta*x translate -1.5*z}
 }
 #end 
 
 #macro bicho (alfa, beta, gama) 
union{
  sphere {
    < 1, 1, 1.60 >, 0.90 
    texture { tinta_A }
  }
  box{
	<0.00, 0.00, 0.00 >,
	<2.00, 2.00, 2.00 >
	texture { tinta_B }
  }
  object {perna (beta, gama) rotate alfa*x translate 1.5*y translate 1.5*x translate 0.2*z}
 }
 #end  
  
// Aqui está a cena, finalmente:


#declare t0 = 0.0;
#declare t1 = 0.25;
#declare t2 = 0.50;
#declare t3 = 0.750;
#declare t4 = 1.0;
#declare alfa0 = 45.0;
#declare alfa1 = 60.0;
#declare alfa2 = 0.0;
#declare alfa3 = 30.0;
#declare alfa4 = 45.0;
#declare beta0 = -90.0;
#declare beta1 = -120.0;
#declare beta2 = 0.0;
#declare beta3 = -60.0;
#declare beta4 = -90.0;
#declare gama0 = 45.0;
#declare gama1 = 60.0;
#declare gama2 = 0.0;
#declare gama3 = 30.0;
#declare gama4 = 45.0;




#macro interpola (ta, va, tb, vb, tt)
	#local s= (tt-ta)/(tb-ta);
	((1-s)*va+s*vb)
#end

#if ((clock >= t0)&(clock <= t1))
	#declare alfa = interpola (t0, alfa0, t1, alfa1,clock);
	#declare	beta = interpola (t0, beta0, t1, beta1,clock);
	#declare	gama = interpola (t0, gama0, t1, gama1,clock);
	object { bicho (alfa, beta, gama) translate 1*z}
	
#end

#if ((clock >= t1)&(clock <= t2))
	#declare alfa = interpola (t1, alfa1, t2, alfa2,clock);
	#declare	beta = interpola (t1, beta1, t2, beta2,clock);
	#declare	gama = interpola (t1, gama1, t2, gama2,clock);
	object { bicho (alfa, beta, gama) translate 1*z}
#end
#if ((clock >= t2)&(clock <= t3))
	#declare alfa = interpola (t2, alfa2, t3, alfa3,clock);
	#declare	beta = interpola (t2, beta2, t3, beta3,clock);
	#declare	gama = interpola (t2, gama2, t3, gama3,clock);
	object { bicho (alfa, beta, gama) translate 1*z}
#end
#if ((clock >= t3)&(clock <= t4))
	#declare alfa = interpola (t3, alfa3, t4, alfa4,clock);
	#declare	beta = interpola (t3, beta3, t4, beta4,clock);
	#declare	gama = interpola (t3, gama3, t4, gama4,clock);
	object { bicho (alfa, beta, gama) translate 1*z}
#end
union {
    //object { bola }
    //object { corpo}
   // object { bicho (alfa, beta, gama) translate 1*z}
    //object { bico translate <0,0,sin(2*pi*tt)>}
    //object { asa1 rotate <37*sin(2*pi*tt),0,0>}
    //object { asa2 rotate <-37*sin(2*pi*tt),0,0>}
  }

#end

// gera o quadro correspondente ao instante dado {clock}:
quadro(clock)