Pseudo tutorial de Pov

Bajarselo para leerlo offline 150Kb
El pov es un sistena de programacion grafica en el que podemos definir una serie de figuras que podremos combinar con elementos tipicos de programacion como son las estructuras de control funciones matematicas. Esto permite que sea una manera muy potente de una vez hechos los modelos controlar totalmente los mivimientos de estos con el tiempo. Para el modelado es un poco arduo ya que no vemos lo que hacemos, aunque con un poco de tiempo de practica se pueden hacer verdaderas pasadas de modelos. A parte de todo incluye un monton de efectos que con otros programas o no tenemos o son tan dificiles de manejar que solo los entiende el que hiro el IPAS o el Plug-in. Asi que empezaremos dos secciones una de iniciacion y otra media. En la de iniciacion iremos describiendo los tipos de objetos que tenemos, transformaciones y al final los efectos tipicos, en la media nos meteremos de lleno en los llamados POVIpas que son una especie de IPAS para Pov que pueden hacer desde una explosion hasta un paisaje de arboles, estos PovIpas nos facilitaran mucho el trabajo. Empezarenos con un sinple PovIpas que nos permitira hacer serpientes, dragones y todos aquellos bichos que se asemejen a una serpiente variando unos pocos parametros, lugo quiero intentar un PovIpas de explosiones con humo y todo pero ya veremos. Para empezar para los que desconocen totalmente la programacion, el Pov utiliza una serie de archivos que vienen ha ser unos indices con una serie de nombres que nos proporcionan ayuda se llaman includes, mas tarde los veremos en mas detalle pero ahora nos lo creemos, por ejemplo el include colors.inc nos da un monton de colores ya definidos con lo que ahorramos de escribir. veamos un ejemplo en POV:
#include "colors.inc"
camera //la camara desde la que vemos la imagen {
    location <0.0 , 2.0 ,-5.0> //posicion de la camara <x,y,z>
    look_at   <0.0 , 0.0 , 0.0> //hacia donde mira la camara <x,y,z>
    }
light_source //luz que ilumina la escena {
    <0,40,0> //posicion donde esta la luz <x,y,z>
    color White //color de la luz
    }
plane //un plano infinito {
    <0,1,0>, // vector normal al plano
    -1.0 // distancia del origen en la direccion de la normal al plano
    pigment{
        color <1,0,1>// color RGB con rojo 100% verde 0% y Azul 100% da un tono malva
        }
    }
Como podeis ver es bastante sencillo es una escena donde hay unicamente una luz, una camara y un plano horizontal malva. Bien tenemos lo primero de todo el include colors.inc en este archivo se definen un monton de colores que podemos utilizar como hacemos con la luz "Color White" la directiva color utiliza colores RGB (Red Green Blue) que para quien haya jugado alguna vez con plastidecores sabra que si mezcla estos tres colores en distintas proporciones obtiene una burrada de colores, pues bien ai funciona su sintaxsis es:
"Color <"valor para el rojo entre 0 y 1 (0-100%)","valor para el verde entre 0 y 1 (0-100%)","valor para el azul entre 0 y 1 (0-100%)">
asi color <1,1,1> seria el blanco, color <0,0,0> sera el negro , color <x,x,x> donde x es un numero cualquiera sera una tonalidad de gris entre blanco puro y negro puro y color <x,y,z> que puede ser cualquier color que nos imaginemos.
En el include colors.inc lo que tenemos son un momton de definiciones de colores que se han asignado a un nombre (en ingles) para que los podamos utilizar directamante asi el blanco esta definido como White (la W debe ser mayuscula sino dara un error) y lo utilizamos de la siguiente manera color White, en vez de color <1,1,1>, como vemos es mas claro de la primera forma y mas rapido de ver que color es el objeto.
Una ver sabemos como de finir colores vamos con esa camara que hay ahi, ¿por que una camara? el Pov necesita un ojo desde el que ver la imagen ya que hay infinitas posiciones desde las que ver la escena, pues bien para eso definimos una camara que es imprescindible en cualquier escena, de momento solo nos quedaremos con esos dos parametros que tiene el location donde indicamos donde estara la camara situada en la escena y Look_at que es el punto hacia donde mira la camara, que sepais que tiene alguno mas. La luz en una abitacion en la que no hay ningun tipo de luz ¿podeis ver algo?, NO, pues aqui igual, la escena es una especie de habitacion aislada de todo, por lo que no hay luz (mas tarde veremos que no es del todo cierto) asi que como la camara tiene que estar en algun sitio de la escena y claro la luz tiene que tener un color blanco, rojo burdel, azul cielo, amarillo amanece... como querais es un buen ejercicio probar a cambiar en este ejemplo el color de la luz y ver que el plano dependiendo del color de la luz se vera de color diferente aunque el plano siga siendo malva. por fin el plano que es uno de esos con los que nos brasean en algebra, una lamina infinita que se extiende perpendicular al vector normal que damos (aqui emos utilizado el vector <0,1,0> que es el vector director de Y luego el plano es el XZ) luego una distancia al punto de origen O y lo mas interesante la directiva pigment{color <1,0,1>} que iremos viendo que utilizaremoe en muchos objetos para asignarles color es importante decir que debe ir dentro de la definicion del plano, es decir dentro de las llaves que delimitan el principio y el final de la definicion del plano, es muy importante el orden en Pov pues en ejemplos tam pequeños no se nota pero mas adelante iremos viendo que un buen sangrado y un poco de orden al escribir los objetos nos facilita la comprension y correccion de errores, de los que os vais a hartar.   Para que vallais viendo como funciona un poco he hecho un pequeño ejemplo con el que voy a explicar desde como funcionan los objetos basicos, transformaciones y demas, hasta los halos y funciones. En concreto es una animacion en la que hay un mar, un cielo, unas nuves, una bola incendiada y unas letras que giran alrededor de la bola. Una nota atener en cuenta es la complegidad de calculos de este render debido a los halos, con el probe el nuevo K6 a 300 y que do en muy buena posicion teniendo en cuenta que la placa que utilice no lo reconocia del todo (ha salido hace nada el K6) me gustaria que todos aquellos que rendericen la animacion me mandaran el tipo de equipo y el tiempo que tardo el primer frame para añadir esos datos a esta tabla y poder hacer un equipo para render que funcione de verdad y no uno de esos comerciales de la revistas y demas milongas (porcierto la WinFast es una mierda para los render):
Es el render del primer fotograma a 640x480 NoAA

`Micro`	`Sistema Operativo`	`Tarjeta de Video`	`Disco Duro`	`Placa`	`Memoria`	`Tiempo de Render`
`PII 233Mhz`	`Win98`	`Trident 975 AGP 4Mb`	`3,2Gb Seagate`	`Legend BX`	`64Mb`	`1' 48''`
`K6 233Mhz`	`Win95`	`Venus Virge DGX 4Mb`	`3,2Gb Seagate`	`Acer TX Pro Cache 512`	`64Mb`	`2' 22''`
`K6 300Mhz`	`Win95`	`Venus Virge DGX 4Mb`	`3,2Gb Samsung`	`Acer TX Pro Cache 512`	`64Mb`	`2' 1''`
`P 75Mhz`	`Linux kernel 2.0.32`	`Venus Virge DGX 4Mb`	`2,5Gb Samsung`	`Intel 430VX`	`32Mb`	`20' 9''`
`P 75Mhz`	`WinNT 4.0`	`Venus Virge DGX 4Mb`	`2,5Gb Samsung`	`Intel 430VX`	`32Mb`	`5' 51''`
`K6 233Mhz`	`WinNT 4.0`	`Venus Virge DGX 4Mb`	`2,5Gb Samsung`	`Acer TX Pro Cache 512`	`64Mb`	`2' 10''`
`K6 233Mhz`	`Linux kernel 2.0.34`	`Venus Virge DGX 4Mb`	`2,5Gb Samsung`	`Acer TX Pro Cache 512`	`64Mb`

El archivo en cuestion es este:

// Persistence of Vision Ray Tracer Scene Description File
// File: AmdK6.pov
// Vers: 3
// Desc: letras dando vueltas
// Date: 6/6/98
// Auth: Kuisathaverat98

// ==== Standard POV-Ray Includes ====
#include "colors.inc" // Standard Color definitions
#include "textures.inc" // Standard Texture definitions

camera
{
location <0.0 , 0 ,-8>
look_at <0.0 , 0.0 , 0.0>
}

// create a regular point light source
light_source
{
0*x // light's position (translated below)
color red 1.0 green 1.0 blue 1.0 // light's color
translate <-10, 10, -10>
}

sphere
{ 0,1
pigment { color rgbt <1, 1, 1,1> }
halo
{
     emitting
     spherical_mapping
     linear
     turbulence 0.7*clock
     color_map {
        [ 0.0 color rgbt <0,0,0,0.2>]
        [ 0.1 color rgbt <1, 0, 0,1> ]
        [ 0.8 color rgbt <1, 1, 0,0> ]
      }
     frequency 2
     samples 10
}
hollow
scale 2
translate <0,0,0>
rotate<0,clock*5,0>
}

// Create an infinite sphere around scene and allow any texture on it
sky_sphere
{
pigment
{
    gradient y
    color_map { [0.0 color red .8] [0.2 color blue .8] [.9 color <1,1,1>] }
}
pigment {
            bozo
            turbulence 0.65
            octaves 6
            omega 0.7
            lambda 2
            color_map {
                      [0.0 0.1 color rgb <0.85, 0.85, 0.85>
                      color rgb <0.75, 0.75, 0.75>]
                      [0.1 0.5 color rgb <0.75, 0.75, 0.75>
                      color rgbt <1, 1, 1, 1>]
                      [0.5 1.0 color rgbt <1, 1, 1, 1>
                      color rgbt <1, 1, 1, 1>]
                  }
            scale <0.2, 0.5, 0.2>
            }
rotate clock*pi*x

}

#declare agua=
              texture{
                      pigment {color <0,0.4,0.7>}
                      normal {
                             bumps 0.15+(sin(clock*2)/8)
                             }
                      finish {
                              reflection 0.3
                              refraction 1
                              phong 0.8
                              }
                      }

object{
       plane
       {
       <0,1,0>,
       -1.0
       }
       texture{agua}
}

#declare g=30
#declare dis=0.16
#declare r=3

// create a TrueType text shape
text
{
ttf          // font type (only TrueType format for now)
"d:\winnt40\fonts\arialbd.ttf", // Microsoft Windows-format TrueType font file name
"A",   // the string to create
2,           // the extrusion depth
0            // offset
texture{agua}
rotate<0,0,degrees((clock-0.5)*pi)-g*1>
translate<cos((clock-dis*1)*pi)*r,sin((clock-dis*1)*pi)*r,0>
}
// create a TrueType text shape
text
{
ttf          // font type (only TrueType format for now)
"d:\winnt40\fonts\arialbd.ttf", // Microsoft Windows-format TrueType font file name
"M",   // the string to create
2,           // the extrusion depth
0            // offset
texture{agua}
rotate<0,0,degrees((clock-0.5)*pi)-g*2>
translate<cos((clock-dis*2)*pi)*r,sin((clock-dis*2)*pi)*r,0>
}
// create a TrueType text shape
text
{
ttf          // font type (only TrueType format for now)
"d:\winnt40\fonts\arialbd.ttf", // Microsoft Windows-format TrueType font file name
"D",   // the string to create
2,           // the extrusion depth
0            // offset
texture{agua}
rotate<0,0,degrees((clock-0.5)*pi)-g*3>
translate<cos((clock-dis*3)*pi)*r,sin((clock-dis*3)*pi)*r,0>
}
// create a TrueType text shape
text
{
ttf          // font type (only TrueType format for now)
"d:\winnt40\fonts\arialbd.ttf", // Microsoft Windows-format TrueType font file name
"K",   // the string to create
2,           // the extrusion depth
0            // offset
texture{agua}
rotate<0,0,degrees((clock-0.5)*pi)-g*4>
translate<cos((clock-dis*4)*pi)*r,sin((clock-dis*4)*pi)*r,0>
}
// create a TrueType text shape
text
{
ttf          // font type (only TrueType format for now)
"d:\winnt40\fonts\arialbd.ttf", // Microsoft Windows-format TrueType font file name
"6",   // the string to create
2,           // the extrusion depth
0            // offset
texture{agua}
rotate<0,0,degrees((clock-0.5)*pi)-g*5>
translate<cos((clock-dis*5)*pi)*r,sin((clock-dis*5)*pi)*r,0>
}
// create a TrueType text shape
text
{
ttf          // font type (only TrueType format for now)
"d:\winnt40\fonts\arialbd.ttf", // Microsoft Windows-format TrueType font file name
"2",   // the string to create
2,           // the extrusion depth
0            // offset
texture{agua}
rotate<0,0,degrees((clock-0.5)*pi)-g*6>
translate<cos((clock-dis*6)*pi)*r,sin((clock-dis*6)*pi)*r,0>
}
// create a TrueType text shape
text
{
ttf          // font type (only TrueType format for now)
"d:\winnt40\fonts\arialbd.ttf", // Microsoft Windows-format TrueType font file name
"3",   // the string to create
2,           // the extrusion depth
0            // offset
texture{agua}
rotate<0,0,degrees((clock-0.5)*pi)-g*7>
translate<cos((clock-dis*7)*pi)*r,sin((clock-dis*7)*pi)*r,0>
}
// create a TrueType text shape
text
{
ttf          // font type (only TrueType format for now)
"d:\winnt40\fonts\arialbd.ttf", // Microsoft Windows-format TrueType font file name
"3",   // the string to create
2,           // the extrusion depth
0            // offset
texture{agua}
rotate<0,0,degrees((clock-0.5)*pi)-g*8>
translate<cos((clock-dis*8)*pi)*r,sin((clock-dis*8)*pi)*r,0>
}
// create a TrueType text shape
text
{
ttf          // font type (only TrueType format for now)
"d:\winnt40\fonts\arialbd.ttf", // Microsoft Windows-format TrueType font file name
"M",   // the string to create
2,           // the extrusion depth
0            // offset
texture{agua}
rotate<0,0,degrees((clock-0.5)*pi)-g*9>
translate<cos((clock-dis*9)*pi)*r,sin((clock-dis*9)*pi)*r,0>
}
// create a TrueType text shape
text
{
ttf          // font type (only TrueType format for now)
"d:\winnt40\fonts\arialbd.ttf", // Microsoft Windows-format TrueType font file name
"H",   // the string to create
2,           // the extrusion depth
0            // offset
texture{agua}
rotate<0,0,degrees((clock-0.5)*pi)-g*10>
translate<cos((clock-dis*10)*pi)*r,sin((clock-dis*10)*pi)*r,0>
}
// create a TrueType text shape
text
{
ttf          // font type (only TrueType format for now)
"d:\winnt40\fonts\arialbd.ttf", // Microsoft Windows-format TrueType font file name
"z",   // the string to create
2,           // the extrusion depth
0            // offset
//pigment{color White}
texture{agua}
rotate<0,0,degrees((clock-0.5)*pi)-g*11>
translate<cos((clock-dis*11)*pi)*r,sin((clock-dis*11)*pi)*r,0>
}
************************** Y el INI para la animacion este ***********************************
Width=640
Height=480

Antialias=Off

Antialias_Threshold=0.1
Antialias_Depth=2
Test_Abort_Count=10

Initial_Frame=1
Final_Frame=50
Initial_Clock=0
Final_Clock=2

Cyclic_Animation=on
Pause_when_Done=off
Output_File_Type=T

Empecemos por lo primero nuevo que nos encontramos que es "sphere" no hay que ser muy aguililla para saber que se trata de una esfera, la miga viene ahora, la de finicion basica de una esfera es:

sphere
{
<x,y,z> // punto que es centro de la esfera
r // radio de la esfera
//resto de modificadores color, translacion, rotacion, pigmentos, texturas, ...
}

Como veis no es muy dificil de entender, le damos el punto que es el centro de la esfera y el radio.
En el ejemplo le he añadido una serie de cosas la mas sencilla es un pigmento:
pigment { color rgbft<1, 1, 1,1> }
Ahora me direis que que coño es el rgbt, que solo os he dicho como funciona el rgb, tranquilidad todo llega, la sentencia pigment es como la que vimos antes dara el color al objeto esfera, pero en este caso en vez de utilizar un color plano (rgb) utilizamos un degradado (es algo asi) lo que hace es una transicion desde el nº que indique la 4º componente hasta el nº que indique la 5º componente (en este caso 0 porque no hay 5º componente) osea hace una especie de degradado del color que definimos en las 3 primeras componentes (<rojo,verde,azul>) desde el 100% del color (<rojo,verde,azul,1>) hasta el 0% (que seria el negro) haciendo el objeto semi o en este caso totalmente transparente.

Ejemplo 1:
//falta la camara
//falta la luz
sphere
{
<0, 0, 0> // center of sphere <X Y Z>
1 // radius of sphere
pigment { color rgbt <1, 0, 0,.5,0> }
}
Daria como resultado esto:

Nota: las imagenes de ejemplo seran de esta penosa calidad salvo que necesiten calidad, asi esta pagina se cargará mucho mas rapido, ocupan entre 5 y 7 Kb lo cual esta muy bien.

Siguendo con la explicacion de lo que tenemos en el gran ejemplo (GE apartir de ahora) el halo de momento lo vamos a dejar pero vienen a ser las llamas de la bola del centro, el hollow lo mismo.
Scale lo que hace es escalar el objeto en este caso le decimos que multiplique por 2 el tamaño de la esfera, la sintaxis de scale es:
scale <x,y,z> //donde x,y,z son los multiplicadores de tamaño por eje
o
scale n //donde n se multiplica en todos los ejes
Con calma lo explico ahora, pues bien que mejor forma que con un ejemplo:

Aqui no modificamos el tamaño de la esfera
sphere
{
<0, 0, 0> // center of sphere <X Y Z>
.5 // radius of sphere
pigment { color rgbt <1, 1, 0,.5,0> }
scale <1,1,1>
}

Aqui duplicamos el tamaño en x
sphere
{
<0, 0, 0> // center of sphere <X Y Z>
.5 // radius of sphere
pigment { color rgbt <1, 1, 0,.5,0> }
scale <2,1,1>
}

Multiplicamos por 2 la y
sphere
{
<0, 0, 0> // center of sphere <X Y Z>
.5 // radius of sphere
pigment { color rgbt <1, 1, 0,.5,0> }
scale <1,2,1>
}

Y la Z
sphere
{
<0, 0, 0> // center of sphere <X Y Z>
.5 // radius of sphere
pigment { color rgbt <1, 1, 0,.5,0> }
scale <1,1,2>
}

Translate lo que hace es mover el objetoa un punto en concreto, aqui no es necesarea pero la he puesto para mostrar su funcionamiento, su sintaxis es:
translate <x,y,z> //donde x,y,z son las coordenadas de un punto
Rotate, rota el objeto los grados que se le indique sobre cada eje, como no un ejemplo:
Sin girar
box
{
<1, 1, 1> // one corner position <X1 Y1 Z1>
< .5, .5, .5> // other corner position <X2 Y2 Z2>
pigment { color rgb <1, 1, 0> }
scale<2,1,1>
translate<-1,-1,0>
}

Girado 60º en x
box
{
<1, 1, 1> // one corner position <X1 Y1 Z1>
< .5, .5, .5> // other corner position <X2 Y2 Z2>
pigment { color rgb <1, 1, 0> }
scale<2,1,1>
translate<-1,-1,0>
rotate<60,0,0>
}

Girado 60º en y
box
{
<1, 1, 1> // one corner position <X1 Y1 Z1>
< .5, .5, .5> // other corner position <X2 Y2 Z2>
pigment { color rgb <1, 1, 0> }
scale<2,1,1>
translate<-1,-1,0>
rotate<0,60,0>
}

El siguiente objeto que vamos a explicar es el text, que es eso texto su sintaxis es :

text
{
ttf          // Tipo de fuente
"cour.ttf", // nombre del archivo de fuente
"POV-Ray",   // Cadena que se escribira
numero,           // extrusion
<x,y,z>            // vector de desplazamiento
}

De momento solo se soportan fuentes ttf asi que el primer parametro sera siempre ttf, el nombre de la fuente habra de tener tambien el camino a la fuente si esta no esta en el mismo directorio que el archivo .pov, la cadena de caracteres es el texto que se vera en nuestra escena, la extrusion es el ancho que tendran las letras al darles la 3ª dimension,es decir, laprofundidad de estas. Por ultimo el vector de desplazamiento, normalmente sera 0 pero en ocasiones nos interesara cambiarlo por un vector que les de a las letras otra direccion que no sea la normal, ademas los vectores siempre nos permiten metre funciones que ya verenos nos pueden dar mucho juego.
Ejemplo:
text
{
ttf
"c:\windows\fonts\cour.ttf",
"POV-Ray",
2,
0
pigment{
color Red
}
translate <-2,0,1>
}
El resultado seria

[email protected]