// 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  <  8.00, 4.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.
} 

// ======================================================================

#declare tx_violet = 
  texture{
    pigment{ color rgb < 0.54, 0.17, 0.88 > }
    finish{ diffuse 0.9 ambient 0.1 }
  }

#declare tx_yellow = 
  texture{
    pigment{ color rgb < 1.0, 1.0, 0.0 > }
    finish{ diffuse 0.9 ambient 0.1 }
  }

#declare tx_green = 
  texture{
    pigment{ color rgb < 0.0, 1.0, 0.0 > }
    finish{ diffuse 0.9 ambient 0.1 }
  }

#declare tx_blue = 
  texture{
    pigment{ color rgb < 0.0, 0.0, 1.0 > }
    finish{ diffuse 0.9 ambient 0.1 }
  }

// DESCRIÇÃO DA CENA 

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

#declare raio = 2.000;

//Declara angulos das articulacoes
#declare angCorpo = abs(45*sin(2*pi*tt));

#declare angCoxa = -abs(80*sin(2*pi*tt));

#declare angPeh = abs(40*sin(2*pi*tt));

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

#declare t0=0.000;
#declare t1=0.250;
#declare t2=0.500;
#declare t3=0.750;
#declare t4=1.000;

#declare alfa0 = 0;
#declare alfa1 = 45;
#declare alfa2 = 45;
#declare alfa3 = 0;
#declare alfa4 = 0;

#declare beta0 = 0;
#declare beta1 = -80;
#declare beta2 = -80;
#declare beta3 = 0;
#declare beta4 = 0;

#declare gama0 = 0;
#declare gama1 = 40;
#declare gama2 = 40;
#declare gama3 = -30;
#declare gama4 = -30;

#declare trans0 = -4;
#declare trans1 = -4;
#declare trans2 = 0;
#declare trans3 = 4;
#declare trans4 = 8;

#declare h0 = 0;
#declare h1 = 1;
#declare h2 = 2;
#declare h3 = 1;
#declare h4 = 0;

#if((tt >= t0) & (tt <= t1))
	#declare alfa = interpola(t0,alfa0,t1,alfa1,tt);
	#declare beta = interpola(t0,beta0,t1,beta1,tt);
	#declare gama = interpola(t0,gama0,t1,gama1,tt);
	#declare trans = interpola(t0,trans0,t1,trans1,tt);
	#declare h = interpola(t0,h0,t1,h1,tt);
#end

#if((tt >= t1) & (tt <= t2))
	alfa = interpola(t1,alfa1,t2,alfa2,tt);
	beta = interpola(t1,beta1,t2,beta2,tt);
	gama = interpola(t1,gama1,t2,gama2,tt);
	trans = interpola(t1,trans1,t2,trans2,tt);
	h = interpola(t1,h1,t2,h2,tt);
#end

#if((tt >= t2) & (tt <= t3))
	alfa = interpola(t2,alfa2,t3,alfa3,tt);
	beta = interpola(t2,beta2,t3,beta3,tt);
	gama = interpola(t2,gama2,t3,gama3,tt);
	trans = interpola(t2,trans2,t3,trans3,tt);
	h = interpola(t2,h2,t3,h3,tt);
#end

#if((tt >= t3) & (tt <= t4))
	alfa = interpola(t3,alfa3,t4,alfa4,tt);
	beta = interpola(t3,beta3,t4,beta4,tt);
	gama = interpola(t3,gama3,t4,gama4,tt);
	trans = interpola(t3,trans3,t4,trans4,tt);
	h = interpola(t3,h3,t4,h4,tt);
#end

// 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 chassis =
	box{ <2,-2, 2>, <-2,2,3> texture {tx_violet} }

#declare coxa =
	cone{ <0,0,0> , 0.5
				<0,0,-2>, 0.5
				texture{ tx_yellow }
	} 

#declare canela =
	cone{ <0,0,0> , 0.5
				<0,0,-2>, 0.5
				texture{ tx_blue }
	}

#macro carro(alfa, beta, gama)
	union{
		object{ chassis }
		object{ perna(beta, gama) rotate<alfa,0,0> translate 2*z }
	}
#end

#macro perna(beta, gama)
	union{
		object{coxa }
		object{ anteperna(gama) rotate<beta,0,0> translate -2*z}
	}
#end

#macro anteperna(gama)
	union{	
		object{ canela }
		object{ peh() rotate <gama,0,0> translate -2*z}
	}
#end

#macro peh()
	union{
		box{ <-1,-0.5,0>, <1,1.5,-0.5>
				texture{ tx_green }	
		}
	}
#end

// Aqui está a cena, finalmente:

//object{ chassis }
//object{ coxa }
//object{ canela }
object{ carro(angCorpo,angCoxa,angPeh) translate <0,0,0> }

#end

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