/* -*- indented-text -*- */

/* Animación de triángulo Reuleaux rotando dentro de un cuadrado.
   César Rincón, noviembre 2006.

   Compile con algo como:
   povray +W320 +H240 +QR +AM2 +A0.6 +P +Ireuleaux2.pov -O1.png +KFF30 -D
*/

#declare QUALITY = 1;

global_settings {
  assumed_gamma 2.2
  radiosity {

#if (QUALITY)

    pretrace_start 0.08
    pretrace_end   0.01
    count 400

    nearest_count 8
    error_bound 0.1
    recursion_limit 1

    low_error_factor 0.2
    gray_threshold 0.0
    minimum_reuse 0.015
    brightness 1

    adc_bailout 0.01/2

#else

    brightness 1
    recursion_limit 1
    error_bound 0.4
    count 50
    nearest_count 2
    minimum_reuse 0.1
    low_error_factor 0.5
    gray_threshold 0.0

    pretrace_start 0.08
    pretrace_end   0.08

    adc_bailout 0.01/2

#end
  }
}

background {
 color rgb < 1, 1, 1 >
}

camera {
 location < -0.8, 0.8, -7 >
 look_at < 0, -0.3, 0 >
 angle 42
}

sky_sphere {
  pigment { rgb < 1, 1, 1 > }
}

plane {
 < 0 , 1, 0 >, -1.5
 pigment { rgb < 1, 1, 1 > }
 finish { ambient 0 diffuse 1 }
}

/* Esto es la longitud de un vértice del triángulo al centro
   geométrico, cuando la distancia entre los vértices (el radio de los
   círculos que intersecamos para componerlo) es 2.0. */
#declare P = 4 * cos(radians(30)) / 3;

/* Rotamos, no con las ecuaciones analíticas que describen el
   movimiento (que son más o menos complejas), sino de una manera más
   empírica: lo rotamos hasta el ángulo que queremos, y corregimos la
   posición para que ningún vértice salga del cuadro (-1,-1),(1,1).
   Esto es literalmente como funciona la broca de Harry Watt. */

/* La posición cartesiana de cada vértice, a partir del ángulo de
   rotación y la posición del centro. */
#declare PX = 0;
#declare PY = 0;
#declare T = clock * 120;

#declare AX = P * cos(radians(T));
#declare AY = P * sin(radians(T));
#if (AX > 1)
 #declare PX = PX + 1 - AX;
#else
 #if (AX < -1)
  #declare PX = PX - 1 - AX;
 #end
#end
#if (AY > 1)
 #declare PY = PY + 1 - AY;
#else
 #if (AY < -1)
  #declare PY = PY - 1 - AY;
 #end
#end

#declare BX = P * cos(radians(T + 120));
#declare BY = P * sin(radians(T + 120));
#if (BX > 1)
 #declare PX = PX + 1 - BX;
#else
 #if (BX < -1)
  #declare PX = PX - 1 - BX;
 #end
#end
#if (BY > 1)
 #declare PY = PY + 1 - BY;
#else
 #if (BY < -1)
  #declare PY = PY - 1 - BY;
 #end
#end

#declare CX = P * cos(radians(T + 240));
#declare CY = P * sin(radians(T + 240));
#if (CX > 1)
 #declare PX = PX + 1 - CX;
#else
 #if (CX < -1)
  #declare PX = PX - 1 - CX;
 #end
#end
#if (CY > 1)
 #declare PY = PY + 1 - CY;
#else
 #if (CY < -1)
  #declare PY = PY - 1 - CY;
 #end
#end

#debug concat("A: ", str(AX, 0, 6), ", ", str(AY, 0, 6), "\n")
#debug concat("B: ", str(BX, 0, 6), ", ", str(BY, 0, 6), "\n")
#debug concat("C: ", str(CX, 0, 6), ", ", str(CY, 0, 6), "\n")
#debug concat("P: ", str(PX, 0, 6), ", ", str(PY, 0, 6), "\n")

/* El triángulo Reuleaux. */

union {
 intersection {
  box {
   < -3, -3, -0.5 >, < 3, 3, 0.5 >
  }

  /* Los círculos. */
  cylinder { < P, 0, -1 >, < P, 0, 1 >, 2 }
  cylinder { < P, 0, -1 >, < P, 0, 1 >, 2 rotate < 0, 0, 120 > }
  cylinder { < P, 0, -1 >, < P, 0, 1 >, 2 rotate < 0, 0, 240 > }

  pigment { color rgb < 1, 0.8, 0 > }
  finish  { ambient 0.4 diffuse 0.85 }
 }

 /* El centro geométrico del triángulo */
 cylinder {
  < 0, 0, -1 >, < 0, 0, 1 >, 0.05
  pigment { color rgb < 0.2, 0.2, 0.2 > }
  finish  { ambient 0 diffuse 0.65 }
 }

 rotate < 0, 0, T >
 translate < PX, PY, 0 >
}

/* La caja que lo contiene */

difference {
 box { < -1.5, -1.5, -0.6 >, < 1.5, 1.5, 0.6 > }
 box { < -1, -1, -1 >, < 1, 1, 1 > }

 pigment { color rgb < 0.4, 0.4, 0.4 > }
 finish  { ambient 0 diffuse 0.65 }
}

/* Fin. */