// Exemplo de arquivo de descricao de cena para POV-ray
// Last edited on 2022-01-06 15:34:51 by stolfi


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

#version 3.7;

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

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

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

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

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

#declare tx_vidro_verde = 
  texture{
    pigment{ color rgb < 0.00, 1.00, 0.00 > filter 0.70 }
    finish{ diffuse 0.03 reflection 0.25 ambient 0.02 specular 0.25 roughness 0.005 }
  }

#declare tx_fosca_vermelha = 
  texture{
    pigment{ color rgb <1.00, 0.20, 0.20> }
    finish{ diffuse 0.9 ambient 0.1 }
  }

#declare tx_xadrez =
  texture{
    pigment{ checker color rgb < 0.15, 0.20, 0.65 >, color rgb < 0.10, 0.97, 0.90 > }
    finish{ diffuse 0.9 ambient 0.1 }
    scale 2.0
  }

// ======================================================================
// MACROS

#macro segtaculo(
  num_esferas, 
  ponto_0, raio_0, 
  ponto_1, raio_1, 
  ponto_2, raio_2, 
  ponto_3, raio_3
)
  #local pedaco_0 = 0;
  #local pedaco_1 = num_esferas/4;
  #local pedaco_2 = 2 * num_esferas/4;
  #local pedaco_3 = 3 * num_esferas/4;
  #local pedaco_4 = num_esferas;
  union{
    #local contador = 0;
    #while (contador < num_esferas)
      #if ((contador >= pedaco_0) & (contador <= pedaco_1))
        #local pedaco_a = pedaco_0;
        #local pedaco_b = pedaco_1;
      #elseif ((contador > pedaco_1) & (contador <= pedaco_2))
        #local pedaco_a = pedaco_1;
        #local pedaco_b = pedaco_2;
      #elseif ((contador > pedaco_2) & (contador <= pedaco_3))
        #local pedaco_a = pedaco_2;
        #local pedaco_b = pedaco_3;
      #elseif ((contador > pedaco_3) & (contador <= pedaco_4))
        #local pedaco_a = pedaco_3;
        #local pedaco_b = pedaco_4;
      #end
      #local raio_atual = interpola_bezier(
        contador, 
        pedaco_a, 
        pedaco_b, 
        raio_0, 
        raio_1, 
        raio_2, 
        raio_3
      );
      #debug concat("raio = ", str(raio_atual,0,4), "\n")
      #local ponto_atual = interpola_bezier(
        contador, 
        pedaco_a, 
        pedaco_b, 
        ponto_0, 
        ponto_1, 
        ponto_2, 
        ponto_3
      );
      #debug concat("ponto = <", str(ponto_atual.x,0,4), ",", str(ponto_atual.y,0,4), ",", str(ponto_atual.z,0,4), ">\n")
      sphere {
        ponto_atual, raio_atual
        texture { tx_fosca_amarela }
      }
      #local contador = contador + 1;
    #end
  }
#end

#macro tentaculo(num_esferas_por_segmento, numero_de_segmentos, pontos, raios)

  union{
    #local contador = 0;
    #while (contador < numero_de_segmentos)
      object{ segtaculo(
          (num_esferas_por_segmento), 
          pontos[contador][0], raios[contador][0], 
          pontos[contador][1], raios[contador][1], 
          pontos[contador][2], raios[contador][2], 
          pontos[contador][3], raios[contador][3] 
        )
      }
      #local contador = contador + 1;
    #end
  }
  
#end

#macro pontos_tentaculo_dado_0()

  #local numero_de_segmentos = 4;
  #local pontos_dados_por_segmento = 4;
  #local pontos_dados = array[numero_de_segmentos][pontos_dados_por_segmento]

  #local pontos_dados[0][0] = <0, 0, 0>;
  #local pontos_dados[0][1] = <0, 15, 10>;
  #local pontos_dados[0][2] = <0, 30, 10>;

  #local pontos_dados[1][1] = <0, 75, 20>;
  #local pontos_dados[1][2] = <0, 90, 18>;

  #local pontos_dados[2][1] = <0, 135, -10>;
  #local pontos_dados[2][2] = <0, 150, -5>;

  #local pontos_dados[3][1] = <0, 195, 10>;
  #local pontos_dados[3][2] = <0, 210, 5>;
  #local pontos_dados[3][3] = <0, 225, 10>;

  #local contador = 1;
  #while (contador < numero_de_segmentos)
    #local posicao_media = ponto_medio(
      pontos_dados[contador - 1][2], 
      pontos_dados[contador][1]
    );
    #local pontos_dados[contador - 1][3] = posicao_media;
    #local pontos_dados[contador][0] = posicao_media;
    #local contador = contador + 1;
  #end

  pontos_dados

#end

#macro pontos_tentaculo_dado_1()

  #local numero_de_segmentos = 4;
  #local pontos_dados_por_segmento = 4;
  #local pontos_dados = array[numero_de_segmentos][pontos_dados_por_segmento]

  #local pontos_dados[0][0] = <0, 0, 0>;
  #local pontos_dados[0][1] = <0, 15, 5>;
  #local pontos_dados[0][2] = <0, 30, -5>;

  #local pontos_dados[1][1] = <0, 75, -20>;
  #local pontos_dados[1][2] = <0, 90, -35>;
  
  #local pontos_dados[2][1] = <0, 135, 15>;
  #local pontos_dados[2][2] = <0, 150, 25>;
  
  #local pontos_dados[3][1] = <0, 195, 15>;
  #local pontos_dados[3][2] = <0, 210, 30>;
  #local pontos_dados[3][3] = <0, 225, 40>;

  #local contador = 1;
  #while (contador < numero_de_segmentos)
    #local posicao_media = ponto_medio(
      pontos_dados[contador - 1][2], 
      pontos_dados[contador][1]
    );
    #local pontos_dados[contador - 1][3] = posicao_media;
    #local pontos_dados[contador][0] = posicao_media;

    #local contador = contador + 1;
  #end

  pontos_dados

#end

#macro pontos_tentaculo_dado_2()

  #local numero_de_segmentos = 4;
  #local pontos_dados_por_segmento = 4;
  #local pontos_dados = array[numero_de_segmentos][pontos_dados_por_segmento]

  #local pontos_dados[0][0] = <0, 0, 0>;
  #local pontos_dados[0][1] = <0, 15, 5>;
  #local pontos_dados[0][2] = <0, 30, 10>;

  #local pontos_dados[1][1] = <0, 75, 35>;
  #local pontos_dados[1][2] = <0, 90, 50>;
  
  #local pontos_dados[2][1] = <0, 135, 40>;
  #local pontos_dados[2][2] = <0, 150, 20>;
  
  #local pontos_dados[3][1] = <0, 195, 15>;
  #local pontos_dados[3][2] = <0, 190, 30>;
  #local pontos_dados[3][3] = <0, 180, 50>;

  #local contador = 1;
  #while (contador < numero_de_segmentos)
    #local posicao_media = ponto_medio(
      pontos_dados[contador - 1][2], 
      pontos_dados[contador][1]
    );
    #local pontos_dados[contador - 1][3] = posicao_media;
    #local pontos_dados[contador][0] = posicao_media;

    #local contador = contador + 1;
  #end

  pontos_dados

#end

#macro pontos_tentaculo_dado_3()

  #local numero_de_segmentos = 4;
  #local pontos_dados_por_segmento = 4;
  #local pontos_dados = array[numero_de_segmentos][pontos_dados_por_segmento]

  #local pontos_dados[0][0] = <0, 0, 0>;
  #local pontos_dados[0][1] = <0, 15, -10>;
  #local pontos_dados[0][2] = <0, 30, -25>;

  #local pontos_dados[1][1] = <0, 75, -40>;
  #local pontos_dados[1][2] = <0, 90, -25>;
  
  #local pontos_dados[2][1] = <0, 135, -10>;
  #local pontos_dados[2][2] = <0, 150, 0>;
  
  #local pontos_dados[3][1] = <0, 195, 5>;
  #local pontos_dados[3][2] = <0, 190, -20>;
  #local pontos_dados[3][3] = <0, 180, -30>;

  #local contador = 1;
  #while (contador < numero_de_segmentos)
    #local posicao_media = ponto_medio(
      pontos_dados[contador - 1][2], 
      pontos_dados[contador][1]
    );
    #local pontos_dados[contador - 1][3] = posicao_media;
    #local pontos_dados[contador][0] = posicao_media;

    #local contador = contador + 1;
  #end

  pontos_dados

#end

#macro pontos_tentaculo_dado_4()

  #local numero_de_segmentos = 4;
  #local pontos_dados_por_segmento = 4;
  #local pontos_dados = array[numero_de_segmentos][pontos_dados_por_segmento]

  #local pontos_dados[0][0] = <0, 0, -40>;
  #local pontos_dados[0][1] = <0, 15, -10>;
  #local pontos_dados[0][2] = <0, 30, -25>;

  #local pontos_dados[1][1] = <0, 75, -40>;
  #local pontos_dados[1][2] = <0, 90, -25>;
  
  #local pontos_dados[2][1] = <0, 135, -10>;
  #local pontos_dados[2][2] = <0, 150, 0>;
  
  #local pontos_dados[3][1] = <0, 195, 5>;
  #local pontos_dados[3][2] = <0, 190, -20>;
  #local pontos_dados[3][3] = <0, 180, -30>;

  #local contador = 1;
  #while (contador < numero_de_segmentos)
    #local posicao_media = ponto_medio(
      pontos_dados[contador - 1][2], 
      pontos_dados[contador][1]
    );
    #local pontos_dados[contador - 1][3] = posicao_media;
    #local pontos_dados[contador][0] = posicao_media;

    #local contador = contador + 1;
  #end

  pontos_dados

#end

#macro raios_tentaculo_dado_0()
  #local numero_de_segmentos = 4;
  #local pontos_dados_por_segmento = 4;
  #local raios_dados = array[numero_de_segmentos][pontos_dados_por_segmento]

  #local raios_dados[0][0] = 7;
  #local raios_dados[0][1] = 12;
  #local raios_dados[0][2] = 5;

  #local raios_dados[1][1] = 4;
  #local raios_dados[1][2] = 6;
  
  #local raios_dados[2][1] = 15;
  #local raios_dados[2][2] = 12;
  
  #local raios_dados[3][1] = 8;
  #local raios_dados[3][2] = 5;
  #local raios_dados[3][3] = 2;

  #local contador = 1;
  #while (contador < numero_de_segmentos)
    #local raio_medio = ponto_medio(
      raios_dados[contador - 1][2], 
      raios_dados[contador][1]
    );
    #local raios_dados[contador - 1][3] = raio_medio;
    #local raios_dados[contador][0] = raio_medio;
    #local contador = contador + 1;
  #end

  raios_dados

#end

#macro tentaculo_animado(numero_de_esferas_por_segmento, tempo_atual)

  #local numero_de_segmentos = 4;
  #local pontos_dados_por_segmento = 4;
  #local numero_de_quadros_chave = 5 - 1; // Ultimo igual ao primeiro
  
  // #local pontos_dados = array[numero_de_quadros_chave][4][numero_de_segmentos][pontos_dados_por_segmento]
  // #local raios_dados = array[numero_de_quadros_chave][4][numero_de_segmentos][pontos_dados_por_segmento] 

  #local pontos_T = array[numero_de_segmentos][pontos_dados_por_segmento]
  #local raios_T = array[numero_de_segmentos][pontos_dados_por_segmento]

  // Segmentos no tempo
  #local tempo_0 = 0.00;
  #local tempo_1 = 0.25;
  #local tempo_2 = 0.50;
  #local tempo_3 = 0.75;
  #local tempo_4 = 1.00;
  #local tempo_5 = tempo_4 + (tempo_1 - tempo_0);

  // Poses desenhadas como exemplos
  #local pose_0 = pontos_tentaculo_dado_0();
  #local pose_1 = pontos_tentaculo_dado_1();
  #local pose_2 = pontos_tentaculo_dado_2();
  #local pose_3 = pontos_tentaculo_dado_3();
  #local pose_4 = pontos_tentaculo_dado_0();
  #local pose_5 = pontos_tentaculo_dado_1();

  // Raios desenhados como exemplos
  #local diametro_0 = raios_tentaculo_dado_0();
  #local diametro_1 = raios_tentaculo_dado_0();
  #local diametro_2 = raios_tentaculo_dado_0();
  #local diametro_3 = raios_tentaculo_dado_0();
  #local diametro_4 = raios_tentaculo_dado_0();
  #local diametro_5 = raios_tentaculo_dado_0();

  // Calcula os pontos dos tentaculos usados como key frames
  #local pontos_dados_0_1 = calcula_ponto_logo_depois(pose_0, pose_1, numero_de_segmentos, pontos_dados_por_segmento);
  #local pontos_dados_0_2 = calcula_ponto_logo_antes(pose_1, pose_0, numero_de_segmentos, pontos_dados_por_segmento);

  #local pontos_dados_1_1 = calcula_ponto_logo_depois(pose_1, pose_2, numero_de_segmentos, pontos_dados_por_segmento);
  #local pontos_dados_1_2 = calcula_ponto_logo_antes(pose_2, pose_1, numero_de_segmentos, pontos_dados_por_segmento);

  #local pontos_dados_2_1 = calcula_ponto_logo_depois(pose_2, pose_3, numero_de_segmentos, pontos_dados_por_segmento);
  #local pontos_dados_2_2 = calcula_ponto_logo_antes(pose_3, pose_2, numero_de_segmentos, pontos_dados_por_segmento);

  #local pontos_dados_3_1 = calcula_ponto_logo_depois(pose_3, pose_4, numero_de_segmentos, pontos_dados_por_segmento);
  #local pontos_dados_3_2 = calcula_ponto_logo_antes(pose_4, pose_3, numero_de_segmentos, pontos_dados_por_segmento);

  #local pontos_dados_4_1 = calcula_ponto_logo_depois(pose_4, pose_5, numero_de_segmentos, pontos_dados_por_segmento);
  #local pontos_dados_4_2 = calcula_ponto_logo_antes(pose_5, pose_4, numero_de_segmentos, pontos_dados_por_segmento);

  // Calcula os raios dos tentaculos usados como key frames

  #local raios_dados_0_1 = calcula_raio_logo_depois(diametro_0, diametro_1, numero_de_segmentos, pontos_dados_por_segmento);
  #local raios_dados_0_2 = calcula_raio_logo_antes(diametro_1, diametro_0, numero_de_segmentos, pontos_dados_por_segmento);

  #local raios_dados_1_1 = calcula_raio_logo_depois(diametro_1, diametro_2, numero_de_segmentos, pontos_dados_por_segmento);
  #local raios_dados_1_2 = calcula_raio_logo_antes(diametro_2, diametro_1, numero_de_segmentos, pontos_dados_por_segmento);

  #local raios_dados_2_1 = calcula_raio_logo_depois(diametro_2, diametro_3, numero_de_segmentos, pontos_dados_por_segmento);
  #local raios_dados_2_2 = calcula_raio_logo_antes(diametro_3, diametro_2, numero_de_segmentos, pontos_dados_por_segmento);

  #local raios_dados_3_1 = calcula_raio_logo_depois(diametro_3, diametro_4, numero_de_segmentos, pontos_dados_por_segmento);
  #local raios_dados_3_2 = calcula_raio_logo_antes(diametro_4, diametro_3, numero_de_segmentos, pontos_dados_por_segmento);

  #local raios_dados_4_1 = calcula_raio_logo_depois(diametro_4, diametro_5, numero_de_segmentos, pontos_dados_por_segmento);
  #local raios_dados_4_2 = calcula_raio_logo_antes(diametro_5, diametro_4, numero_de_segmentos, pontos_dados_por_segmento);

  #local j = 0;
  #while (j < numero_de_segmentos)
    #local k = 0;
    #while (k < pontos_dados_por_segmento)
      // Prof:

      #local pontos_dados_0_3 = ponto_medio(pontos_dados_0_2[j][k], pontos_dados_1_1[j][k]);
      #local pontos_dados_1_0 = pontos_dados_0_3;

      #local pontos_dados_1_3 = ponto_medio(pontos_dados_1_2[j][k], pontos_dados_2_1[j][k]);
      #local pontos_dados_2_0 = pontos_dados_1_3;

      #local pontos_dados_2_3 = ponto_medio(pontos_dados_2_2[j][k], pontos_dados_3_1[j][k]);
      #local pontos_dados_3_0 = pontos_dados_2_3;

      #local pontos_dados_3_3 = ponto_medio(pontos_dados_3_2[j][k], pontos_dados_4_1[j][k]);
      #local pontos_dados_4_0 = pontos_dados_3_3;

      #local pontos_dados_4_3 = ponto_medio(pontos_dados_4_2[j][k], pontos_dados_0_1[j][k]);
      #local pontos_dados_0_0 = pontos_dados_4_3;

      #local raios_dados_0_3 = ponto_medio(raios_dados_0_2[j][k], raios_dados_1_1[j][k]);
      #local raios_dados_1_0 = raios_dados_0_3;

      #local raios_dados_1_3 = ponto_medio(raios_dados_1_2[j][k], raios_dados_2_1[j][k]);
      #local raios_dados_2_0 = raios_dados_1_3;

      #local raios_dados_2_3 = ponto_medio(raios_dados_2_2[j][k], raios_dados_3_1[j][k]);
      #local raios_dados_3_0 = raios_dados_2_3;

      #local raios_dados_3_3 = ponto_medio(raios_dados_3_2[j][k], raios_dados_4_1[j][k]);
      #local raios_dados_4_0 = raios_dados_3_3;

      #local raios_dados_4_3 = ponto_medio(raios_dados_4_2[j][k], raios_dados_0_1[j][k]);
      #local raios_dados_0_0 = raios_dados_4_3;

      //#local contador = 0;
      //#while (contador < numero_de_segmentos * pontos_dados_por_segmento)
      #if ((tempo_0 <= tempo_atual) & (tempo_atual <= tempo_1))
        #local pontos_T[j][k] = interpola_bezier(
          tempo_atual,
          tempo_0, 
          tempo_1, 
          pontos_dados_0_0,
          pontos_dados_0_1[j][k],
          pontos_dados_0_2[j][k],
          pontos_dados_0_3
        );
        #local raios_T[j][k] = interpola_bezier(
          tempo_atual,
          tempo_0, 
          tempo_1, 
          raios_dados_0_0,
          raios_dados_0_1[j][k],
          raios_dados_0_2[j][k],
          raios_dados_0_3
        );
      #elseif ((tempo_1 <= tempo_atual) & (tempo_atual <= tempo_2))
        #local pontos_T[j][k] = interpola_bezier(
          tempo_atual,
          tempo_1, 
          tempo_2, 
          pontos_dados_1_0,
          pontos_dados_1_1[j][k],
          pontos_dados_1_2[j][k],
          pontos_dados_1_3
        );
        #local raios_T[j][k] = interpola_bezier(
          tempo_atual,
          tempo_1, 
          tempo_2, 
          raios_dados_1_0,
          raios_dados_1_1[j][k],
          raios_dados_1_2[j][k],
          raios_dados_1_3
        );

      #elseif ((tempo_2 <= tempo_atual) & (tempo_atual <= tempo_3))
        #local pontos_T[j][k] = interpola_bezier(
          tempo_atual,
          tempo_2, 
          tempo_3, 
          pontos_dados_2_0,
          pontos_dados_2_1[j][k],
          pontos_dados_2_2[j][k],
          pontos_dados_2_3
        );
        #local raios_T[j][k] = interpola_bezier(
          tempo_atual,
          tempo_2, 
          tempo_3, 
          raios_dados_2_0,
          raios_dados_2_1[j][k],
          raios_dados_2_2[j][k],
          raios_dados_2_3
        );

      #elseif ((tempo_3 <= tempo_atual) & (tempo_atual <= tempo_4))
        #local pontos_T[j][k] = interpola_bezier(
          tempo_atual,
          tempo_3, 
          tempo_4, 
          pontos_dados_3_0,
          pontos_dados_3_1[j][k],
          pontos_dados_3_2[j][k],
          pontos_dados_3_3
        );
        #local raios_T[j][k] = interpola_bezier(
          tempo_atual,
          tempo_3, 
          tempo_4, 
          raios_dados_3_0,
          raios_dados_3_1[j][k],
          raios_dados_3_2[j][k],
          raios_dados_3_3
        );

      #elseif ((tempo_5 <= tempo_atual) & (tempo_atual <= tempo_5))
        #local pontos_T[j][k] = interpola_bezier(
          tempo_atual,
          tempo_4, 
          tempo_5, 
          pontos_dados_4_0,
          pontos_dados_4_1[j][k],
          pontos_dados_4_2[j][k],
          pontos_dados_4_3
        );
        #local raios_T[j][k] = interpola_bezier(
          tempo_atual,
          tempo_4, 
          tempo_5, 
          raios_dados_4_0,
          raios_dados_4_1[j][k],
          raios_dados_4_2[j][k],
          raios_dados_4_3
        );

      #end
        //#local contador = contador + 1;
      // #end
      #debug concat("raio = ", str(raios_T[j][k],0,4), "\n")
      #debug concat("ponto = <", str(pontos_T[j][k].x,0,4), ",", str(pontos_T[j][k].y,0,4), ",", str(pontos_T[j][k].z,0,4), ">\n")

      #local k = k + 1;
    #end
    #local j = j + 1;
  #end

  #local tent = object{
    tentaculo(numero_de_esferas_por_segmento, numero_de_segmentos, pontos_T, raios_T)
  }
  
  tent

#end

#macro calcula_ponto_logo_antes(ponto_atual, ponto_anterior, numero_de_segmentos, numero_de_pontos)
  #local resultado = array[numero_de_segmentos][numero_de_pontos]
  #local contador_a = 0;
  #while (contador_a < numero_de_segmentos)
    #local contador_b = 0;
    #while (contador_b < numero_de_pontos)
      #local resultado[contador_a][contador_b] = ponto_atual[contador_a][contador_b] - <0, 15, 15>;
      #local contador_b = contador_b + 1;
    #end
    #local contador_a = contador_a + 1;
  #end
  resultado
#end

#macro calcula_ponto_logo_depois(ponto_atual, ponto_depois, numero_de_segmentos, numero_de_pontos)
  #local resultado = array[numero_de_segmentos][numero_de_pontos]
  #local contador_a = 0;
  #while (contador_a < numero_de_segmentos)
    #local contador_b = 0;
    #while (contador_b < numero_de_pontos)
      #local resultado[contador_a][contador_b] = ponto_atual[contador_a][contador_b] + <0, 15, 15>;
      #local contador_b = contador_b + 1;
    #end
    #local contador_a = contador_a + 1;
  #end
  resultado
#end

#macro calcula_raio_logo_antes(ponto_atual, ponto_anterior, numero_de_segmentos, numero_de_pontos)
  #local resultado = array[numero_de_segmentos][numero_de_pontos]
  #local contador_a = 0;
  #while (contador_a < numero_de_segmentos)
    #local contador_b = 0;
    #while (contador_b < numero_de_pontos)
      #local resultado[contador_a][contador_b] = ponto_atual[contador_a][contador_b] - 2;
      #local contador_b = contador_b + 1;
    #end
    #local contador_a = contador_a + 1;
  #end
  resultado
#end

#macro calcula_raio_logo_depois(ponto_atual, ponto_depois, numero_de_segmentos, numero_de_pontos)
  #local resultado = array[numero_de_segmentos][numero_de_pontos]
  #local contador_a = 0;
  #while (contador_a < numero_de_segmentos)
    #local contador_b = 0;
    #while (contador_b < numero_de_pontos)
      #local resultado[contador_a][contador_b] = ponto_atual[contador_a][contador_b] + 2;
      #local contador_b = contador_b + 1;
    #end
    #local contador_a = contador_a + 1;
  #end
  resultado
#end

#macro ponto_medio(ponto_a, ponto_b)
  #local novo_ponto = (ponto_a + ponto_b) / 2;
  novo_ponto
#end

#macro interpola_afim(tempo_atual, tempo_anterior, tempo_posterior, valor_anterior, valor_posterior)
  #local coef_ang = (tempo_atual - tempo_anterior) / (tempo_posterior - tempo_anterior);
  #local novo_valor = (1 - coef_ang) * valor_anterior + coef_ang * valor_posterior;
  novo_valor
#end

#macro interpola_bezier(tempo_atual, tempo_0, tempo_3, valor_0, valor_1, valor_2, valor_3)
  #local valor_0_1 = interpola_afim(tempo_atual, tempo_0, tempo_3, valor_0, valor_1);
  #local valor_1_2 = interpola_afim(tempo_atual, tempo_0, tempo_3, valor_1, valor_2);
  #local valor_2_3 = interpola_afim(tempo_atual, tempo_0, tempo_3, valor_2, valor_3);
  #local valor_0_1_2 = interpola_afim(tempo_atual, tempo_0, tempo_3, valor_0_1, valor_1_2);
  #local valor_1_2_3 = interpola_afim(tempo_atual, tempo_0, tempo_3, valor_1_2, valor_2_3);
  #local valor_0_1_2_3 = interpola_afim(tempo_atual, tempo_0, tempo_3, valor_0_1_2, valor_1_2_3);
  
  valor_0_1_2_3
#end

// Aqui est� a cena, finalmente:
#include "eixos.inc"
union{   
  // object{ eixos(100) }
  object{ tentaculo_animado(150, clock) translate <-20, -120, 0> }
}

#include "camlight.inc"
#declare centro_cena = < -25.00, -25.00, 15.00 >;
#declare raio_cena = 130.0;
#declare dir_camera = < 20.00, -25.00, 15.00 >;

#declare dist_camera = 5*raio_cena;
// #declare centro_cena = < 0.00, 0.00, 0.00 >;
// #declare raio_cena = 200.0;
// #declare dir_camera = < 20.00, 0.00, 00.00 >;
// 
// #declare dist_camera = 7*raio_cena;
#declare intens_luz = 1.20;
camlight(centro_cena, raio_cena, dir_camera, dist_camera , z, intens_luz)