// Desenho do vírus com tentáculos
// Last edited on 2020-12-02 22:35:00 by Guilherme Londe

// ======================================================================
// CORES E TEXTURAS

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

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

#declare tx_verde = 
  texture{
    pigment{ color rgb < 0.10, 0.80, 0.10 > }
    finish{ diffuse 0.9 ambient 0.1 }
  }

#declare tx_rubi =
  texture{
    pigment{ color rgb < 0.700, 0.900, 0.900 > filter 0.990 }
    finish{ diffuse 0.01 ambient 0.02
    reflection 0.15 specular 0.35 roughness 0.005 }
  }
  
#declare tx_fixa = 
  texture{
    pigment{ color rgb < 0.600, 0.000, 0.000 > }
    finish{ diffuse 0.0 ambient 1.0 }
  }

#declare tx_xadrez =
  texture{
    pigment{ checker color rgb < 0.600, 0.600, 0.600 >, color rgb < 0.900, 0.900, 0.900 > }
    finish{ diffuse 0.9 ambient 0.1 }
    scale 0.5
  }

// ======================================================================
// DESCRICAO

// Partes da cena:
 
#macro interpola1(tt, tt0, tt1, vv0, vv1)
  #local rr = (tt - tt0)/(tt1 - tt0);
  #local vv = (1-rr)*vv0 + rr*vv1;
  vv
#end

#macro interpola3(tt, tt0, tt3, vv0, vv1, vv2, vv3)
  #local vv01 = interpola1(tt, tt0, tt3, vv0, vv1);
  #local vv12 = interpola1(tt, tt0, tt3, vv1, vv2);
  #local vv23 = interpola1(tt, tt0, tt3, vv2, vv3);
  #local vv012 = interpola1(tt, tt0, tt3, vv01, vv12);
  #local vv123 = interpola1(tt, tt0, tt3, vv12, vv23);
  #local vv0123 = interpola1(tt, tt0, tt3, vv012, vv123);
  vv0123
#end

#macro segmento(p0, p1, p2, p3, n, r0, rn)
  union{
  #local tt = 0;
  #while(tt < n)
    #local r = interpola1(tt, 0, n-1, r0, rn);
    
    #local px = interpola3(tt, 0, n-1, p0.x, p1.x, p2.x, p3.x);
    #local py = interpola3(tt, 0, n-1, p0.y, p1.y, p2.y, p3.y);
    #local pz = interpola3(tt, 0, n-1, p0.z, p1.z, p2.z, p3.z); 
    
    sphere{<px, py, pz>, r texture{pigment{ color rgb<1.0-r, 0.5-r*0.2, 1.0-r*0.7>} finish{ diffuse 0.9 ambient 0.1} } }

    #local tt = tt+1;
  #end
  }
#end

#macro tentaculo(N, RA0, RC3, p0, p1, p2, p4, p5, p7, p8, p9)
  union{
    #local p3 = <(p2.x+p4.x)/2.0, (p2.y+p4.y)/2.0, (p2.z+p4.z)/2.0>;
    #local p6 = <(p5.x+p7.x)/2.0, (p5.y+p7.y)/2.0, (p5.z+p7.z)/2.0>;

    #local RB0 = interpola1(1/3, 0, 1, RA0, RC3);
    #local RC0 = interpola1(2/3, 0, 1, RA0, RC3);
    
    object{segmento(p0,p1,p2,p3,N,RA0,RB0)}
    object{segmento(p3,p4,p5,p6,N,RB0,RC0)}
    object{segmento(p6,p7,p8,p9,N,RC0,RC3)}
  }
#end

#macro interpola_hermite3H(tt, t0,t1, p0,d0,d1,p1)
  #local rr = (tt - t0)/(t1 - t0);
  #local ss = 1 - rr;
  #local ph0 = rr*rr*(2*rr - 3) + 1;
  #local dh0 = + rr*ss*ss * (t1 - t0);
  #local dh1 = - ss*rr*rr * (t1 - t0);
  #local ph1 = ss*ss*(2*ss - 3) + 1;
  #local pp = ph0*p0 + dh0*d0 + dh1*d1 + ph1*p1;
  pp
#end

#macro tentaculo_hermite(N, tt, t0, t1, A0, A1H, A2H, B1H, B2H, C1H, C2H, C3H, RA0, RC3)
  #local p0 = A0;

  #local p1 = interpola_hermite3H(tt, t0, t1, A1H[0], A1H[1], A1H[2], A1H[3]);
  #local p2 = interpola_hermite3H(tt, t0, t1, A2H[0], A2H[1], A2H[2], A2H[3]);
  #local p4 = interpola_hermite3H(tt, t0, t1, B1H[0], B1H[1], B1H[2], B1H[3]);
  #local p5 = interpola_hermite3H(tt, t0, t1, B2H[0], B2H[1], B2H[2], B2H[3]);
  #local p7 = interpola_hermite3H(tt, t0, t1, C1H[0], C1H[1], C1H[2], C1H[3]);
  #local p8 = interpola_hermite3H(tt, t0, t1, C2H[0], C2H[1], C2H[2], C2H[3]);
  #local p9 = interpola_hermite3H(tt, t0, t1, C3H[0], C3H[1], C3H[2], C3H[3]);
  object{tentaculo(N, RA0, RC3, p0, p1, p2, p4, p5, p7, p8, p9)}
#end

#macro encontra_intervalo(tt, NQ,TQ)
  #local k0 = 0; // Por via das duvidas.
  #local kq = 0;
  #while (kq < NQ)
    #if ((TQ[kq] <= tt) & (tt <= TQ[kq+1]))
      #local k0 = kq;
    #end
    #local kq = kq + 1;
  #end
  k0
#end

#macro tentaculo_anim(N,tt, A0, NQ,TQ, PA1,DA1, PA2,DA2, PB1,DB1, PB2,DB2, PC1,DC1, PC2,DC2, PC3,DC3, RA0,RC3)
  // Determina os quadros chave a interpolar k0,k1 e os tempos t0,t1:
  #local k0 = encontra_intervalo(tt, NQ, TQ); #local k1 = mod(k0 + 1, NQ);
  #local t0 = TQ[k0]; #local t1 = TQ[k0 + 1];
  // Pega posicoes e velocidades nesses dois quadros chave:
  #local A1H = array[4];
  #local A1H[0] = PA1[k0];
  #local A1H[1] = DA1[k0];
  #local A1H[2] = DA1[k1];
  #local A1H[3] = PA1[k1];
  #local A2H = array[4];
  #local A2H[0] = PA2[k0];
  #local A2H[1] = DA2[k0];
  #local A2H[2] = DA2[k1];
  #local A2H[3] = PA2[k1];
  #local B1H = array[4];
  #local B1H[0] = PB1[k0];
  #local B1H[1] = DB1[k0];
  #local B1H[2] = DB1[k1];
  #local B1H[3] = PB1[k1];
  #local B2H = array[4];
  #local B2H[0] = PB2[k0];
  #local B2H[1] = DB2[k0];
  #local B2H[2] = DB2[k1];
  #local B2H[3] = PB2[k1];
  #local C1H = array[4];
  #local C1H[0] = PC1[k0];
  #local C1H[1] = DC1[k0];
  #local C1H[2] = DC1[k1];
  #local C1H[3] = PC1[k1];
  #local C2H = array[4];
  #local C2H[0] = PC2[k0];
  #local C2H[1] = DC2[k0];
  #local C2H[2] = DC2[k1];
  #local C2H[3] = PC2[k1];
  #local C3H = array[4];
  #local C3H[0] = PC3[k0];
  #local C3H[1] = DC3[k0];
  #local C3H[2] = DC3[k1];
  #local C3H[3] = PC3[k1];
// Gera o tentaculo entre esses dois quadros chave:
  object{ tentaculo_hermite(N, tt,t0,t1, A0, A1H,A2H,B1H,B2H,C1H,C2H,C3H, RA0,RC3)}
#end

#macro ranvec(sem)
  #local vv = < 2*rand(sem)-1, 2*rand(sem)-1, 2*rand(sem)-1 >;
  vv
#end

#macro tentaculo_aleatorio_anim(tf, N, ss, A0,Z3,RA0,RC3)
    #declare sem = seed(ss);
    #local NQ = 3; // Quadros-chave excluindo final (= inicial).
    #local TQ = array[NQ+1]; // Tempos dos quadros-chave
    #local TQ[0] = 0.0000; // Inicio da animacao.
    #local TQ[1] = 0.3333; // Fim do primeiro movimento.
    #local TQ[2] = 0.6667; // Fim do segundo movimento.
    #local TQ[3] = 1.0000; // Fim da animacao.
    // Gera posicoes e velocidades aleatorias do tentaculo para quadros-chave
    #local PA1 = array[NQ]; #local DA1 = array[NQ];
    #local PA2 = array[NQ]; #local DA2 = array[NQ];
    #local PB1 = array[NQ]; #local DB1 = array[NQ];
    #local PB2 = array[NQ]; #local DB2 = array[NQ];
    #local PC1 = array[NQ]; #local DC1 = array[NQ];
    #local PC2 = array[NQ]; #local DC2 = array[NQ];
    #local PC3 = array[NQ]; #local DC3 = array[NQ];
  
    #local mP = 0.5*vlength(Z3 - A0);
    #local mV = 4.0*vlength(Z3 - A0);


    #local kq = 0;
    #while (kq < NQ)
      #local PA1[kq] = interpola1(1/9, 0,1, A0,Z3) + (1/9)*mP*ranvec(sem);
      #local DA1[kq] = (1/9)*mV*ranvec(sem);
      #local PA2[kq] = interpola1(2/9, 0,1, A0,Z3) + (2/9)*mP*ranvec(sem);
      #local DA2[kq] = (2/9)*mV*ranvec(sem); 
      #local PB1[kq] = interpola1(4/9, 0,1, A0,Z3) + (4/9)*mP*ranvec(sem);
      #local DB1[kq] = (4/9)*mV*ranvec(sem);
      #local PB2[kq] = interpola1(5/9, 0,1, A0,Z3) + (5/9)*mP*ranvec(sem);
      #local DB2[kq] = (5/9)*mV*ranvec(sem);
      #local PC1[kq] = interpola1(7/9, 0,1, A0,Z3) + (7/9)*mP*ranvec(sem);
      #local DC1[kq] = (7/9)*mV*ranvec(sem);
      #local PC2[kq] = interpola1(8/9, 0,1, A0,Z3) + (8/9)*mP*ranvec(sem);
      #local DC2[kq] = (8/9)*mV*ranvec(sem);
      #local PC3[kq] = Z3 + mP*ranvec(sem);
      #local DC3[kq] = mV*ranvec(sem);
      #local kq = kq + 1;
    #end

    object{ tentaculo_anim(N, tf, A0, NQ,TQ, PA1,DA1, PA2, DA2, PB1, DB1, PB2, DB2, PC1, DC1, PC2, DC2, PC3,DC3, RA0,RC3) }
#end

#macro virus(tf)
  union{
    #declare roleta = seed(1111);
    sphere{ <0,0,0>, 5 texture{pigment{ color rgb<0.1, 0.3, 0.2>} finish {diffuse 0.9 ambient 0.1 } } }
    #local j = 0;
    #while (j < 40)
      #local sx = rand(roleta)-0.5;
      #local sy = rand(roleta)-0.5;
      #local sz = rand(roleta)-0.5;

      #local lamb = 5.0/sqrt((sx*sx)+(sy*sy)+(sz*sz));      
      sphere{ <sx*lamb, sy*lamb, sz*lamb>, 0.6 texture{pigment { color rgb<0.5, 0.1, 0> } finish {diffuse 0.9 ambient 0.1 } } }

      #local j = j+1;
    #end
    object{tentaculo_aleatorio_anim(tf, 300, 123, <0, 0, -5>, <0, 0, -35>, 1, 0.25)}
    object{tentaculo_aleatorio_anim(tf, 300, 125, <0, 0, 5>, <0, 0, 35>, 1, 0.25)}
    object{tentaculo_aleatorio_anim(tf, 300, 127, <0, -5, 0>, <0, -35, 0>, 1, 0.25)}
    object{tentaculo_aleatorio_anim(tf, 300, 129, <0, 5, 0>, <0, 35, 0>, 1, 0.25)}
    object{tentaculo_aleatorio_anim(tf, 300, 131, <-5, 0, 0>, <-35, 0, 0>, 1, 0.25)}
    object{tentaculo_aleatorio_anim(tf, 300, 133, <5, 0, 0>, <35, 0, 0>, 1, 0.25)} 
  } 
#end

#macro texto(tf, tx)
  #local py = interpola1(tf, 0, 1, 6, -15);
  object{
    text{
      ttf "ttf/arial.ttf"
      tx
      0.25, 0
      texture{ tx_fixa }
    }

    scale<1.0, 1.0, 1.0>
    rotate<90, 0, 90>
    translate<0, py, 0>
  }
#end

#macro pote()
  difference{
    union{
      object{sphere{<0,0,0>, 47 texture{tx_rubi} interior{ior 1.15} } }
    }
    object{sphere{<0,0,0>, 46 texture{tx_rubi} } }
  }
#end

#macro chao()
  object{
    box{ < -100, -100, -46 >, < +100, +100, -45 > texture{ tx_xadrez } }
    scale <1, 1, 1>
  }
#end

#macro call_texto(tf)
  object{texto(tf, "APOCALIPSEVIRUS") scale<0.75, 0.75, 0.75> translate<0, 0, -2>}
#end

#include "eixos.inc"

// Aqui esta a cena, finalmente:

#include "frontal.inc"

#include "camlight.inc"
#declare raio_cena = 80.0;
#declare centro_cena = < 3.00, 3.00, 3.00 >;
#declare dir_camera = < 1.20, 1.40, 0.30 >;
#declare dist_camera = 15*raio_cena;
#declare intens_luz = 1.20;
camlight(centro_cena, raio_cena, dir_camera, dist_camera , z, intens_luz)
#declare dist_overlay = 0.94*dist_camera;

union{
  object{ eixos(3.00) }
  object{ chao() }
  object{ virus(clock)}
  object{ pote()}
  //chamar call_texto(clock)
  object{ frontal(call_texto(0.5), centro_cena, dir_camera, dist_overlay, z) }
}