// Fabio de Souza Azevedo - RA 952215
// 2021-11-24
//
// TP10 - Tentaculos Tentativos Tateantes (II)

// Exemplo de arquivo de descricao de cena para POV-ray
// Last edited on 2020-09-30 19:57:13 by jstolfi

//#version 3.7;
#include "rand.inc"

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

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

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

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

#declare tx_espelho = 
  texture {
    pigment { color rgb < 1.00, 0.85, 0.30 > }
    finish { diffuse 0.2 reflection 0.7*< 1.00, 0.85, 0.30 > ambient 0.1 }
  }

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

#declare tx_verde_escuro =
  texture {
    pigment { color rgb <0, 0.5, 0> }
    //finish { diffuse 0.8 ambient 0.1 specular 0.5 roughness 0.005 }
  }

#declare tx_verde_claro =
  texture {
    pigment { color rgb <0, 1.0, 0> }
    //finish { diffuse 0.8 ambient 0.1 specular 0.5 roughness 0.005 }
  }

#declare tx_azul_escuro = 
  texture {
    pigment { color rgb<0, 0, 0.5> }
    //finish { diffuse 0.8 ambient 0.1 specular 0.5 roughness 0.005 }
  }
  
#declare tx_azul_escuro_espelhado = 
  texture {
    pigment { color rgb<0, 0, 0.5> }
    finish { diffuse 0.2 reflection 0.7*<0, 0, 0.5> ambient 0.1 }
  }

#declare tx_verm_escuro = 
  texture {
    pigment { color rgb<0.5, 0, 0> }
    //finish { diffuse 0.8 ambient 0.1 specular 0.5 roughness 0.005 }
  }

#declare tx_verm_transp = 
  texture {
    pigment { color rgbt <1, 0, 0, 0.5> }
    //finish { diffuse 0.8 ambient 0.1 specular 0.5 roughness 0.005 }
  }

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

// ======================================================================
// DESCRICAO DA CENA 

#macro interpola1(tt, tt0,tt1, vv0,vv1)
  // Interpolacao afim.
  // Dados dois pontos (tt0,vv0) e (tt1,vv1) do grafico de uma funcao afim (ou
  // seja, de um polinomio de grau 1 A*tt+B), devolve o valor da funcao para o
  // argumento generico {tt}.
  //
  // Alternativa: devolver diretamente esta expressao
  // ( (vv0)+(tt-(tt0)) * ((vv1)-(vv0))/((tt1)-(tt0)) )
  //
  #local rr = (tt - tt0)/(tt1 - tt0);
  #local vv = (1-rr)*vv0 + rr*vv1;
  vv;
#end


#macro interpola3(tt, tt0,tt3, vv0,vv1,vv2,vv3)
  // Calcula um polinomio de grau 3 (cubico) que comeca no ponto (tt0,vv0) e
  // termina no ponto (tt3,vv3) para o argumento {tt}.
  // As derivadas no inicio e no fim do intervalo sao determinadas pelos valores
  // {vv1} e {vv2}, respectivamente.
  #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 segtaculo(m, p0,r0, p1,r1, p2,r2, p3,r3)
  // Desenha um segmento do tentaculo
  // {m}  = numero de esferas no segmento
  // {p0} = ponto inicial do segmento
  // {r0} = raio da esfera no ponto inicial
  // {p3} = ponto final do segmento
  // {r3} = raio da esfera no ponto final
  //
  // {p1},{r1} = primeiros ponto e raio intermediarios  
  // {p2},{r2} = segundos ponto e raio intermediarios
  #local i = 0;
  union {
    #while (i < m)
      #local centro = interpola3(i, 0,m, p0,p1,p2,p3);
      #local raio =   interpola3(i, 0,m, r0,r1,r2,r3);
      sphere { centro, raio }
      #local i = i + 1;
    #end
  }
#end


#macro tentaculo(m,n,pp,rr)
  // {m} = numero de esferas por segmento do tentaculo
  // {n} = numero de segmentos do tentaculo
  // {pp} = matriz (n x 4) de pontos que definem a curva de Bezier do tentaculo
  // {rr} = matriz (n x 4) de raios, um para cada ponto da matriz {pp}
  #local i = 0;
  union {
    #while (i < n)
      segtaculo(m, pp[i][0],rr[i][0], pp[i][1],rr[i][1], pp[i][2],rr[i][2], pp[i][3],rr[i][3])
      #local i = i + 1;
    #end
  }
#end


#macro tentaculo_teste(m)
  // 2021-11-24
  // {m} = numero de esferas por segmento do tentaculo
  #local N = 4;
  #local PP = array[N][4];
  #local RR = array[N][4];
  
  #local sr = seed(952215);

  // Tenta calcular um tentaculo 'interessante' em funcao do numero de segmentos {N}
  #local i = 0;
  #while (i < N)
    #local j = 0;
    #while (j < 4)
      #local ponto = <2*i+3*j, 4*sin(i*j), 2*i+j>;
      #local PP[i][j] = ponto;
      #local RR[i][j] = 0.25+(0.5*rand(sr));
      #local j = j + 1;
    #end
    #local i = i + 1;
  #end

  // Abordagem simples: calcula a media aritmetica dos pontos para garantir as
  // continuidades de Bezier
  #local seg = 0;
  #while (seg < N-1)
    // Costurando...
    #local ponto_pre_emenda = PP[seg  ][2];
    #local ponto_pos_emenda = PP[seg+1][1];
    #local ponto_daa_emenda = 0.5*(ponto_pre_emenda + ponto_pos_emenda);
    #local PP[seg  ][3] = ponto_daa_emenda;
    #local PP[seg+1][0] = ponto_daa_emenda;

    #local raio_pre_emenda = RR[seg  ][2];
    #local raio_pos_emenda = RR[seg+1][1];
    #local raio_daa_emenda = 0.5*(raio_pre_emenda + raio_pos_emenda);
    #local RR[seg  ][3] = raio_daa_emenda;
    #local RR[seg+1][0] = raio_daa_emenda;

    #local seg = seg + 1;
  #end

  object { tentaculo(m,N,PP,RR) texture { tx_fosca } }
#end


// 2021-11-24 ------------------------------------------------------------------
//
// Macros 'importadas' do TP do robo animado... (reuso de codigo!)
//

// Algumas macros de "servico" para ajudar no calculo dos parametros que servirao
// de pontos de controle para as curvas de Bezier.

// "I will always take an aggressively simple approach to things."
// (--John Carmack)

#macro dist(x0,y0,x1,y1)
  #local dx = x1-x0;
  #local dy = y1-y0;
  #local distancia = sqrt(dx*dx + dy*dy);
  distancia
#end

#macro fa(k,d01,d12)
  // Calcula o fator de escala para o triangulo Ta.
  // TODO: Detalhar o que e' o triangulo Ta.
  (k*d01)/(d01+d12)
#end

#macro fb(k,d01,d12)
  // Calcula o fator de escala para o triangulo Tb.
  // TODO: Detalhar o que e' o triangulo Tb.
  (k*d12)/(d01+d12)
#end

#macro calcula_emenda(x0,y0, x1,y1, x2,y2, k)
  // Considerando duas curvas cubicas de Bezier, uma com extremidades nos pontos
  // (x0,y0) e (x1,y1) e outra com extremidades em (x1,y1) e (x2,y2), calcula os
  // dois pontos de controle em torno do no' (x1,y1), pc1 e pc2, de tal forma que
  // a emenda das duas curvas seja suave (com continuidade C0 e C1) nesse no'.
  // A macro devolve as coordenadas dos dois pontos em um vetor de 4 posicoes:
  // {pc1x, pc1y, pc2x, pc2y}. {k} e' uma constante que ajuda a controlar a
  // suavidade da curva. Bons valores para testar sao k = 0.5 e k = 0.333.
  //
  // (Observação: Segundo a teoria, essencialmente, os pontos de controle, pc1 e
  // pc2, e o no' (x1,y1) devem ser colineares. Seria bom checar essa
  // colinearidade de alguma forma.)

  #local d01 = dist(x0,y0,x1,y1);
  #local d12 = dist(x1,y1,x2,y2);
  #local fator_a = fa(k,d01,d12);
  #debug concat("[calcula_emenda] fator_a = ", str(fator_a,0,4), "\n")

  #local pc1x = x1-fator_a*(x2-x0);
  #local pc1y = y1-fator_a*(y2-y0);

  #local fator_b = k-fator_a;
  #debug concat("[calcula_emenda] fator_b = ", str(fator_b,0,4), "\n")

  #local pc2x = x1+fator_b*(x2-x0);
  #local pc2y = y1+fator_b*(y2-y0);

  #local vet_pc = array[4] {pc1x,pc1y, pc2x,pc2y};
    // {vet_pc} = Vetor com as coordenadas dos pontos de controle calculados

  #debug concat("vet_pc[0] = ", str(vet_pc[0],2,4), "\n")
  #debug concat("vet_pc[1] = ", str(vet_pc[1],2,4), "\n")
  #debug concat("vet_pc[2] = ", str(vet_pc[2],2,4), "\n")
  #debug concat("vet_pc[3] = ", str(vet_pc[3],2,4), "\n")

  vet_pc
#end

#macro robo_calcula_quadros_de_controle(Ti_pre,Pi_pre, Ti,Pi, Ti_pos,Pi_pos, np)
  // Referencia:
  // http://scaledinnovation.com/analytics/splines/aboutSplines.html

  #local k = 0.5;
  #local vet_pc = array[4] {10,20,30,40};
    // {vet_pc} = Vetor para armazenar as coordenadas dos dois pontos de controle
    // (pc) calculados para um no' de curva de Bezier.
  #local Pi_a = array[np];
  #local Pi_z = array[np];
  #local vet_res = array[2];

  #local i = 0;
  #while (i < np)
    // Seja Pi o vetor com os parametros que configuram um quadro-chave i e Ti
    // o instante no tempo em que esse quadro ocorre.
    // Queremos calcular Pi_a e Pi_z, os vetores auxiliares anterior e posterior
    // a Pi, respectivamente. Os valores dos parametros nesses vetores auxiliares
    // servirao como as ordenadas dos pontos de controle "em torno" do no' Pi.
    //
    // Usaremos a macro 'calcula_emenda', abaixo, para calcular os pontos de
    // controle para um no'. Dado o no', representado como o ponto (x1,y1),
    // em que x1 e' o instante de tempo do quadro e y1 e' o valor do parametro
    // no quadro, a macro precisa dos pontos [pre]decessor e [pos]terior do no',
    // (x0,y0) e (x2,y2), respectivamente, e de uma constante {k}.
    //
    // calcula_emenda(x0,y0, x1,y1, x2,y2, k)

//    #debug concat("vet_pc[3] = ", str(vet_pc[3],0,4), "\n")
//    #debug concat("vet_pc[2] = ", str(vet_pc[2],0,4), "\n")
//    #debug concat("vet_pc[1] = ", str(vet_pc[1],0,4), "\n")
//    #debug concat("vet_pc[0] = ", str(vet_pc[0],0,4), "\n")

    #local vet_pc = calcula_emenda(Ti_pre,Pi_pre[i], Ti,Pi[i], Ti_pos,Pi_pos[i], k);
    // Resultado:
    // vet_pc[0]: pc1x; vetpc[1]: pc1y; vetpc[2]: pc2x; vetpc[3]: pc2y;
    #local Pi_a[i] = vet_pc[1];
    #local Pi_z[i] = vet_pc[3];

    ////#debug concat("vet_pc[", str(k,0,0), "] = ", str(vetia[k],0,4), "\n")
/*    #debug concat("vet_pc[0] = ", str(vet_pc[0],0,4), "\n")
    #debug concat("vet_pc[1] = ", str(vet_pc[1],0,4), "\n")
    #debug concat("vet_pc[2] = ", str(vet_pc[2],0,4), "\n")
    #debug concat("vet_pc[3] = ", str(vet_pc[3],0,4), "\n")
*/
    #local i = i+1;
  #end
  #local vet_res[0] = Pi_a;
  #local vet_res[1] = Pi_z;
  vet_res
#end


#macro robo_mov_interp3(tf)
  // Define os quadros-chave da animacao do robo:
  // a) tempos (instantes) de cada quadro-chave na linha do tempo da sequencia
  // 	de animacao (linha que varia de 0.000 a 1.000) e
  // b) os valores dos parametros de configuracao do robo associados a cada
  // 	quadro-chave.
  //
  // Para cada valor de tempo {tf} intermediario dado (entre "tempos-chave"),
  // calcula o vetor de parametros interpolados correspondente, usando
  // interpolacao de Bezier (cubica). Em outras palavras, executa um
  // 'inbetweening' para calcular os valores dos parametros que definem um quadro
  // intermediario.
  //
  // Ao final, chama a macro {robo_vet} para o quadro (frame) intermediario
  // calculado.

  #local num_params = 20;
  #local qd = array[num_params];
  #local quadros_aux = array[2];

  // Quadros-chave "originais" (tais como na interpolacao afim):
  #local T0 = 0.000;
  #local P0 = array[num_params] {
    +00,    +00, +00, +00,  +00, +00, +00,    +00, +00, +00,  +00, +00, +00, // torax
    +00,    -10, +10, +00,  +20, +20, +20 }; // quadril
  #local T1 = 0.125;
  #local P1 = array[num_params] {
    +00,    +00, +00, +00,  +00, +00, +00,    +90, +00, +00,  +00, +00, +00, // torax
    +00,    +10, +00, -10,  -10, +70, -30 }; // quadril
  #local T2 = 0.250;
  #local P2 = array[num_params] {
    +90,    +00, +45, +00,  -45, +00, +00,    +00, -90, +00,  +00, +00, +00, // torax
    +00,    +20, +10, +00,  -20, +00, +00 }; // quadril
  #local T3 = 0.375;
  #local P3 = array[num_params] {
    +90,    +00, +45, +00,  -45, +00, +00,    +00, -90, +00,  +00, +00, +120, // torax
    +00,    +30, +10, +00,  -15, +00, +00 }; // quadril
  #local T4 = 0.500;
  #local P4 = array[num_params] {
    +90,    +00, -90, +00,  +00, +00, +120,    +00, +45, +00,  -45, +00, +120, // torax
    +00,    +30, +20, +20,  -15, +15,  +00 }; // quadril
  #local T5 = 0.625;
  #local P5 = array[num_params] {
    +90,    +00, +45, +00,  -45, +00, +120,    +00, -90, +00,  +00, +00, +120, // torax
    +00,    -10, +70, -30,  +10, +00, -10 }; // quadril
  #local T6 = 0.750;
  #local P6 = array[num_params] {
    +00,    -90, +00, +00,  +00, +00, +00,    +90, +00, +00,  +00, +00, +00, // torax
    +00,    -20, +00, +00,  +20, +10, +00 }; // quadril
  #local T7 = 0.875;
  #local P7 = array[num_params] {
   -180,    -90, +00, +00,  +00, +00, +00,    +90, +00, +00,  +00, +00, +00, // torax
    +00,    -15, +00, +00,  +30, +10, +00 }; // quadril
  #local T8 = 1.000;
  #local P8 = P0;

  // Quadros-chave exceto os nos:
  #local quadros_aux = robo_calcula_quadros_de_controle(T0,P0, T1,P1, T2,P2, num_params);
  #local P1a = quadros_aux[0];
  #local P1z = quadros_aux[1];

  #local quadros_aux = robo_calcula_quadros_de_controle(T1,P1, T2,P2, T3,P3, num_params);
  #local P2a = quadros_aux[0];
  #local P2z = quadros_aux[1];

  #local quadros_aux = robo_calcula_quadros_de_controle(T2,P2, T3,P3, T4,P4, num_params);
  #local P3a = quadros_aux[0];
  #local P3z = quadros_aux[1];
  #local quadros_aux = robo_calcula_quadros_de_controle(T3,P3, T4,P4, T5,P5, num_params);
  #local P4a = quadros_aux[0];
  #local P4z = quadros_aux[1];
  #local quadros_aux = robo_calcula_quadros_de_controle(T4,P4, T5,P5, T6,P6, num_params);
  #local P5a = quadros_aux[0];
  #local P5z = quadros_aux[1];
  #local quadros_aux = robo_calcula_quadros_de_controle(T5,P5, T6,P6, T7,P7, num_params);
  #local P6a = quadros_aux[0];
  #local P6z = quadros_aux[1];
  #local quadros_aux = robo_calcula_quadros_de_controle(T6,P6, T7,P7, T8,P8, num_params);
  #local P7a = quadros_aux[0];
  #local P7z = quadros_aux[1];
  #local quadros_aux = robo_calcula_quadros_de_controle(T7,P7, T8,P8, T1,P1, num_params);
  #local P8a = quadros_aux[0];
  #local P8z = quadros_aux[1];

  #local P0a = P8a;
  #local P0z = P8z;

  // Quadros-chave dos nos:
  #local P0m = robo_interpola1(T0, T0-(T8-T7)/3, T0+(T1-T0)/3, P0a, P0z, num_params);
  #local P1m = robo_interpola1(T1, T1-(T1-T0)/3, T1+(T2-T1)/3, P1a, P1z, num_params);
  #local P2m = robo_interpola1(T2, T2-(T2-T1)/3, T2+(T3-T2)/3, P2a, P2z, num_params);
  #local P3m = robo_interpola1(T3, T3-(T3-T2)/3, T3+(T4-T3)/3, P3a, P3z, num_params);
  #local P4m = robo_interpola1(T4, T4-(T4-T3)/3, T4+(T5-T4)/3, P4a, P4z, num_params);
  #local P5m = robo_interpola1(T5, T5-(T5-T4)/3, T5+(T6-T5)/3, P5a, P5z, num_params);
  #local P6m = robo_interpola1(T6, T6-(T6-T5)/3, T6+(T7-T6)/3, P6a, P6z, num_params);
  #local P7m = robo_interpola1(T7, T7-(T7-T6)/3, T7+(T8-T7)/3, P7a, P7z, num_params);
  #local P8m = robo_interpola1(T8, T8-(T8-T7)/3, T8+(T1-T0)/3, P8a, P8z, num_params);

  #if ((T0 <= tf) & (tf <= T1))
    #local qd = robo_interpola3(tf, T0,T1, P0m,P0z,P1a,P1m, num_params);
  #elseif ((T1 <= tf) & (tf <= T2))
    #local qd = robo_interpola3(tf, T1,T2, P1m,P1z,P2a,P2m, num_params);
  #elseif ((T2 <= tf) & (tf <= T3))
    #local qd = robo_interpola3(tf, T2,T3, P2m,P2z,P3a,P3m, num_params);
  #elseif ((T3 <= tf) & (tf <= T4))
    #local qd = robo_interpola3(tf, T3,T4, P3m,P3z,P4a,P4m, num_params);
  #elseif ((T4 <= tf) & (tf <= T5))
    #local qd = robo_interpola3(tf, T4,T5, P4m,P4z,P5a,P5m, num_params);
  #elseif ((T5 <= tf) & (tf <= T6))
    #local qd = robo_interpola3(tf, T5,T6, P5m,P5z,P6a,P6m, num_params);
  #elseif ((T6 <= tf) & (tf <= T7))
    #local qd = robo_interpola3(tf, T6,T7, P6m,P6z,P7a,P7m, num_params);
  #elseif ((T7 <= tf) & (tf <= T8))
    #local qd = robo_interpola3(tf, T7,T8, P7m,P7z,P8a,P8m, num_params);
  #end

  //qd
  robo_vet(qd)
#end


/*
#macro tentaculo_animado(m,tt)
  // 2021-11-17
  // {m} = numero de esferas por segmento do tentaculo
  // {tt} = quadro-chave

  #local N_segs = 4;
  #local K = 4; // Numero de quadros-chave da animacao

  // Seja "qc" um quadro-chave
  #local QPP = array[K-1][4][N_segs][4] =
    {
      { // intervalo k=0: entre qc0 e qc1
        { // posicao j=0 (calculada):
          { // segmento n=0:
            <0,0,0>, <0,0,0>, <0,0,0>, <0,0,0>
          },
          { // segmento n=1:
            <0,0,0>, <0,0,0>, <0,0,0>, <0,0,0>
          },
          { // segmento n=2:
            <0,0,0>, <0,0,0>, <0,0,0>, <0,0,0>
          },
          { // segmento n=3:
            <0,0,0>, <0,0,0>, <0,0,0>, <0,0,0>
          }
        },
        { // posicao j=1 (derivada inicial, DADA):
          { // segmento n=0 (p0,p1,p2 dados; p3 calculado):
            <0,0,0>, <+1,-0.50,0>, <+2,-0.50,0>,      <+3,0,0>
          },
          { // segmento n=1 (p0 calculado; p1,p2 dados; p3 calculado):
            <+3,0,0>,   <+4,+0.50,0>, <+5,+0.50,0>,   <+6,0,0>
          },
          { // segmento n=2 (p0 calculado; p1,p2 dados; p3 calculado):
            <+6,0,0>,    <+7,+1.50,0>, <+8,+2.0,0>,   <+8,0,0>
          },
          { // segmento n=3 (p0 calculado; p1,p2,p3 dados):
            <+8,0,0>,      <+8,+4.0,0>, <+7,+4.5,0>, <+6,0,0>
          }
        },
        { // posicao j=2 (derivada final, DADA):
          // *** REFAZER TUDO ABAIXO! ESTA' ERRADO AQUI!
          { // segmento n=0 (p0,p1,p2 dados; p3 calculado):
            <0,0,0>, <+1,-0.50,0>, <+2,-0.50,0>,      <+3,0,0>
          },
          { // segmento n=1 (p0 calculado; p1,p2 dados; p3 calculado):
            <+3,0,0>,   <+4,+0.50,0>, <+5,+0.50,0>,   <+6,0,0>
          },
          { // segmento n=2 (p0 calculado; p1,p2 dados; p3 calculado):
            <+6,0,0>,    <+7,+1.50,0>, <+8,+1,0>,   <+9,0,0>
          },
          { // segmento n=3 (p0 calculado; p1,p2,p3 dados):
            <+9,0,0>,      <+10,-1,0>, <+9.5,-2,0>, <+9,0,0>
          }
        },
        { // posicao j=3 (calculada):
          { // segmento n=0:
            <0,0,0>, <0,0,0>, <0,0,0>, <0,0,0>
          },
          { // segmento n=1:
            <0,0,0>, <0,0,0>, <0,0,0>, <0,0,0>
          },
          { // segmento n=2:
            <0,0,0>, <0,0,0>, <0,0,0>, <0,0,0>
          },
          { // segmento n=3:
            <0,0,0>, <0,0,0>, <0,0,0>, <0,0,0>
          }
        }
      }, 

      { // intervalo k=1: entre qc1 e qc2
        { // posicao j=0 (calculada):
          { // segmento n=0:
            <0.0>,<0.0>,<0.0>,<0.0>
          },
          { // segmento n=1:
            <0.0>,<0.0>,<0.0>,<0.0>
          },
          { // segmento n=2:
            <0.0>,<0.0>,<0.0>,<0.0>
          },
          { // segmento n=3:
            <0.0>,<0.0>,<0.0>,<0.0>
          }
        },
        { // posicao j=1 (dada):
          { // segmento n=0:
            <0.0>,<0.0>,<0.0>,<0.0>
          },
          { // segmento n=1:
            <0.0>,<0.0>,<0.0>,<0.0>
          },
          { // segmento n=2:
            <0.0>,<0.0>,<0.0>,<0.0>
          },
          { // segmento n=3:
            <0.0>,<0.0>,<0.0>,<0.0>
          }
        },
        { // posicao j=2 (dada):
          { // segmento n=0 (p0,p1,p2 dados; p3 calculado):
            <0,0,0>, <+1,-0.50,0>, <+2,-0.50,0>,      <+3,0,0>
          },
          { // segmento n=1 (p0 calculado; p1,p2 dados; p3 calculado):
            <+3,0,0>,   <+4,+0.50,0>, <+5,+0.50,0>,   <+6,0,0>
          },
          { // segmento n=2 (p0 calculado; p1,p2 dados; p3 calculado):
            <+6,0,0>,    <+7,+1.50,0>, <+8,+1,0>,   <+9,0,0>
          },
          { // segmento n=3 (p0 calculado; p1,p2,p3 dados):
            <+9,0,0>,      <+10,-1,0>, <+9.5,-2,0>, <+9,0,0>
          }
        },
        { // posicao j=3 (calculada):
          { // segmento n=0:
            <0.0>,<0.0>,<0.0>,<0.0>
          },
          { // segmento n=1:
            <0.0>,<0.0>,<0.0>,<0.0>
          },
          { // segmento n=2:
            <0.0>,<0.0>,<0.0>,<0.0>
          },
          { // segmento n=3:
            <0.0>,<0.0>,<0.0>,<0.0>
          }
        }
      },

      { // intervalo k=2: entre qc2 e qc3
        { // posicao j=0 (calculada):
          { // segmento n=0:
            <0.0>,<0.0>,<0.0>,<0.0>
          },
          { // segmento n=1:
            <0.0>,<0.0>,<0.0>,<0.0>
          },
          { // segmento n=2:
            <0.0>,<0.0>,<0.0>,<0.0>
          },
          { // segmento n=3:
            <0.0>,<0.0>,<0.0>,<0.0>
          }
        },
        { // posicao j=1 (dada):
          { // segmento n=0:
            <0.0>,<0.0>,<0.0>,<0.0>
          },
          { // segmento n=1:
            <0.0>,<0.0>,<0.0>,<0.0>
          },
          { // segmento n=2:
            <0.0>,<0.0>,<0.0>,<0.0>
          },
          { // segmento n=3:
            <0.0>,<0.0>,<0.0>,<0.0>
          }
        },
        { // posicao j=2 (dada):
          { // segmento n=0:
            <0.0>,<0.0>,<0.0>,<0.0>
          },
          { // segmento n=1:
            <0.0>,<0.0>,<0.0>,<0.0>
          },
          { // segmento n=2:
            <0.0>,<0.0>,<0.0>,<0.0>
          },
          { // segmento n=3:
            <0.0>,<0.0>,<0.0>,<0.0>
          }
        },
        { // posicao j=3 (calculada):
          { // segmento n=0:
            <0.0>,<0.0>,<0.0>,<0.0>
          },
          { // segmento n=1:
            <0.0>,<0.0>,<0.0>,<0.0>
          },
          { // segmento n=2:
            <0.0>,<0.0>,<0.0>,<0.0>
          },
          { // segmento n=3:
            <0.0>,<0.0>,<0.0>,<0.0>
          }
        }
      }
    };

  #local qrr = array[k-1][4][N_segs][4] =
    {
    };

#end
*/


#include "eixos.inc"

// Aqui está a cena, finalmente:

object { eixos(10.0) }

// Chao
box {
  <-25, -25, +00>, <+25, +25, -0.5>
  translate <0,0,-2>
  texture { tx_xadrez }
}


#declare M_esferas = 30;//120;
object { tentaculo_teste(M_esferas) }


#include "camlight.inc"

#declare centro_cena = < 8.00, 8.00, 4.00 >;


// Perspectiva

#declare raio_cena = 18;
#declare dir_camera = < 0, -15, 20.00 >;//<7.0, 7.0, 7.0 >;
//<1,1,10>;
//< 7.00, 3.00, 4.00 >;
//< 0.5, 7.00,  2.00 >;
//< 7.00, 0.5, 2.00 >;
//< 7.00, 14.00, 4.00 >;

#declare dist_camera = 2.0*raio_cena;
#declare intens_luz = 1.20;
camlight(centro_cena, raio_cena, dir_camera, dist_camera , z, intens_luz)