Persistence of Vision Ray-Tracer

(POV-Ray)
Documentación del usuario 3.0
Versión (incompleta) en Castellano
1 de diciembre de 1997

En esta versión han colaborado:

Roberto Selva
Ricardo Pereyra
Santiago Ordax Solivellas
Ignacio Fernández
Pablo Costas
http://www.arrakis.es/∼pcostas/povray/
1. INTRODUCCIÓN ................................................................................................ 9

1.1. Notación ......................................................................................................................................................9

2. DESCRIPCIÓN DEL PROGRAMA ................................................................... 11

2.1. ¿Qué es el trazado de rayos? ...................................................................................................................11

2.2. ¿Qué es pov-ray? ......................................................................................................................................11

2.3. ¿Qué versión de pov-ray debo usar? ......................................................................................................12

2.3.1. IBM-Pc y compatibles ........................................................................................................................13
2.3.1.1. MS-Dos........................................................................................................................................13
2.3.1.2. Windows......................................................................................................................................13
2.3.1.3. Linux ...........................................................................................................................................14
2.3.2. Apple Macintosh.................................................................................................................................15
2.3.3. Commodore Amiga.............................................................................................................................16
2.3.4. SunOS .................................................................................................................................................17
2.3.5. Unix genérico......................................................................................................................................17
2.3.6. Todas las versiones .............................................................................................................................18
2.3.7. Compilando POV-Ray ........................................................................................................................18
2.3.7.1. Estructura de directorios..............................................................................................................19
2.3.7.2. Configurando el fuente de POV-Ray...........................................................................................20
2.3.7.3. Conclusión...................................................................................................................................20

2.4. Donde encontrar POV-Ray .....................................................................................................................21

2.4.1. Foro de POV-Ray en Compuserve......................................................................................................21
2.4.2. Internet ................................................................................................................................................21
2.4.3. Area de gráficos para PC en América On-Line ..................................................................................21
2.4.4. BBS The Graphics Alternative en El Cerrito, CA ..............................................................................22
2.4.5. PCGNet...............................................................................................................................................22
2.4.6. Libros y cd-roms relacionados con POV-Ray ....................................................................................23

3. COMIENZO RÁPIDO ........................................................................................ 25

3.1. Instalando POV-Ray ................................................................................................................................25

3.2. Utilización básica......................................................................................................................................26

4. TUTORIAL PARA PRINCIPIANTES................................................................. 29

4.1. Tu primera imagen...................................................................................................................................29
4.1.1. El sistema de coordenadas de POV-Ray.............................................................................................29
4.1.2. Añadiendo archivos de inclusión estándar..........................................................................................30
4.1.3. Añadiendo la cámara...........................................................................................................................31
4.1.4. Describiendo un objeto. ......................................................................................................................31
4.1.5. Añadiendo la textura al objeto. ...........................................................................................................32
4.1.6. Definiendo una fuente de luz. .............................................................................................................32

4.2. Usando la cámara .....................................................................................................................................33

4.2.1. Usando el desenfoque .........................................................................................................................33

4.3. Formas simples .........................................................................................................................................35

4.3.1. Caja .....................................................................................................................................................35
4.3.2. Cono....................................................................................................................................................35
4.3.3. Cilindro ...............................................................................................................................................35
4.3.4. Plano ...................................................................................................................................................36
4.3.5. Inclusión de objetos estándar ..............................................................................................................36

4.4. Formas avanzadas ....................................................................................................................................37

4.4.1. Parche bicúbico...................................................................................................................................37
4.4.2. Burbuja................................................................................................................................................37
4.4.2.1. Tipos de componentes y otras características nuevas. .................................................................39
4.4.2.2. Construcciones complejas con burbujas e intensidad negativa. ..................................................40
4.4.3. Campo de alturas.................................................................................................................................42
4.4.4. Objeto torneado (lathe) .......................................................................................................................44
4.4.4.1. Entendiendo el concepto de splines.............................................................................................45
4.4.5. Malla de triángulos .............................................................................................................................49
4.4.6. Polígono ..............................................................................................................................................50
4.4.7. Prisma .................................................................................................................................................53
4.4.7.1. Nuevos trucos para las curvas spline...........................................................................................54
4.4.7.2. Transiciones suaves .....................................................................................................................55
4.4.7.3. Múltiples subformas ....................................................................................................................56
4.4.7.4. Barrido cónico y el efecto de estrechamiento..............................................................................57
4.4.8. Elipsoide supercuádrico ......................................................................................................................59
4.4.9. Superficie de revolución .....................................................................................................................63
4.4.10. Texto .................................................................................................................................................64
4.4.11. Toro...................................................................................................................................................67

4.5. Objetos CSG (Geometría Sólida Constructiva).....................................................................................72

 4.5.1. ¿Qué es CSG? .....................................................................................................................................72
4.5.2. Unión ..................................................................................................................................................72
4.5.3. Intersección .........................................................................................................................................74
4.5.4. Diferencia............................................................................................................................................74
4.5.5. Fusión..................................................................................................................................................75
4.5.6. Observaciones sobre los objetos CSG ................................................................................................76
4.5.6.1. Coincidencia de superficies .........................................................................................................76

4.6. Las fuentes de luz. ....................................................................................................................................76

4.6.1. La fuente de luz ambiente. .................................................................................................................77
4.6.2. La fuente de luz puntual......................................................................................................................77
4.6.3. La fuente de luz cónica (focos). ..........................................................................................................78
4.6.4. La fuente de luz cilíndrica...................................................................................................................79
4.6.5. La fuente de luz extendida. .................................................................................................................79
4.6.6. Asignando un objeto a una fuente de luz. ...........................................................................................81
4.6.7. Fuentes de luz especiales. ...................................................................................................................82
4.6.7.1. Empleando luces sin sombra. ......................................................................................................82
4.6.7.2. Usando atenuación de la luz. .......................................................................................................82
4.6.7.3. Las fuentes de luz y la atmósfera.................................................................................................83

4.7. Opciones de textura simples ....................................................................................................................83

4.7.1. Acabado de superficies. ......................................................................................................................84
4.7.2. Añadiendo abolladuras........................................................................................................................84
4.7.3. Creando patrones de colores. ..............................................................................................................84
4.7.4. Texturas predefinidas..........................................................................................................................85

4.8. Opciones avanzadas de texturas .............................................................................................................85

4.8.1. Patrones de pigmentación y de normal ...............................................................................................86
4.8.2. Pigmentos............................................................................................................................................86
4.8.2.1. Usando pigmentos con lista de colores........................................................................................86
4.8.2.2. Usando pigmentos y patrones......................................................................................................87
4.8.2.3. Usando modificadores de patrones..............................................................................................87
4.8.2.4. Usando pigmentos transparentes y texturas superpuestas ...........................................................88
4.8.2.5. Usando mapas de pigmentos .......................................................................................................89
4.8.3. Normales .............................................................................................................................................90
4.8.3.1. Usando modificadores de normal básicos ...................................................................................91
4.8.3.2. Combinando normales .................................................................................................................91
4.8.4. Acabados.............................................................................................................................................93
4.8.4.1. Usando ambient ...........................................................................................................................93
 4.8.4.2. Usando los reflejos de superficie.................................................................................................94
4.8.4.3. Usando reflection y metallic........................................................................................................95
4.8.4.4. Usando refraction ........................................................................................................................96
4.8.4.5. Añadiendo la atenuación luminosa..............................................................................................96
4.8.4.6. Usando cáusticas simuladas.........................................................................................................97
4.8.4.7. Usando la iridiscencia................................................................................................................100
4.8.5. Halos .................................................................................................................................................101
4.8.5.1. ¿Qué son los halos? ...................................................................................................................101
4.8.5.2. El halo emisor............................................................................................................................102
4.8.5.3. El halo brillante .........................................................................................................................110
4.8.5.4. El halo atenuante .......................................................................................................................111
4.8.5.5. El halo de polvo.........................................................................................................................114
4.8.5.6. Dificultades de los halos............................................................................................................120

4.9. Trabajar con texturas especiales...........................................................................................................122

4.9.1. Trabajar con mapas de pigmentos.....................................................................................................122
4.9.2. Trabajar con mapas de normales.......................................................................................................123
4.9.3. Trabajar con mapas de textura ..........................................................................................................124
4.9.4. Trabajar con listas de texturas...........................................................................................................125
4.9.5. ¿Y las baldosas?................................................................................................................................126
4.9.6. Función promedio .............................................................................................................................126
4.9.7. Trabajar con texturas superpuestas ...................................................................................................126
4.9.7.1. Declarar texturas superpuestas ..................................................................................................128
4.9.7.2. Otro ejemplo de texturas superpuestas ......................................................................................128
4.9.8. Cuando todo falla: mapas de materiales............................................................................................131
4.9.9. Limitaciones de las texturas especiales.............................................................................................133

4.10. Usando los efectos atmosféricos ..........................................................................................................134

4.10.1. Background.....................................................................................................................................134
4.10.2. La esfera celeste..............................................................................................................................135
4.10.2.1. Creando el cielo con un gradiente de colores ..........................................................................135
4.10.2.2. Añadiendo el sol ......................................................................................................................137
4.10.2.3. Añadiendo algunas nubes ........................................................................................................138
4.10.3. La niebla .........................................................................................................................................139
4.10.3.1. La niebla constante ..................................................................................................................139
4.10.3.2. Especificando un mínimo de translucidez ...............................................................................140
4.10.3.3. Creando niebla filtrante ...........................................................................................................141
4.10.3.4. Añadiendo algo de turbulencia a la niebla...............................................................................142
 4.10.3.5. Usando la niebla de superficie.................................................................................................143
4.10.3.6. Usando múltiples capas de niebla............................................................................................144
4.10.3.7. La niebla y los objetos vacíos..................................................................................................145
4.10.4. La atmósfera....................................................................................................................................145
4.10.4.1. Empezando con una habitación vacía......................................................................................145
4.10.4.2. Añadiendo polvo a la habitación .............................................................................................147
4.10.4.3. Eligiendo una buena tasa de muestreo.....................................................................................148
4.10.4.4. Usando una atmósfera coloreada .............................................................................................149
4.10.4.5. Consejos usando la atmósfera..................................................................................................150
PERSISTENCE OF VISION RAYTRACER 9

1. Introducción
Este documento detalla el uso del Trazador de Rayos Persistence of Vision, (POV-Ray). Se
compone de cuatro partes: la guía de instalación, el tutorial, la guía de referencia y los apéndices. La
primera parte (ver secciones "Descripción del Programa" y "Comienzo Rápido") cuenta como obtener y
como instalar POV-Ray. También da una breve introducción al trazado de rayos. El tutorial explica
paso a paso como usar las diferentes características de POV-Ray (ver sección "Tutorial para
Principiantes"). La referencia da una completa descripción de todas las características de POV-Ray
explicando todas las opciones disponibles (activadas por parámetros de la línea de comandos o por
sentencias en archivos INI) y del lenguaje de descripción de escena (ver sección "Referencia de POV-
Ray", sección "Opciones de POV-Ray" y sección "Lenguaje de descripción de escena"). Los apéndices
incluyen trucos y pistas, lecturas sugeridas, direcciones de contacto e información legal.

POV-Ray está basado en DKBTrace 2.12, de David K. Buck y Aaron A. Collins.

1.1. Notación
A lo largo de este documento se seguirá la siguiente notación para denotar palabras clave del lenguaje de
descripción de escena, parámetros de la línea de comandos, palabras clave de archivos INI y nombres
de archivos.

nombre palabra clave del lenguaje de descripción de escena

nombre opción de la línea de comando

nombre palabra clave de archivo INI

NOMBRE nombre de archivo

nombre dirección de Internet, grupo de noticias Usenet

En la versión ASCII del documento no hay diferencias entre las notaciones.

PERSISTENCE OF VISION RAYTRACER 11

2. Descripción del programa

El trazador de rayos Persistence of Vision Raytracer crea imágenes tridimensionales fotorrealistas
usando una técnica llamada trazado de rayos. Lee un archivo de texto conteniendo información que
describe objetos e iluminación en una escena y genera una imagen de esa escena desde el punto de vista
de una cámara, también descrita en el archivo de escena. El trazado de rayos no es de ninguna manera
un proceso rápido, pero produce imágenes de muy alta calidad con reflexiones realistas, sombreado,
perspectiva y otros efectos.

2.1. ¿Qué es el trazado de rayos?

El trazado de rayos es una técnica que calcula una imagen de una escena disparando rayos a la escena.
La escena está construida por formas, fuentes de luz, una cámara, materiales, efectos especiales, etc.

Para cada pixel en la imagen final se disparan uno o más rayos en la escena y se comprueba la
intersección con cada uno de los objetos de la escena. Los rayos se originan en el observador,
representado por la cámara, y pasan a través de la ventana de visión (que representa la imagen final).

Cada vez que el rayo golpea a un objeto, se calcula el color de la superficie en ese punto. Para ello se
determina la cantidad de luz que proviene de cada fuente luminosa para ver si el objeto permanece en la
sombra o no. Si la superficie es reflectora o traslúcida se trazan nuevos rayos para determinar la
contribución de la luz reflejada o refractada en el color final de la superficie.

Los efectos especiales como la luz difusa (radiosidad), efectos atmosféricos y luces extendidas hacen
necesario el trazado de muchos rayos adicionales por cada pixel de la escena.

2.2. ¿Qué es pov-ray?

El Trazador de Rayos Persistence of Vision fue desarrollado a partir de DBKTrace 2.12 (escrito por
David K. Buck y Aaron A. Collins) por un puñado de gente, llamado el POV-Team, en su tiempo
libre. El cuartel general del POV-Team está en el foro POVRAY de CompuServe (ver "Foro POVRAY
en CompuServe" para más detalles).

El paquete POV-Ray incluye instrucciones detalladas para usar el trazador y crear escenas. Se han
incluido muchas escenas asombrosas con POV-Ray para que puedas empezar a crear imágenes
inmediatamente. Estas escenas pueden ser modificadas para que no tengas que empezar desde cero.

Además de las escenas predefinidas, también se suministra una gran biblioteca de formas predefinidas y
de materiales. Puedes incluir estas formas y materiales en tus propias escenas simplemente incluyendo el
nombre de la forma o material y el nombre del archivo fuente correspondiente.

He aquí algunas características de POV-Ray:

♦ Lenguaje de descripción de escena fácil de usar

♦ Gran biblioteca de archivos de escenas asombrosas
♦ Archivos de inclusión estándar que predefinen muchas formas, colores y texturas
2. DESCRIPCIÓN DEL PROGRAMA 12

♦ Archivos de imagen de muy alta calidad (hasta 48 bits de color)

♦ Visualización en IBM-PCs de 15 y 24 bits, usando el hardware apropiado
♦ Crea paisajes usando suaves campos elevados
♦ Fuentes luminosas dirigidas, cilíndricas y extendidas para iluminación sofisticada
♦ Reflejos phong y especulares para conseguir superficies más realistas
♦ Reflexión difusa (radiosidad) para conseguir iluminación realista
♦ Efectos atmosféricos como atmósfera, niebla y arco iris
♦ Halos para modelar efectos como nubes, polvo, fuego y vapor
♦ Varios formatos de imagen, incluyendo Targa, PNG y PPM
♦ Primitivas para figuras básicas, como esferas, cajas, cuádricas, cilindros, conos, triángulos y
planos
♦ Primitivas para figuras avanzadas, como toros (donuts), parches de Bezier, campos elevados
(montañas), burbujas, cuárticas, triángulos suavizados, texto, fractales, supercuádricas, superficies
de revolución, prismas, polígonos y tornos (lathes)
♦ Las figuras se pueden combinar fácilmente para crear nuevas figuras complicadas usando
Geometría Constructiva Sólida (CSG). POV-Ray soporta uniones, mezclas, intersecciones y
diferencias
♦ A los objetos se les asignas materiales llamados texturas (una textura describe el color y las
propiedades de la superficie de una figura)
♦ Distribuciones de color y de normales incluidas: Agate, Bozo, Bumps, Checker, Crakle, Dents,
Granite, Gradient, Hexagon, Leopard, Mandel, Marble, Onion, Quilted, Ripples, Spotted, Spiral,
Radial, Waves, Wood, Wrinkles y mapeado según archivo de imagen
♦ Los usuarios pueden crear sus nuevas texturas o usar las predefinidas, como latón, cromado,
cobre, oro, plata, piedra, madera...
♦ Combinar texturas usando capas de texturas semitransparentes
♦ Previsualizar la imagen mientras la crea (no disponible en todas las plataformas)
♦ Parar el trazado de una escena y continuarlo posteriormente

2.3. ¿Qué versión de pov-ray debo usar?

POV-Ray puede usarse bajo MS-DOS, Windows 3.x, Windows para Trabajo en Grupo 3.11, Windows
95, Windows NT, Apple Macintosh 68k, Power PC, Commodore Amiga, Linux, UNIX y otras
plataformas.

Las ultimas versiones de los archivos necesarios están disponibles en CompuServe, Internet, América
On-line y varios BBS. Vea la sección "Donde Encontrar los archivos de POV-Ray" para obtener más
información.
PERSISTENCE OF VISION RAYTRACER 13

2.3.1. IBM-Pc y compatibles

Normalmente hay tres versiones diferentes para IBM-PC funcionando bajo diversos sistemas
operativos (MS-DOS, Windows y Linux) como se describe más adelante.

2.3.1.1. MS-Dos
La versión para MS-DOS corre bajo MS-DOS o como una aplicación DOS bajo Windows 95,
Windows NT, Windows 3,1 o Windows para Trabajo en Grupo 3.11. También corre bajo OS/2 y
OS/2 WARP.

Requerimientos de hardware y software:

♦ CPU 386 o superior y por lo menos 4 Mb de RAM.

♦ Aproximadamente 6 Mb de espacio en el disco duro para la instalación y de 2 a 10 Mb o más
como espacio de trabajo.
♦ Un editor de texto capaz de editar archivos de texto en formato ASCII. El programa EDIT que
viene con MS-DOS trabajará para archivos de tamaño moderado.
♦ Un visor de archivos gráficos capaz de visualizar archivos en formato GIF y quizás TGA y PNG.
Archivos de POV-Ray Requeridos:

♦ POVMSDOS.EXE: un archivo auto-extraible contiendo el programa, ejemplos de escenas, los

archivos .INC estándar y la documentación en un formato de ayuda de hipertexto con un visor
de ayuda. Este archivo puede estar dividido en archivos más pequeños para facilitar la descarga
del mismo. Chequee el directorio de su sitio de ftp para ver si requieren otros archivos.
Recomendado:

♦ Pentium o 486DX, o también 386 o 486SX con co-procesador matemático .

♦ 8 Mb o más de RAM.
♦ Monitor SVGA, preferiblemente con interface VESA y capacidad de usar los modos Hi color
(color de 16 bits ) o True color (color de 24 bits).
Optativo: el código fuente no es necesario para usar POV-Ray. Se proporciona para curiosos y
aventureros.

♦ POVMSD_S.ZIP: El código fuente en C de POV-Ray para MS-DOS. Contiene partes genéricas y

partes específicas MS-DOS. No incluye ejemplos de escenas, Archivos .INC estándar ni la
documentación, por lo que deberás obtener también el archivo ejecutable.
♦ Un compilador de C qué pueda crear aplicaciones de 32-bit en modo protegido. Soportamos
Watcom 10.5a, Borland 4.52 con DOS Power Pack y gráficos limitados bajo DJGPP 1.12maint4.
No soportamos DJGPP 2.0.

2.3.1.2. Windows
La versión para Windows corre bajo Windows 95, Windows NT y bajo Windows 3.1 o 3.11 si se
agregan las extensiones Win32s. También corre bajo OS/2 WARP.

Requerimientos de hardware y software:

2. DESCRIPCIÓN DEL PROGRAMA 14

♦ CPU 386 o superior y por lo menos 8 Mb de RAM.

♦ Aproximadamente 12 Mb de espacio en el disco duro para la instalación y de 2 a 10 Mb o más
como espacio de trabajo.
Archivos de POV-Ray requeridos:

♦ El archivo de usuario POVWIN3.EXE, un archivo autoextraible contiendo el programa, ejemplos de

escenas, los archivos .INC estándar y la documentación en un formato de ayuda de Windows.
Puede estar dividido en archivos más pequeños para facilitar la descarga del mismo. Verifique el
directorio de su sitio de ftp para ver si se requieren otros archivos.
Recomendado:

♦ Pentium o 486DX, o también 386 o 486SX con co-procesador matemático .

♦ 16 Mb o más de RAM.
♦ Monitor SVGA, preferiblemente con capacidad de usar los modos Hi color (color de 16 bits ) o
True color (color de 24 bits).
Optativo: el código fuente no es necesario para usar POV-Ray. Se proporciona para curiosos y
aventureros.

♦ POVWIN_S.ZIP: el código fuente en C de POV-Ray para Windows Contiene partes genéricas y

partes específicas Windows. No incluye ejemplos de escenas, archivos .INC estándar ni la
documentación, por lo que también deberás obtener el archivo ejecutable.
♦ POV-Ray solo puede ser compilado usando compiladores qué puedan crear aplicaciones de 32
bits para Windows. Soportamos los compiladores Watcom 10.5a, Borland 4.52/5.0. El código
fuente no es necesario para usar POV-Ray, se proporciona sólo para los curiosos y aventureros.

2.3.1.3. Linux
Requerimientos de hardware y software:

♦ CPU 386 o superior y por lo menos 4 Mb de RAM.

♦ Aproximadamente 6 Mb de espacio en el disco duro para la instalación y 2-10 Mb o más como
espacio de trabajo.
♦ Un editor de texto capaz de editar archivos de texto en formato ASCII.
♦ Cualquier versión reciente (1994 en adelante)del kernel de Linux y soporte para formatos
binarios ELF. POV-Ray para Linux no esta en formato a.out.
♦ Bibliotecas ELF libc.so.5, libm.so.5 y uno o ambos de libX11.so.6 o libvga.so.1.
Archivos de POV-Ray requeridos:

♦ POVLINUX.TGZ o POVLINUX.TAR.GZ, un archivo que contiene el binario oficial para cada uno de los
modos SVGALib y X-Windows. También contiene ejemplos de escenas, los archivos .INC
estándar y la documentación.
Recomendado:

♦ Pentium o 486dx o también 386 o 486sx con co-procesador matemático.

PERSISTENCE OF VISION RAYTRACER 15

♦ 8 Mb o más RAM.
♦ Monitor SVGA preferiblemente con capacidad de usar los modos Hi color (color de 16 bits ) o
True color (color de 24 bits).
♦ Si quieres previsualización, requerirá o SVGALib o X-Windows.
♦ Un visor de archivos gráficos capaz de visualizar archivos en formato PPM, TGA o PNG.
Optativo: el código fuente no es necesario para usar POV-Ray. Se proporciona para curiosos y
aventureros.

♦ POVUNI_S.TAR.GZ o POVUNI_S.TGZ, el código fuente en C de POV-Ray para Linux. Contiene

partes genéricas y partes específicas Linux . No incluye ejemplos de escenas, archivos .INC
estándar ni la documentación, por lo cual también debes obtener el archivo ejecutable.
♦ El compilador GNU C y (opcionalmente) archivos de inclusión y bibliotecas X y conocimiento
de como usarlo. Aunque proporcionamos el código fuente genérico para sistemas Unix, no
proporcionamos apoyo técnico sobre cómo compilar el programa.

2.3.2. Apple Macintosh

Las versiones para Macintosh corren bajo el sistema operativo Apple's MacOS versión 7.0 o superior,
en cualquier Macintosh basado en 68020/030/040 (con o sin un coprocesador de punto flotante) o en
cualquier ordenador Power Macintosh.

Requerimientos de hardware y software:

♦ Una CPU 68020 o superior sin una unidad del punto flotante (serie LC, Performa o Centris) y
por lo menos 8 Mb de RAM, o
♦ Una CPU 68020 o superior con una unidad de punto flotante (series Mac II o Quadra) y por lo
menos 8 Mb de RAM, o
♦ Cualquier ordenador Power Macintosh y por lo menos 8 Mb de RAM.
♦ System 7 o más nuevo y color QuickDraw (el System 6 ya no es soportado).
♦ Aproximadamente 6 Mb de espacio libre en el disco para la instalación y de 2 a 10 Mb de espacio
libre adicional como espacio de trabajo.
♦ Una utilidad para visualizar archivos gráficos que soporte los formatos Mac PICT, GIF y quizás
TGA y PNG (las aplicaciones shareware GIFConverter o GraphicConverter son buenas.)
Archivos de POV-Ray requeridos:

♦ POVMACNF.SIT o POVMACNF.SIT.HQX, un archivo stuffit conteniendo la aplicación para Macintosh

no-FPU 68K, ejemplos de escenas, los archivos .INC estándar y documentación (versión más
lenta para Macs sin unidad de punto flotante), o
♦ POVMAC68.SIT o POVMAC68.SIT.HQX, un archivo stuffit conteniendo la aplicación para Macintosh
FPU 68K, ejemplos de escenas, los archivos .INC estándar y documentación (versión más rápida
para Macs con unidad de punto flotante), o
♦ POVPMAC.SIT o POVPMAC.SIT.HQX, un archivo stuffit conteniendo la aplicación nativa del Power
Macintosh, ejemplos de escenas, los archivos .INC estándar y documentación.
2. DESCRIPCIÓN DEL PROGRAMA 16

Recomendado:

♦ 68030/33 o más rápido con unidad de punto flotante, o cualquier Power Macintosh.
♦ 8 Mb o más de RAM para Macintosh 68K, 16 Mb o más para sistemas Power Macintosh.
♦ Monitor preferentemente en color: de 256 colores esta bien, pero de miles o millones de colores
está incluso mejor.
Optativo: el código fuente no es necesario para usar POV-Ray. Se proporciona para curiosos y
aventureros. POV-Ray se puede compilar usando Apple's MPW 3.3, Metrowerks CodeWarrior 8 o
Symantec 8.

♦ POVMACS.SIT o POVMACS.SIT.HQX, el código fuente en C completo de POV-Ray para Macintosh.

Contiene partes genéricas y partes específicas Macintosh. No incluye ejemplos de escenas,
archivos .INC estándar ni la documentación por lo que también deberás obtener el archivo
ejecutable.

2.3.3. Commodore Amiga

La versión para Amiga viene en varios sabores: 68000/68020 sin FPU (muy lenta, no se recomienda),
68020/68881(68882), 68030/68882 y 68040. Hay también dos sub-versiones, una sólo con un interface
CLI, y otra con un interface GUI (requiere MUI 3.1). Todas las versiones corren bajo OS2.1 y
superiores. Existe soporte para pensharing y visualización de ventanas bajo OS3.x con paletas de 256
colores y soporte para la biblioteca CybeGFX.

Requerimientos:

♦ Por lo menos 4 Mb de RAM.

♦ Por lo menos 2 Mb de espacio en el disco duro, se recomiendan de 5 a 20 Mb más para espacio
de trabajo.
♦ Un editor de texto ASCII, GUI configurable para lanzar el editor de su elección.
♦ Visor de archivos gráficos: POV-Ray da como resultado archivos en formato PNG, Targa
(TGA) y PPM, convertidores desde la distribución PPMBIN están incluidos para convertir estas
a archivos IFF ILBM
Archivos de POV-Ray requeridos:

♦ POVAMI.LHA, un archivo en formato .LHA conteniendo el ejecutable, ejemplos de escenas, los

archivos .INC estándar y la documentación.
Recomendado:

♦ 8 Mb o más de RAM.
♦ Procesador 68030, 68882 o superior.
♦ Tarjeta gráfica de 24-bits (con soporte para la biblioteca CyberGFX)
Tan pronto como se haga público un compilador estable para sistemas Amiga PowerPC, los planes son
agregar este a la lista de sabores.

Optativo: el código fuente no es necesario para usar POV-Ray. Se proporciona para curiosos y
aventureros.
PERSISTENCE OF VISION RAYTRACER 17

♦ POVLHA_S.ZIP, el código fuente en C de POV-Ray para Amiga Contiene partes genéricas y partes
específicas Amiga. No incluye ejemplos de escenas, archivos .INC estándar ni la documentación
por lo que también deberás obtener el archivo ejecutable.

2.3.4. SunOS
Requerimientos de hardware y software:

♦ Un procesador Sun SPARC y por lo menos 4 Mb de RAM.

♦ Aproximadamente 6 Mb de espacio en el disco duro para la instalación y de 2 a 10 Mb o más
para espacio de trabajo.
♦ Un editor de texto capaz de editar archivos de texto ASCII.
♦ SunOS 4.1.3 u otro sistema operativo capaz de correr el archivo binario (Solaris o posiblemente
Linux para Sparc).
Archivos de POV-Ray requeridos:

♦ POVSUNOS.TGZ o POVSUNOS.TAR.GZ, archivo conteniendo un ejecutable oficial para los modos

sólo texto y X-Windows. También contiene ejemplos de escenas, los archivos .INC estándar y la
documentación.
Recomendado:

♦ 8 Mb de RAM o más.
♦ Si quieres previsualización, requerirá X-Windows o un terminal X.
♦ Preferiblemente capacidad para visualizar color verdadero de 24 bits(True Color), aunque se sabe
que el código X-Windows funciona con cualquier resolución y número de colores.
♦ Un visor de archivos gráficos capaz de visualizar formatos PPM, TGA o PNG.
Optativo: el código fuente no es necesario para usar POV-Ray. Se proporciona para curiosos y
aventureros.

♦ POVUNI_S.TGZ o POVUNI_S.TAR.GZ, el código fuente en C de POV-Ray para UNIX. Contiene

partes genéricas UNIX y partes específicas Linux. No incluye ejemplos de escenas, archivos .INC
estándar ni la documentación, por lo que también deberás obtener el archivo ejecutable.
♦ Un compilador de C y (opcionalmente) los archivos de inclusión y bibliotecas X, y
conocimiento de cómo usarlo. Aunque proporcionamos el código fuente genérico para
sistemas UNIX, no proporcionamos apoyo técnico sobre cómo compilar el programa.

2.3.5. Unix genérico

Requerimientos:

♦ POVUNI_S.TGZ o POVUNI_S.TAR.GZ, el código fuente en C de POV-Ray para Unix. O cualquier

archivo conteniendo el código fuente genérico para Unix, y el especifico para X-Windows.
♦ POVUNI_D.TGZ o POVUNI_D.TAR.GZ, o cualquier archivo conteniendo los ejemplos de escenas, los
archivos .INC estándar y la documentación. Éste podría ser uno de los archivos ejecutables para
Linux o SunOS que se describieron antes.
2. DESCRIPCIÓN DEL PROGRAMA 18

♦ Un compilador C para tu ordenador y conocimiento de como usarlo. Aunque proporcionamos

el código fuente genérico para sistemas Unix, no proporcionamos apoyo técnico sobre cómo
compilar el programa.
♦ Un editor de texto capaz de editar archivos de texto ASCII.
Recomendado:

♦ Co-procesador matemático.
♦ 8 Mb o más de memoria RAM.
♦ Un visor de archivos gráficos capaz de visualizar formatos PPM, TGA o PNG.
Opcional:

♦ X Windows si quieres previsualizar el trazado.

♦ También necesitarás los archivos de inclusión de X-Windows. Si no estás familiarizado con la
compilación de programas para X-Windows podrías necesitar algo de ayuda de alguien que
conozca tu instalación, porque los archivos de inclusión de X-Windows y las bibliotecas no
siempre están en el lugar habitual.

2.3.6. Todas las versiones

Cada archivo ejecutable incluye la documentación completa de POV-Ray mismo así como instrucciones
específicas para usar POV-Ray con su tipo de plataforma.

Todas las versiones del programa comparten las mismas formas, iluminación y texturas. En otras
palabras, un IBM-PC puede crear las mismas imágenes qué un superordenador Cray siempre que tenga
bastante memoria.

Cada usuario deseará obtener el ejecutable que mejor se adapte al hardware de su ordenador. Consulta
la sección “Donde encontrar los archivos de POV-Ray” para ver donde encontrar estos archivos.
Puedes contactar con estas fuentes para encontrar la mejor versión para ti y tu ordenador

2.3.7. Compilando POV-Ray

Las secciones siguientes te ayudarán a compilar el código fuente en C portable en una versión ejecutable
de POV-Ray qué funcione. Son sólo para ésas personas qué quieren compilar una versión personalizada
de POV-Ray o portarlo a una plataforma o compilador no soportado.

La primera pregunta qué debes hacerte antes de proceder es ¿realmente necesito compilar POV-Ray?
Las versiones ejecutables oficiales del POV-Ray Team están disponible para MS-DOS, Windows
3.1x/95/NT, Mac 68k, Mac Power PC, Amiga, Linux para Intel x86, y SunOS. Otras compilaciones no
oficiales para otras plataformas estarán pronto disponibles. Si no piensas agregar cualquier característica
personalizada o experimental al programa y si ya existe un ejecutable para tu plataforma, entonces no
necesitas compilar este programa.

Si quieres proceder deberás estar muy seguro de ti mismo. Las secciones siguientes y otra
documentación relacionada a la compilación asumen que sabes lo qué estas haciendo. Asumen qué
tienes un compilador de C adecuado instalado y funcionando. Asumen que sabes como compilar y
enlazar programas de múltiples partes usando una utilidad make o un archivo de proyecto IDE si tu
compilador los soporta. Ya que los archivos make y los archivos de proyecto a menudo especifican
PERSISTENCE OF VISION RAYTRACER 19

información sobre unidades, directorios o paths, no podemos prometerte qué nuestros archivos make o
de proyectos trabajarán en tu sistema. Asumimos que sabes hacer cambios en los archivos make y de
proyectos para especificar donde se localizan tus bibliotecas de sistema y otros archivos necesarios.

En general no debes esperar ningún apoyo técnico del POV-Ray Team sobre cómo compilar el
programa. Todo se provee tal como esta. Todo lo qué podemos decir con certeza es qué pudimos
compilar él código en nuestros sistemas. Si no trabaja para ti probablemente no podamos decirte
porqué.

No hay ninguna documentación técnica para el código fuente mismo salvo los comentarios en los
archivos fuente. Intentamos hacer lo mejor para escribir código claro y bien comentado, pero algunas
secciones están apenas comentadas y algunos comentarios pueden estar desactualizados. No
proporcionamos ningún soporte técnico para ayudarte a agregar características. No explicamos cómo
trabaja una característica en particular. En algunos casos la persona qué escribió una parte del programa
ya no esta hace tiempo activamente en el Equipo y no sabemos exactamente cómo trabaja.

Cuando hagas cualquier versión personalizada de POV-Ray o cualquier compilación extraoficial, por
favor asegúrate de haber leído y seguir todas las provisiones de nuestra licencia en la sección
"Copyright". En general puedes modificar y usar POV-Ray para ti mismo, sin embargo si quieres
distribuir tu versión extraoficial debes seguir nuestras reglas. No puedes bajo cualquier circunstancia
usar porciones del código fuente de POV-Ray en otros programas.

2.3.7.1. Estructura de directorios

El código fuente de POV-Ray se distribuye en archivos en una jerarquía particular de directorios o
carpetas. Cuando extrae los archivos debe hacerlo de modo qué resguarde la estructura de directorios
intacta. En general sugerimos qué cree un directorio llamado povray3 y extraiga los archivos allí. La
extracción creará un directorio llamado source con muchos archivos y subdirectorios.

En general, hay archivos separados para cada plataforma de hardware y sistema operativo, pero cada
uno de estos archivos soporta más de un compilador. Por ejemplo aquí esta la estructura de directorios
para el archivo MS-DOS.
SOURCE
SOURCE\LIBPNG
SOURCE\ZLIB
SOURCE\MSDOS
SOURCE\MSDOS\PMODE
SOURCE\MSDOS\BORLAND
SOURCE\ MSDOS\DJGPP
SOURCE\MSDOS\WATCOM

El directorio SOURCE contiene archivos fuente para las partes genéricas de POV-Ray qué son comunes
a todas las plataformas. El directorio SOURCE\LIBPNG contiene archivos para compilar una biblioteca de
rutinas utilizadas en la lectura y escritura de archivos gráficos en formato PNG (Portable Network
Graphic). El directorio SOURCE\ZLIB contiene archivos para compilar una biblioteca de rutinas utilizada
por libpng para comprimir y descomprimir flujos de datos. Todos estos archivos son usados por todas
las plataformas y compiladores. Están en cada versión de los archivos fuente.

El directorio SOURCE\MSDOS contiene todos los archivos fuente de la versión para MS-DOS común a
todos los compiladores MS-DOS soportados. El subdirectorio PMODE contiene archivos fuente para
PMODE.LIB qué son necesarios para todas las versiones de MS-DOS. Los subdirectorios BORLAND, DJGPP
y WATCOM contienen fuente, archivos make y archivos de proyecto para compiladores de C de Borland,
DJGPP y Watcom.
2. DESCRIPCIÓN DEL PROGRAMA 20

El directorio SOURCE\MSDOS esta sólo en el archivo MS-DOS. De manera semejante el archivo

Windows contiene un directorio SOURCE\WINDOWS. El archivo Unix contiene un directorio
SOURCE/UNIX etc.

El directorio SOURCE\MSDOS contiene un archivo CMPL_MSD.DOC qué contiene información de

compilación específica de la versión MS-DOS. Otros directorios específicos de plataforma contienen
archivos CMPL_XXX.DOC similares y los subdirectorios específicos del compilador también contienen
archivos CMPL_XXX.DOC específicos. Asegúrese de leer todos los archivos CMPL_XXX.DOC pertinentes
para su plataforma y compilador.

2.3.7.2. Configurando el fuente de POV-Ray

Cada plataforma tiene un archivo de cabecera (header) llamado CONFIG.H qué generalmente está en el
directorio específico de la plataforma, pero podría estar en el directorio específico del compilador.
Algunas plataformas tienen versiones múltiples de este archivo y podrías necesitar copiarlo o
renombrarlo como CONFIG.H. Este archivo se incluye en cada módulo de POV-Ray. Contiene todos los
prototipos, macros y otras definiciones qué se requieren en las partes genéricas de POV-Ray, pero debe
ser personalizado para una plataforma o compilador en particular.

Por ejemplo, sistemas operativos diferentes usan caracteres diferentes como separador entre directorios
y nombres del archivo. MS-DOS usa una barra invertida(\), Unix una barra normal(/) y Mac una
coma(,). El archivo CONFIG.H para MS-DOS y Windows contienen lo siguiente:
#define FILENAME_SEPARATOR '\'
qué instruye a la parte genérica de POV-Ray para usar una barra invertida(\).

Cada personalización que la parte genérica del código requiere tiene un valor por defecto en el archivo
SOURCE\FRAME.H, qué también se incluye en cada módulo después de CONFIG.H. El archivo de cabecera
FRAME.H contiene muchos grupos de definiciones como esta:

#ifndef FILENAME_SEPARATOR
#define FILENAME_SEPARATOR '/'
#endif
el cual básicamente dice qué si no está definido previamente en CONFIG.H, entonces este es su valor por
defecto. Verifica FRAME.H para ver qué otros valores puedes querer configurar.

Si se usa cualquier definición para especificar una función especifica de una plataforma también se
deberá incluir un prototipo para esa función. El archivo SOURCE\MSDOS\CONFIG.H, por ejemplo, no
sólo contiene el macro:
#define POV_DISPLAY_INIT(w,h) MSDOS_Display_Init ((w), (h));
para definir el nombre de la función de inicialización de visualización de gráficos, también contiene el
prototipo:
void MSDOS_Display_Init (int w, int h);
Si piensas portar POV-Ray hacia una plataforma no soportada debes comenzar probablemente con la
versión más simple para Unix sin previsualización. Después agrega nuevos trozos personalizados a
través del archivo CONFIG.H.

2.3.7.3. Conclusión
Comprendemos que las secciones anteriores son solo los primeros pasos, pero la mitad de la diversión
de trabajar en los fuentes de POV-Ray es escarbar en ellos y figurártelo por ti mismo. Así es como los
PERSISTENCE OF VISION RAYTRACER 21

miembros del POV-Ray Team comenzaron. Hemos tratado de hacer el código tan claro como
pudimos.

Asegúrate de leer los archivos CMPL_XXX.DOC en los directorios de tu plataforma y compilador

específicos para obtener alguna ayuda menor más si trabaja en una plataforma o compilador soportados.

¡Buena suerte !

2.4. Donde encontrar POV-Ray

Las ultimas versiones del software POV-Ray están disponibles de las siguientes fuentes.

2.4.1. Foro de POV-Ray en Compuserve

La oficina principal de POV-Ray está en CompuServe, en el foro POVRAY, qué es dirigido por algunos
de los miembros del equipo. Nos reunimos allí para compartir información, programas útiles, utilidades
y gráficos creados con POV-Ray. Todo el mundo es bienvenido para unirse a la acción en CIS:
POVRAY. ¡Esperamos verte allí! Puedes obtener información de como unirse a CompuServe llamando
al (800)848-8990 o visitando la página principal de CompuServe en http://www.compuserve.com.
Acceso directo a CompuServe también esta disponible en Japón, Europa y muchos otros países.

2.4.2. Internet
El hogar en Internet de POV-Ray está disponible a través del world wide web a través de la dirección
http://www.povray.org y vía ftp como ftp.povray.org. Por favor, visítala a menudo para conocer los
últimos archivos, utilidades, noticias e imágenes del sitio oficial de POV-Ray en Internet.

El grupo de noticias comp.graphics.rendering.raytracing es visitado por muchos usuarios

competentes de POV-Ray qué están muy deseosos de compartir su conocimiento. Generalmente
primero te invitan a curiosear unos pocos archivos para ver si alguien ya ha contestado la misma
pregunta, y por supuesto, a qué sigas la apropiada "netiquette". Si tienes cualquier duda sobre las
calificaciones de las personas qué frecuentan el grupo, unos pocos minutos empleados en la pagina de la
Competición de Raytracing en www.povray.org te convencerán rápidamente.

2.4.3. Area de gráficos para PC en América On-Line

Hay ahora un área en América On-Line dedicada al soporte e información de POV-Ray. Puedes
encontrarla en la sección PC Graphics de AOL. Sigue la palabra clave POV (la palabra clave
PCGRAPHICS te conducirá al principio de la sección relacionada con los gráficos). Esta área incluye
también los ejecutables para Apple Macintosh. Lo mejor sería qué los mensajes sean dejados en la
sección Company Support. Normalmente, Bill Pulver (BPulver) es nuestro representante allí.
2. DESCRIPCIÓN DEL PROGRAMA 22

2.4.4. BBS The Graphics Alternative en El Cerrito, CA

Para todos aquellos en la costa oeste1, podéis encontrar los archivos de POV-Ray en The Graphics
Alternative BBS. Es una gran BBS gráfica dirigida por Adam Shiffman. TGA es una BBS de alta
calidad, activa y progresiva que oferta mensajería y archivos de calidad a sus más de 1300 usuarios.

510-524-2780 (PM14400FXSA v.32bis 14.4k, Público)

510-524-2165 (USR DS v.32bis/ HST 14.4k, Subscriptores)

2.4.5. PCGNet
La red Profesional de CAD y Gráficos (PCGnet) sirve a ambas comunidades, CAD y Gráficos
haciendo ampliamente disponible información útil.

Anteriormente conocida como ADEnet, PCGnet es una red nueva que incorpora nodos nuevos y
enfoca uniformemente ambos tópicos relacionados, CAD y Gráficos, incluyendo, pero no limitada a,
los temas siguientes: diseño, dibujo, ingeniería, modelado 2d y 3d, multimedia, sistemas, imagen raster,
trazado de rayos, rendering y animación 3d.

PCGnet esta diseñada para servir las necesidades de todos los visitantes estimulando el interés y
generando foros de soporte para usuarios activos qué tienen un interés en los temas relacionados al
CAD y los gráficos previamente mencionados; el interés y soporte se genera a través de las conferencias
de mensajes de PCGnet, compartiendo archivos a través de la red, noticias de la industria y boletines de
prensa. Las conferencias de mensajes de PCGnet son foros moderados diseñados acomodar discusiones
amistosas, y aun así profesionales e informativas sobre los asuntos relacionados con el CAD y los
gráficos.

TGA BBS sirve como eje central para una gran red de sistemas BBS orientados a los gráficos alrededor
del mundo. La siguiente es una descripción concisa de los nodos activos de PCGNet al momento qué
este documento fue escrito. El POV-Team no puede responder sobre la validez de esta información, ni
verificar qué cualquiera de estas BBS distribuyan POV-Ray.

EE.UU. y Canadá
411-Exchange Alpharetta GA 404-345-0008
Autodesk Global Village San Rafael CA 415-507-5921
CAD/Engineering Services Hendersonville TN 615-822-2539
Canis Major Nashville TN 615-385-4268
CEAO BBS Columbus OH 614-481-3194
CHAOS BBS Columbia MO 314-874-2930
Joes CODE BBS West Bloomfield MI 810-855-0894
John's Graphics Brooklyn Park MN 612-425-4436
PC-AUG Phoenix AZ 602-952-0638
SAUG BBS Bellevue WA 206-644-7115
Space Command BBS Kennewick WA 509-735-4894
The CAD/fx BBS Mesa AZ 602-835-0274
The Drawing Board BBS Anchorage AK 907-349-5412
The Graphics Alternative El Cerrito CA 510-524-2780
The Happy Canyon Denver CO 303-759-3598
Los New Graphics BBS Piscataway NJ 908-271-8878
The University Shrewsbury Twp NJ 908-544-8193
The virtual Dimension Oceanside CA 619-722-0746

1 De los Estados Unidos, obviamente (N. de los T.)

PERSISTENCE OF VISION RAYTRACER 23

Time-Out BBS Sadsburyville PA 610-857-2648

Australia
MULTI-CAD BBS Magazine Toowong QLD 61-7-878-2940
My Computer Company Erskineville NSW 61-2-557-1489
Sydney PCUG Compaq BBS Caringbah NSW 61-2-540-1842
The Baud Room Melbourne VIC 61-3-481-8720
Austria
Austrian AutoCAD User Group Graz 43-316-574-426
Bélgica
Lucas Visions BBS Boom 32-3-8447-229
Dinamarca
Horreby SuperBBS Nykoebing Falster 45-53-84-7074
Finlandia
DH-Online Jari Hiltunen 358-9-40562248
Triplex BBS Helsinki 358-9-5062277
Francia
CAD Connection Montesson 33-1-39529854
Zyllius BBS! Saint Paul 33-93320505
Alemania
Ray BBS Munich Munich 49-89-984723
Tower of Magic Gelsenkirchen 49-209-780670
Países Bajos
BBS Bennekom: Fractal Board Bennekom 31-318-415331
CAD-BBS Nieuwegein 31-30-6090287
31-30-6056353
Foundation One Baarn 31-35-5422143
Nueva Zelanda
The Graphics Connections Wellington 64-4-566-8450
The Graphics Connections II Nuevo Plymouth 64-6-757-8092
The Graphics Connections III Auckland 64-9-309-2237
Slovenia
MicroArt Koper 386-66-34986
Suecia
Autodesk On-line Gothenburg 46-31-401718
Reino Unido
CADenza BBS Leicester, UK 44-116-259-6725
Raytech BBS Tain, Scotland 44-1862-83-2020
The Missing Link Surrey, England 44-181-641-8593
Números de países o de larga distancia podrían requerir usar números adicionales. Consulta a tu
compañía telefónica local.

2.4.6. Libros y cd-roms relacionados con POV-Ray

Los artículos siguientes fueron producidos por miembros del POV-Team. Aunque sólo tienen presente
a POV-Ray 2.2 todavía serán útiles. El siguiente paso es actualizar el cdrom de POV-Ray a la versión 3,
con una versión nueva que se espera para la primera la mitad de 1997.
2. DESCRIPCIÓN DEL PROGRAMA 24

Los libros listados abajo se han sido descatalogados recientemente, pero pueden encontrarse todavía en
algunas librerías o bibliotecas (Visita http://www.dnai.com:80waite/ para más detalles).
Ray Tracing Creations, 2d Ed.
Chris Young and Drew Wells
ISBN 1-878739-69-7
Waite Group Press, 1994
700 paginas con insertos en color y POV-Ray 2.2 en discos MS-DOS de 3.5".
Ray Tracing Worlds with POV-Ray
Alexander Enzmann, Lutz Kretzschmar, Chris Young
ISBN 1-878739-64-6
Waite Group Press, 1994
Incluye el modelador Moray 1.5x y POV-Ray 2.2 en discos MS-DOS de 3.5".
Ray Tracing for the Macintosh CD
Eduard Schwan
ISBN 1-878739-72-7
Waite Group Press, 1994
Viene con un CD-ROM lleno de escenas, imágenes, películas QuickTime, y una referencia de palabras
clave interactiva. También un disco flexible con POV-Ray para aquellos que no tienen un lector de CD-
ROM.

'The Official POV-Ray CDROM'

El cdrom Oficial de POV-Ray es una recopilación de imágenes, fuentes de escenas, fuentes de

programas, utilidades y trucos sobre POV-Ray y los gráficos 3D provenientes de Internet y
CompuServe. Dirigido no sólo a aquellos qué quieren crear sus propias imágenes o hacer trabajos de
programación general en 3D, sino también a aquellos que quieren simplemente admirar unas imágenes
del alta calidad hechas por algunos de los mejores artistas de POV-Ray, y aprender de su código fuente.
El cdrom contiene más de 500 imágenes trazadas.

Es un buen recurso para aquellos qué están aprendiendo sobre POV-Ray, así como aquellos que ya
tienen experiencia, y contiene un tutorial interactivo basado en Windows. El disco viene con un poster
desplegable y una hoja de referencia. El CD es compatible con los formatos DOS/Windows y
Macintosh.

El cdrom esta disponible también en la World Wide Web, en http://www.povray.org/pov-cdrom. Para

más detalles visita http://www.povray.org/povcd.
PERSISTENCE OF VISION RAYTRACER 25

3. Comienzo rápido
La siguiente sección describe como instalar rápidamente POV-Ray y trazar escenas de ejemplo en tu
ordenador. Se asume que estás usando un ordenador compatible con IBM-PC con MS-DOS. Para otras
plataformas debes buscar la documentación específica incluida en el archivo que contiene POV-Ray.

3.1. Instalando POV-Ray

En el ejecutable para tu ordenador se incluyen instrucciones específicas para la instalación. En general,
hay dos formas de instalar POV-Ray.2

[Ten en cuenta que usamos la palabra “directorio”. Tu sistema operativo puede que use otro término
(subdirectorio, carpeta, etc.)]

1) La forma chapucera: crea un directorio llamado POVRAY y copia todos los archivos de POV-Ray en
el. Edita y ejecuta todos los archivos y programas desde este directorio. Este método funciona, pero no
es el recomendado.

O la forma recomendada:

2) Crea un directorio llamado POVRAY y varios subdirectorios llamados INCLUDE, DEMO, SCENES, UTIL.
Los archivos autoextraíbles de algunas versiones del programa crean estos directorios por ti. Si los creas
tú mismo, el árbol de directorios debería quedar parecido a esto:
\--
|
+POVRAY --
|
+INCLUDE
|
+DEMO
|
+SCENES
|
+UTIL
Copia los ejecutables y la documentación al directorio POVRAY. Copia los archivos de inclusión estándar
en el subdirectorio INCLUDE. Copia las escenas de ejemplo en el subdirectorio SCENES. Y copia cualquier
utilidad relacionada con POV-Ray en el subdirectorio UTIL. Las escenas que crees irán en el
subdirectorio SCENES. También tendrás que añadir los directorios \POVRAY y \POVRAY\UTIL a tu “path”,
para que los programas puedan ser ejecutados desde cualquier directorio.

Ten en cuenta que algunos sistemas operativos no tienen soporte para múltiples trayectorias de
búsqueda.

2 Si utilizas el programa de instalación de POV-Ray, este se encargará de crear la estructura de directorios

necesaria. En este caso puedes omitir esta sección (N. de los T.)
3. COMIENZO RÁPIDO 26

El segundo método es un poco más complicado de poner a punto, pero es el preferido. Hay muchos
archivos asociados a POV-Ray que son mucho más fáciles de manejar cuando están separados en varios
directorios.

3.2. Utilización básica

Nota: si no instalas el programa usando INSTALL.EXE, los ejemplos e instrucciones siguientes no
funcionarán. El proceso de instalación configura POVRAY.INI y varios archivos BATimportantes. Sin
esos archivos configurados, los ejemplos siguientes no funcionarán.

El propósito básico de POV-Ray es leer una descripción de una escena escrita en el lenguaje de POV y
escribir un archivo conteniendo la imagen. Estos archivos de escena son texto ASCII que puedes crear
usando un editor de texto. Con el paquete se incluyen docenas de archivos de ejemplo para ilustrar las
características.

El programa se ejecuta escribiendo un comando desde el símbolo de MS-DOS. El comando es povray

y debe ir seguido de uno o más parámetros. Cada parámetro comienza con un signo más o menos, y
van separados entre sí por espacios. Los parámetros pueden estar en mayúsculas o minúsculas.

Nota: los ejemplos en esta documentación asumen que has instalado POV-Ray en el directorio
C:\POVRAY3. El instalador te permitirá instalar POV-Ray en cualquier sitio y configurará el programa
para la unidad y directorio que especifiques. Simplemente sustituye esa unidad y directorio donde te
digamos que uses C:\POVRAY3. Cámbiate a ese directorio ahora. Luego teclea la siguiente línea de
comando y pulsa [ENTER}.
POVRAY +ISHAPES +D1
El parámetro +I (de input) le dice al programa que archivo debe leer como entrada. Si no le das una
extensión al nombre del archivo, se asume .POV. De modo que +Ishapes le dice que lea SHAPES.POV
para ser trazado.

El parámetro +D (de display) le dice al programa que active la previsualización gráfica. El parámetro -D
la desactivaría. El número “1” le dice que tipo de adaptador gráfico usar. El tipo “1” es el antiguo
adaptador estándar VGA a 320 por 200 puntos de resolución y 256 colores. Totalmente garantizado
que funcionará en cualquier tarjeta de vídeo VGA.

Hay otras opciones activas además de las que especificaste en la línea de comandos. Se guardan en un
archivo llamado POVRAY.INI que es creado por el programa de instalación. POV-Ray busca
automáticamente este archivo en el mismo directorio donde reside POVRAY.EXE. Mira las secciones
“Archivos INI” y “Usando los archivos INI” para obtener más información sobre POVRAY.INI y otros
archivos INI.

Al ejecutar el comando anterior, verás aparecer brillantes formas geométricas a medida que POV-Ray va
calculando el color de cada pixel línea a línea. Probablemente estarás descontento con el resultado
gráfico. Esto es debido a que es únicamente una previsualización. La imagen actual contiene 24 bits de
color pero no se puede mostrar tan alta calidad usando una simple tarjeta VGA con un conjunto de 256
colores fijos. Si tu hardware soporta el interface estándar VESA o si tienes un controlador VESA
instalado, prueba a ejecutar con el parámetro +DG en lugar de +D1. Esto te dará acceso a los varios
modos que tu tarjeta de vídeo puede usar. Si tienes capacidad para color de 15 o 16 bits prueba +DGH,
o si tienes capacidad para color de 24 bits prueba +DGT para ver la imagen en todo su esplendor.
Consulta la sección “Tipos de visualización” más adelante para obtener más información sobre la
previsualización gráfica.
PERSISTENCE OF VISION RAYTRACER 27

Cuando el programa termine oirás unos pitidos. Después de admirar la imagen pulsa [ENTER]. Verás
una pantalla de texto con estadísticas. Si el texto es demasiado largo para caber en la pantalla puedes
pulsar las teclas “cursor arriba” o “cursor abajo” para leer más texto. Fíjate en las pestañas que hay en la
parte inferior de la pantalla. Pulsa las teclas “cursor derecha” o “cursor izquierda” para leer otra
información interesante. Pulsa [ENTER] de nuevo para salir de POV-Ray.
PERSISTENCE OF VISION RAYTRACER 29

4. Tutorial para principiantes

El Tutorial para Principiantes explica paso a paso como usar el lenguaje de descripción de escena de
POV-Ray para crear tus propias escenas. Se explica el uso de casi todas las características del lenguaje de
POV-Ray. Aprenderás las cosas básicas como donde colocar la cámara o las fuentes de luz. También
aprenderás como crear una gran variedad de objetos y como asignarles texturas. Las características mas
sofisticadas, como la radiosidad, los halos y los efectos atmosféricos también serán explicados con
detalle.

Las siguientes secciones explican las características de POV más o menos en el mismo orden en que
aparecen en el capítulo de Referencia.

4.1. Tu primera imagen

Vamos a crear el archivo de escena para una imagen sencilla. Como las esferas son las formas más
comunes en los trazadores, es lo primero que usaremos.

4.1.1. El sistema de coordenadas de POV-Ray

Primero hemos de decirle a POV-Ray donde situar nuestra cámara y hacia donde apuntará. Para hacer
esto, usamos coordenadas 3D. El sistema de coordenadas habitual de POV-Ray tiene el sentido
positivo del eje Y apuntando hacia arriba, el sentido positivo del eje X hacia la derecha y el sentido
positivo del eje Z apuntando hacia el interior del monitor, tal y como muestra la figura:

Figura 1: El sistema de coordenadas de mano izquierda (el

eje Z apunta alejándose de ti)

Este tipo de sistema de coordenadas se llama "de mano izquierda". Si usas los dedos de tu mano
izquierda puedes ver fácilmente porque se llama así. Apunta el pulgar hacia la dirección positiva del eje
X, el dedo índice hacia la dirección positiva del eje Y, y el dedo medio hacia la dirección positiva del eje
Z. Sólo puedes hacer esto con la mano izquierda. Si hubieras usado la mano derecha no habrías sido
capaz de apuntar el dedo medio hacia la dirección correcta.
4. TUTORIAL PARA PRINCIPIANTES 30

La mano izquierda se puede usar también para determinar las direcciones de rotación. Para hacer esto
debes practicar el famoso ejercicio de Aerobic Infográfico. Toma tu mano izquierda, y apunta el pulgar
hacia la dirección positiva del eje de rotación. El resto de los dedos se curvarán en la dirección positiva
de rotación. Del mismo modo, si apuntas hacia la dirección negativa del eje, los dedos se curvarán sobre
la dirección negativa de rotación.

Figura 2: Aerobic Infográfico para determinar el sentido de

rotación

En la ilustración, la mano izquierda se curva sobre el eje X. El dedo pulgar apunta hacia la dirección
positiva del eje X y los dedos se curvan sobre la dirección positiva de rotación.

Si quieres usar un sistema de coordenadas de mano derecha, como hacen algunos sistemas de CAD
como AutoCAD, has de modificar el vector right en la especificación de la cámara. Mira la descripción
detallada en la sección "Sistemas de coordenadas levógiros y dextrógiros". En un sistema de mano
derecha debes usar tu mano derecha para el Aerobic.

Ten en cuenta que hay alguna controversia sobre si el método que usa POV-Ray para obtener un
sistema de coordenadas de mano derecha es realmente válido. Si quieres evitarte problemas te
sugerimos que uses el sistema de mano izquierda, sobre el que no hay disputa.

4.1.2. Añadiendo archivos de inclusión estándar.

Usando tu editor de textos favorito, crea un archivo llamado DEMO.POV. Ahora teclea lo siguiente
(POV-Ray distingue entre mayúsculas y minúsculas, así que asegúrate de que estén correctas).
#include "colors.inc" // Los archivos de inclusión contienen
#include "shapes.inc" // elementos de escena predefinidos
#include "finish.inc"
#include "glass.inc"
#include "metals.inc"
#include "stones.inc"
#include "woods.inc"
La primera sentencia de inclusión lee las definiciones de varios colores útiles. La segunda sentencia de
inclusión las definiciones de algunas formas útiles. Las siguientes leen definiciones de acabados y
texturas de vidrios, metales, piedras y maderas.
PERSISTENCE OF VISION RAYTRACER 31

Sólo debes incluir aquellos archivos que realmente uses en tu escena. Algunos de los archivos de
inclusión que vienen con POV-Ray son bastante largos, y es mejor que ahorres memoria y tiempo de
interpretación si no los vas a usar. En los siguientes ejemplos solo vamos a usar COLORS.INC, FINISH.INC
y STONES.INC, así que mejor que quites el resto de las líneas de tu archivo de escena.

Puedes tener tantos archivos de inclusión como sea necesario. Los archivos de inclusión pueden incluso
contener a otros archivos, pero esto está limitado a diez niveles de profundidad.

Los nombres de archivos en las sentencias de inclusión se buscan primero en el directorio actual. Si no
se encuentran, se buscan en los directorios especificados por el parámetro +L o por la opción
Library_Path. Esto facilita el tener todos los archivos de inclusión en un directorio aparte, y especificar
con el parámetro +L donde se encuentran.

4.1.3. Añadiendo la cámara.

La declaración de la cámara describe donde y como la cámara ve la escena. Hay que especificar las
coordenadas x, y, x que sitúan a la cámara y a que parte de la escena está apuntando. Para describir las
coordenadas x, y, z usamos un vector de tres componentes. Un vector se especifica poniendo tres
valores numéricos entre paréntesis angulares y separando los valores por comas.

Añade la siguiente sentencia a la escena.

camera {
location <0, 2, -3>
look_at <0, 1, 2>
}
Brevemente, location <0, 2, -3> sitúa la cámara dos unidades hacia arriba y tres unidades hacia
atrás a partir del centro del universo del trazador, que está situado en <0, 0, 0>. Recuerda que por
defecto +Z va hacia dentro del monitor, y -Z sale hacia fuera.

También look_at <0, 1, 2> rota la cámara hasta apuntar a las coordenadas <0, 1, 2>. Es decir, un
punto a 5 unidades enfrente de la cámara y 1 unidad más abajo que la cámara. El punto look_at es el
centro de atención de tu imagen.

4.1.4. Describiendo un objeto.

Ahora que la cámara está lista para registrar la escena, vamos a poner una esfera amarilla. Añade lo
siguiente a tu archivo de escena:
sphere {
<0, 1, 2>, 2
texture {
pigment { color Yellow }
}
}
El primer vector especifica el centro de la esfera. En este ejemplo la coordenada x es cero, de modo que
estará centrada a izquierda y derecha. También tenemos y=1, o una unidad por encima del origen. La
coordenada z es 2, que está a 5 unidades de la cámara, que está en z=3. Después del vector hay una
coma seguida por el radio que en este caso es de 2 unidades. Como el radio es la mitad de la anchura de
la esfera, ésta tendrá un ancho de 4 unidades.
4. TUTORIAL PARA PRINCIPIANTES 32

4.1.5. Añadiendo la textura al objeto.

Después de definir la posición y tamaño de la esfera, necesitamos describir la apariencia de su
superficie. El bloque texture {...} especifica el color, la rugosidad y las propiedades del acabado
de un objeto. En este ejemplo sólo vamos a especificar el color. Esto es lo mínimo que debemos hacer.
El resto de las opciones de la textura usarán los valores por defecto.

El color que tu defines es el que tendrá el objeto cuando esté totalmente iluminado. Si estuvieras
haciendo un dibujo de una esfera usarías tonos oscuros para indicar las zonas sombreadas, y tonos
brillantes para indicar las zonas iluminadas. Sin embargo, el trazador se ocupa ya de eso. Tú eliges el
color inherente al objeto y POV-Ray lo aclara u oscurece dependiendo de la iluminación de la escena.
Como estamos definiendo el color que el objeto tiene en lugar del color aparente, el parámetro usado se
llama pigment.

Hay muchos tipos de distribuciones de color que se pueden usar en la sentencia pigment {...}. La
palabra clave color indica que todo el objeto es de un único color, en lugar de tener una distribución de
colores. Puedes usar uno de los colores definidos previamente en el archivo de inclusión colors.inc.

Si no hay un color estándar disponible para tus necesidades, puedes definir tu propio color usando la
palabra clave color seguida de red, green y blue, que especifican las cantidades de rojo, verde y
azul de que se compone el color. Por ejemplo, un bonito tono rosa se puede indicar como:
color red 1.0 green 0.8 blue 0.8
Los valores después de cada palabra han de estar comprendidos entre 0.0 y 1.0. Cualquiera de los tres
componentes no especificadas se toman como 0 por defecto. También se puede usar una notación más
corta. Lo siguiente también produce el mismo tono rosa:
color rgb <1.0, 0.8, 0.8>
Los colores se explican con más detalle en la sección "Especificando Colores".

4.1.6. Definiendo una fuente de luz.

Un último detalle falta en nuestra escena. Necesitamos una fuente de luz, hasta que crees una no habrá
luz en este mundo virtual. De modo que añade esta línea
light_source {<2, 4, -3> color White}
a tu archivo de escena. Tu primera escena con POV-Ray debería quedar así:
#include "colors.inc"

background { color Cyan }

camera {
location <0, 2, -3>
look_at <0, 1, 2>
}

sphere {
<0, 1, 2>, 2
texture {
pigment { color Yellow }
}
}

light_source { <2, 4, -3> color White}

PERSISTENCE OF VISION RAYTRACER 33

El vector en la sentencia light_source especifica la posición de la luz como 2 unidades a nuestra

derecha, 4 unidades sobre el origen y 3 unidades por detrás del origen. La fuente de luz es invisible, sólo
emite luz, de modo que no se necesita textura.

Esto es todo. Graba el archivo y traza una pequeña imagen con la orden
povray +w160 +h120 +p +x +d0 -v -idemo.pov
Si tu ordenador no usa la línea de comandos, consulta la documentación específica de tu plataforma
para ver como trazar la escena.

También puedes especificar otras opciones en la línea de comandos, si quieres. La escena será escrita al
archivo DEMO.TGA (o con otro sufijo si tu ordenador usa un formato por defecto diferente).

La escena que acabas de trazar no es ninguna obra de arte, pero tenemos que empezar por lo básico
antes de que exploremos características y escenas mucho más fascinantes.

4.2. Usando la cámara

4.2.1. Usando el desenfoque

Vamos a construir una escena simple para ilustrar el uso del desenfoque. Para este ejemplo usaremos
una esfera rosa, una caja verde y un cilindro azul. La esfera estará en primer plano, la caja en el centro y
el cilindro al fondo. Para completar la escena pondremos un suelo ajedrezado y un par de fuentes de
luz.

Creamos un nuevo archivo llamado FOCALDEM.POV y tecleamos lo siguiente:

#include "colors.inc"
#include "shapes.inc"
#include "textures.inc"

#version 3.0

global_settings {
assumed_gamma 2.2 // para la mayoría de los monitores de PC
max_trace_level 5
}

sphere { <1, 0, -6>, 0.5

finish {
ambient 0.1
diffuse 0.6
}
pigment { NeonPink }
}

box { <-1, -1, -1>, < 1, 1, 1>

rotate <0, -20, 0>
finish {
ambient 0.1
diffuse 0.6
}
pigment { Green }
}

cylinder { <-6, 6, 30>, <-6, -1, 30>, 3

finish {
ambient 0.1
diffuse 0.6
}
4. TUTORIAL PARA PRINCIPIANTES 34

pigment {NeonBlue}
}

plane { y, -1.0
pigment {
checker color Gray65 color Gray30
}
}

light_source { <5, 30, -30> color White }

light_source { <-5, 30, -30> color White }

Ahora vamos a poner la cámara en una posición apropiada, justo detrás de los tres objetos. Ajustando el
punto focal moveremos el foco a cualquier punto de la escena. Añade las siguientes líneas:
camera {
location <0.0, 1.0, -10.0>
look_at <0.0, 1.0, 0.0>

// focal_point <-6, 1, 30> // el cilindro está enfocado

// focal_point < 0, 1, 0> // la caja esta enfocada
focal_point < 1, 1, -6> // la esfera está enfocada

aperture 0.4 // una solución de compromiso

// aperture 0.05 // casi todo está enfocado
// aperture 1.5 // muy desenfocado

// blur_samples 4 // poco muestreo, trazado más rápido

blur_samples 20 // más muestras, mayor calidad de la imagen
}
El punto focal es el punto de la escena que estará totalmente enfocado, con los bordes bien definidos.
Definimos el punto focal y asignamos un valor a la apertura para ajustar la distancia a la que comenzará
a desenfocarse la imagen.

El ajuste de la apertura puede considerarse como el área enfocada. Aumentar la apertura tiene como
efecto el hacer más pequeña el área donde todo está enfocado, mientras de disminuirla hace que el área
enfocada sea mayor. Así es como controlamos donde comienza a desenfocarse la imagen alrededor del
punto focal.

El valor de blur_samples determina cuantos rayos se trazan para muestrear cada pixel. Básicamente,
cuantos más rayos se usen mayor será la calidad de la imagen, y consecuentemente mayor tiempo
tardará en trazarse. Cada escena es diferente, así que tendremos que experimentar. En este tutorial
tenemos ejemplos de 4 y 20 muestras, pero podemos usar más para imágenes de alta resolución. No
deberíamos usar más muestras que las necesarias para obtener la calidad deseada, porque más muestras
suponen más tiempo para el trazado. Los ajustes de confidencia y varianza están cubiertos en la sección
"Desenfoque".

Experimenta con el punto focal, la apertura y el valor del muestreo. La escena tiene líneas con varios
valores, y puedes probarlos comentando las líneas por defecto, y quitando el comentario a la línea que
quieras probar. Haz un cambio de cada vez para que puedas ver el efecto sobre la escena.

Dos cosas sobre el trazado de escenas con desenfoque. No necesitamos especificar antialias (el
parámetro +a) porque el desenfoque en sí ya es un método de sobremuestreo. El desenfoque sólo
puede usarse con la cámara de perspectiva (perspective camera).
PERSISTENCE OF VISION RAYTRACER 35

4.3. Formas simples

Hasta ahora, sólo hemos usado la forma de la esfera. Hay muchas otras formas que podemos usar con
POV-Ray. Las secciones siguientes describirán cómo usar algunas de las más sencillas en lugar de la
esfera usada anteriormente.

4.3.1. Caja
La caja es uno de los objetos más utilizados. Sustituyamos la esfera por el texto del siguiente ejemplo:
box {
<-1, 0, -1>, // Esquina delantera inferior izquierda
< 1, 0.5, 3> // Esquina trasera superior derecha

texture {
T_Stone25 // Predefinida en stones.inc
scale 4 // Escalamos en todas las direcciones el mismo factor
}

rotate y*20 // Equivalente a "rotate <0,20,0>"

}
En el ejemplo, podemos observar que una caja se define especificando las coordenadas tridimensionales
de sus esquinas opuestas. El primer vector debe contener los valores mínimos de x, y y z, y el segundo
debe contener los valores máximos. Los objetos con forma de caja sólo pueden ser definidos con sus
aristas paralelas a los ejes del eje de coordenadas. Si lo deseamos, podemos rotarlos para situarlos de
otra manera. Observa que podemos construir expresiones matemáticas de diverso tipo con números y
vectores. El parámetro de la rotación está expresado por el vector y multiplicado por 20. Es lo mismo
que <0, 1, 0>*20, es decir, <0, 20, 0>.

4.3.2. Cono
Aquí tenemos otro ejemplo mostrando cómo usar un cono.
cone {
<0, 1, 0>, 0.3 // Centro y radio de una base
<1, 2, 3>, 1.0 // Centro y radio de la otra base

texture { T_Stone25 scale 4 }

}
La forma del cono se define mediante el centro y el radio de cada base. En el ejemplo, una de las bases
está centrada en el <0, 1, 0> y tiene radio 0.3, mientras que la otra está centrada en el punto <1, 2, 3> y
tiene radio 1. Si queremos que el cono acabe en punta, indicaremos para esa base un radio 0. Ambas
bases son paralelas y perpendiculares al eje del cono. Si queremos que el cono sea dibujado abierto,
añadiremos la palabra open después del segundo radio, como en el siguiente ejemplo:
cone {
<0, 1, 0>, 0.3 // Centro y radio de una base
<1, 2, 3>, 1.0 // Centro y radio de la otra base
open // Quita las bases

texture { T_Stone25 scale 4 }

}

4.3.3. Cilindro
Podemos definir también un cilindro como sigue:
cylinder {
<0, 1, 0>, // Centro de una base
4. TUTORIAL PARA PRINCIPIANTES 36

<1, 2, 3>, // Centro de la otra base

0.5 // Radio
open // No dibuja las bases

texture { T_Stone25 scale 4 }

}

4.3.4. Plano
Probemos a crear un objeto típico de los gráficos por ordenador: el suelo ajedrezado. Añadimos el
objeto siguiente a la primera versión del archivo DEMO.POV, el que incluye la esfera.
plane { <0, 1, 0>, -1
pigment {
checker color Red, color Blue
}
}
El objeto definido aquí es un plano infinito. El vector <0, 1, 0> marca la dirección normal a la
superficie del plano (si estuviésemos de pie sobre la superficie, la dirección apuntaría desde nuestros
pies hacia nuestra cabeza). El número situado tras el vector marca la distancia a la que el plano está
situado del origen de coordenadas medido sobre la dirección normal. En este caso, el suelo está situado
en y=-1, una unidad por debajo del centro. Como la esfera tiene radio 2 y está centrada a una unidad de
altura, reposa sobre el suelo.

Observemos que, aunque no hay una declaración de textura, hay una textura implícitamente declarada
aquí. Teclear continuamente instrucciones anidadas del tipo de texture{pigment{....}} es muy
agotador, de forma que POV-Ray nos permite omitir la instrucción textura en muchas ocasiones. De
hecho, sólo deberemos usarla cuando englobemos una textura predefinida (como T_Stone25 del
ejemplo anterior), o cuando apilemos varias texturas (como veremos más adelante).

Este pigmento usa el patrón de color ajedrezado y especifica que los colores usados serán el rojo y el
azul.

Como los vectores <1, 0, 0>, <0, 1, 0> y <0, 0, 1> se usan frecuentemente, POV-Ray tiene tres
identificadores reservados (x, y, z) que se pueden usar como abreviatura. Así, un plano puede definirse
como
plane { y, -1
pigment { ... }
}
Observa que no usamos los símbolos < y > alrededor de los identificadores de vectores.

Mirando al suelo, descubrimos que la esfera produce una sombra en él. El trazador de rayos calcula las
sombras de forma muy precisa y esto crea sombras con bordes muy definidos. En el mundo real
habitualmente se aprecia una zona de penumbra o sombra "suave". Más adelante aprenderemos cómo
usar luces avanzadas para suavizar el borde de las sombras.

4.3.5. Inclusión de objetos estándar

El archivo de inclusión shapes.inc contiene algunas formas predefinidas que tienen un tamaño
similar a una esfera de radio uno. Podemos invocarlas desde uno de nuestros diseños así:
#include "shapes.inc"

object {
UnitBox
texture { T_Stone25 scale 4 }
PERSISTENCE OF VISION RAYTRACER 37

scale 0.75
rotate <-20,25,0>
translate y
}

4.4. Formas avanzadas

Después de haber conseguido cierta experiencia con las formas simples de POV-Ray, es el momento de
hablar de las formas más avanzadas (e interesantes).

Debemos tener en cuenta que las formas definidas en adelante no son sencillas de entender. No
debemos preocuparnos por no saber usarlas, o no conocer su aspecto. Sólo probaremos unos ejemplos
que juegan con las características descrita más ampliamente en el capítulo de referencias. No hay nada
mejor para aprender que practicar.

4.4.1. Parche bicúbico

4.4.2. Burbuja
Las burbujas se pueden describir como esferas y cilindros que tienden a fusionarse unos con otros
cuando están próximos. Ideales para modelar átomos y moléculas, estos objetos son también
herramientas poderosas que nos permiten crear variadas formas orgánicas.

Una manera más matemática de describir una burbuja es decir que es un objeto hecho de dos o más
componentes, de forma que cada componente se comporta como un campo de fuerza invisible que
comienza con una intensidad determinada y decae a cero a cierto radio. Donde esos campos se solapan,
sus intensidades se suman (algunos de esos componentes pueden tener intensidad negativa, también).
Lo que nosotros vemos de este objeto es la superficie en la que esa intensidad es igual a un determinado
valor. Por supuesto, podemos tener un solo componente en una burbuja, pero su aspecto es idéntico a
una esfera (o a un cilindro, si ésa es la forma del campo). La verdadera belleza de este objeto es la forma
en la que unos componentes interactúan con los otros.

Tomemos un ejemplo simple de burbuja para empezar. Para simplificar este primer ejemplo, sólo
usaremos componentes esféricos. Escribamos el siguiente código, compuesto de una cámara sencilla,
luz, y una burbuja con sólo dos componentes. Esta escena se llama BLOBDEM1.POV:
#include "colors.inc"

camera {
angle 15
location <0,2,-10>
look_at <0,0,0>
}

light_source { <10, 20, -10> color White }

blob {
threshold .65
sphere { <.5,0,0>, .8, 1 pigment {Blue} }
sphere { <-.5,0,0>,.8, 1 pigment {Pink} }

finish { phong 1 }
}
4. TUTORIAL PARA PRINCIPIANTES 38

Figura 3: Una sencilla burbuja con dos componentes

El umbral (threshold) es simplemente la intensidad en la que nuestro objeto se vuelve visible.

Cualquier punto visible de la superficie del objeto reúne exactamente esa cantidad de intensidad, a partir
de la suma o la diferencia de las diferentes componentes. Aquellos en los que la intensidad es menor
están fuera del objeto, y los que tienen una intensidad mayor se encuentran en el interior.

Observemos que el componente esférico parece una esfera. De hecho, indicamos su centro y su radio.
Pero ¿qué es el último valor numérico? Es la intensidad de ese componente, el valor que alcanza en su
centro. Decae siguiendo una progresión lineal hasta alcanzar el valor cero exactamente a una distancia
igual al radio de la esfera.

Antes de trazar esta imagen, observemos que le hemos dado a cada componente una pigmentación
distinta. POV-Ray permite que los componentes tengan distintas texturas. Hemos hecho esto para dejar
claro cuál es cada componente en la imagen. También podemos aplicar texturas al final, lo que afectará
a todos los componentes, como el acabado indicado en el ejemplo, fuera de ambas esferas. Cuando
tracemos la imagen, encontraremos una burbuja típica formada por dos esferas unidas.

La imagen que vemos muestra una esfera en cada lado, pero están suavemente unidas por una sección
puente en el centro. Este puente representa dónde los campos se solapan, por lo que su intensidad
aumenta con respecto a lo que valdría si sólo hubiese un componente. Por si esto no está totalmente
claro, añadiremos dos objetos más y la trazaremos de nuevo (archivo BLOBDEM2.POV). Observa que las
dos nuevas esferas se introducen como un objeto a parte, no como componentes de la burbuja.
sphere { <.5,0,0>, .8
pigment { Yellow transmit .75 }
}

sphere { <-.5,0,0>, .8
pigment { Green transmit .75 }
}
PERSISTENCE OF VISION RAYTRACER 39

Figura 4: Las componentes esféricas se hacen visibles

Ahora el secreto de las dos esferas unidas se pone de manifiesto. Estas esferas semitransparentes
muestran dónde están realmente las componentes de la burbuja. Si no hemos trabajado nunca con este
tipo de objetos quizá nos sorprenda que las esferas se extiendan mucho más allá de donde vemos
nosotros realmente los componentes. Esto es debido a que lo que muestran las superficies de las esferas
es dónde la fuerza de los campos llega a cero, mientras que la burbuja marca dónde esta intensidad es
igual a 0.65. El resto de la esfera es exterior a la burbuja y, por tanto, no es visible.

¿Ves dónde se solapan ambas esferas? Observa que se corresponde precisamente con el "puente" entre
las dos esferas. Esta es la región donde la intensidad de ambos componentes está contribuyendo a la
intensidad total, por lo que el puente aparece así: una región en la que la intensidad supera el valor de
umbral (0.65), debido a que se combina la de las dos esferas.

4.4.2.1. Tipos de componentes y otras características nuevas.

La forma mostrada hasta ahora es interesante, pero limitada. POV-Ray tiene unos cuantos trucos más
que extiende su utilidad. Por ejemplo, como hemos visto, podemos asignar valores de textura
individualmente a cada componente, podemos aplicar transformaciones individuales (traslación,
rotación y escalado) para modificar cada parte como deseemos. Y, lo que quizá es más interesante, el
código de las burbujas se ha extendido a componentes cilíndricas.

Antes de empezar con los cilindros, deberíamos mencionar que la forma clásica de enunciar las
componentes de anteriores versiones de POV-Ray aún sirve. Entonces, todas las componentes eran
esféricas, de forma que no era necesario citar su forma. La forma clásica tiene el siguiente aspecto:
component intensidad, radio,
Esto tiene el mismo efecto que un componente esférico, como los que hemos mostrado antes. Esto
sólo se mantiene por compatibilidad. Si tenemos archivos de POV-Ray de anteriores versiones, lo
necesitaremos para que reconozca las componentes. Observa que el estilo clásico no pone llaves
encerrando la intensidad, el radio y el centro, y, por supuesto, no podemos aplicarles individualmente
texturas o transformaciones. De manera que si estás modificando un trabajo antiguo, tal vez sea
interesante cambiar la sintaxis a la actual para conseguir algunas ventajas.
4. TUTORIAL PARA PRINCIPIANTES 40

Ahora intentemos crear algo con las componentes cilíndricas. Se podría argumentar que podríamos
hacer un cilindro con una burbuja, usando algunas componentes esféricas alineadas. Esto es cierto, pero
sería delicado calcular el valor de los centros, y deberíamos teclear mucho más.

Sustituye la burbuja del último ejemplo con lo siguiente y trázalo. Podemos borrar las esferas
transparentes también.
blob {
threshold .65

cylinder { <-.75,-.75,0>, <.75,.75,0>, .5, 1 }

pigment { Blue }
finish { phong 1 }
}
Tenemos sólo un componente cilíndrico para que veamos el aspecto que tiene aislado. No es realmente
un cilindro, pues acaba en dos semiesferas. Podemos pensar en él como una esfera alargada en cierta
dirección.

En cuanto a la sintaxis, es lo que podíamos esperar: el cilindro está descrito como los cilindros
anteriormente vistos: dos vectores que indican los centros de sus bases y un valor que indica el radio. El
otro número, por supuesto, indica la intensidad del campo en el centro del cilindro. Este valor indica
cómo interactúa con otras componentes, si tiene alguna con la que interactuar.

4.4.2.2. Construcciones complejas con burbujas e intensidad negativa.

Iniciemos un archivo POV nuevo, llamado BLOBDEM3.POV, escribiendo este ejemplo algo más
complejo:
#include "colors.inc"

camera {
angle 20
location<0,2,-10>
look_at<0,0,0>
}

light_source { <10, 20, -10> color White }

blob {
threshold .65

sphere { <-.23,-.32,0>,.43, 1 scale <1.95,1.05,.8> } //palma

sphere { <+.12,-.41,0>,.43, 1 scale <1.95,1.075,.8> } //palma
sphere { <-.23,-.63,0>, .45, .75 scale <1.78, 1.3,1> } //centro de la mano
sphere { <+.19,-.63,0>, .45, .75 scale <1.78, 1.3,1> } //centro de la mano
sphere { <-.22,-.73,0>, .45, .85 scale <1.4, 1.25,1> } //extremo
sphere { <+.19,-.73,0>, .45, .85 scale <1.4, 1.25,1> } //extremo

cylinder { <-.65,-.28,0>, <-.65,.28,-.05>, .26, 1 } //meñique (bajo)

cylinder { <-.65,.28,-.05>, <-.65, .68,-.2>, .26, 1 } //meñique (alto)

cylinder { <-.3,-.28,0>, <-.3,.44,-.05>, .26, 1 } //anular (bajo)

cylinder { <-.3,.44,-.05>, <-.3, .9,-.2>, .26, 1 } //anular (alto)

cylinder { <.05,-.28,0>, <.05, .49,-.05>, .26, 1 } //medio (bajo)

cylinder { <.05,.49,-.05>, <.05, .95,-.2>, .26, 1 } //medio (alto)

cylinder { <.4,-.4,0>, <.4, .512, -.05>, .26, 1 } //índice (medio)

cylinder { <.4,.512,-.05>, <.4, .85, -.2>, .26, 1 } //índice (alto)

cylinder { <.41, -.95,0>, <.85, -.68, -.05>, .25, 1 } //pulgar (bajo)

PERSISTENCE OF VISION RAYTRACER 41

cylinder { <.85,-.68,-.05>, <1.2, -.4, -.2>, .25, 1 } //pulgar (alto)

pigment { Flesh }
}

Figura 5: Una mano hecha con burbujas

Como podemos ver por los comentarios, estamos construyendo una mano. Cuando tracemos esta
imagen, veremos que hay ciertos problemas con esta. La palma y la parte baja se pueden hacer más
realistas si usamos una docena de componentes pequeñas en lugar de media docena de componentes
grandes, y cada dedo debería tener tres segmentos en lugar de dos, pero como ejemplo nos sirve. Sin
embargo, hay una cosa que realmente debemos añadir: los dedos aparecen unidos por una especie de
membrana.

Una revisión de lo que sabemos de las burbujas nos revela rápidamente qué sucede. Esta membrana
está formada por lugares donde las componentes se solapan, por lo que la intensidad de las
componentes se suma y la superficie se extiende hacia ellos. Lo que necesitamos es añadir aquí algunas
componentes más que tengan intensidad negativa y contrarresten parte de la intensidad combinada.
Añadiremos las siguientes componentes a nuestro objeto (ver archivo BLOBDEM4.POV):
sphere { <-.65,.28,-.05>, .26, -1 } //anula el bulto del nudillo del meñique
sphere { <-.65,-.28,0>, .26, -1 } //anula el bulto de la palma junto al
meñique

sphere { <-.3,.44,-.05>, .26, -1 } //anula el bulto del nudillo del anular

sphere { <-.3,-.28,0>, .26, -1 } //anula el bulto de la palma junto al
anular

sphere { <.05,.49,-.05>, .26, -1 } //anula el bulto del nudillo del medio

sphere { <.05,-.28,0>, .26, -1 } //anula el bulto de la palma junto al medio

sphere { <.4,.512,-.05>, .26, -1 } //anula el bulto del nudillo del índice

sphere { <.4,-.4,0>, .26, -1 } //anula el bulto de la palma junto al
índice

sphere { <.85,-.68,-.05>, .25, -1 } //anula el bulto del nudillo del pulgar

sphere { <.41,-.7,0>, .25, -.89 } //anula el bulto de la palma junto al
pulgar
4. TUTORIAL PARA PRINCIPIANTES 42

Figura 6: La mano sin membrana

¡Mucho mejor! La intensidad negativa de la componente esférica actúa aproximadamente en el punto

medio entre los dedos, de forma que la horrible membrana ya no aparece, haciendo nuestra mano
mucho más creíble. Aunque la podemos hacer aún más realista añadiendo algunas docenas de
componentes adicionales, lo que hemos conseguido ya es bastante aceptable. Por ahora, ya tenemos
algún ejemplo de la utilización de las burbujas para crear superficies orgánicas complejas.

4.4.3. Campo de alturas

Un campo de alturas es un objeto cuya superficie está determinada por el valor de color o de paleta de
cada píxel de una imagen diseñada para este propósito. Con estos objetos podemos simular montañas
realistas y hacer fácilmente otros tipos de terreno. En primer lugar, necesitamos una imagen a partir de
la cual crearemos el campo de alturas. POV-Ray es ideal para crear tal imagen.

Abrimos un nuevo archivo llamado IMAGE.POV y escribimos lo siguiente:

#include "colors.inc"

global_settings {
assumed_gamma 2.2
hf_gray_16
}
La palabra clave hf_gray_16 hace que la salida sea codificada de un modo especial (16 bits en escala
de grises) que es ideal para generar campos de alturas. Las superficies construidas con 8 bits son mucho
menos suaves, ya que se trabaja con menos alturas diferentes (256 frente a 65536 de los 16 bits).

Ahora situamos una cámara que apunta desde la parte negativa del eje z al origen.
camera {
location <0, 0, -10>
look_at 0
}
Después, situamos un plano como un muro en z=0, que llenará totalmente la pantalla. Lo coloreamos
con manchas con forma de arrugas grises sobre fondo blanco.
plane { z, 10
pigment {
wrinkles
PERSISTENCE OF VISION RAYTRACER 43

color_map {
[0 0.3*White]
[1 White]
}
}
}
Finalmente, añadiremos una luz.
light_source { <0, 20, -100> color White }
Trazamos esta escena con las opciones +h480 +w640 +a0.1 +fT. Obtendremos una imagen que
producirá un excelente campo de alturas. Creamos ahora un archivo llamado HFDEMO.POV y escribimos
en él lo siguiente:
#include "colors.inc"
Añadimos una cámara dos unidades sobre el origen y diez unidades por detrás...
camera{
location <0, 2, -10>
look_at 0
angle 30
}
... y una luz.
light_source{ <1000,1000,-1000> White }
Ahora añadimos el campo de alturas. En la sintaxis siguiente se especifica que usamos un archivo Targa,
que se suaviza el cambio entre alturas, se colorea de blanco, y se traslada para centrarlo en el origen y
escalarlo de forma que simule montañas y llene la pantalla.
height_field {
tga "image.tga"
smooth
pigment { White }
translate <-.5, -.5, -.5>
scale <17, 1.75, 17>
}
Guardamos el archivo y trazamos a 320 por 240, sin antialias (-a). Después, si estamos satisfechos con
el resultado, probaremos a crear una imagen de mayor resolución y con antialias.

Figura 7: Un campo de alturas creado íntegramente con POV-

Ray
4. TUTORIAL PARA PRINCIPIANTES 44

¡Uao! ¡El Himalaya en nuestro ordenador!

4.4.4. Objeto torneado (lathe)

Estos objetos simulan lo que podemos hacer con un torno puede hacer al cortar bordeando un patrón
determinado sobre una pieza de algún material. El resultado es un artefacto elegantemente redondeado
que puede ser usado en una gran diversidad de situaciones (mesas, piezas de cerámica, etc.).

Aquí incluimos algo de código para crear una pieza torneada muy sencilla (llamada LATHDEM1.POV).
#include "colors.inc"

camera {
angle 10
location <1, 9, -50>
look_at <0, 2, 0>
}

light_source {
<20, 20, -20> color White
}

lathe {
linear_spline
6,
<0,0>, <1,1>, <3,2>, <2,3>, <2,4>, <0,4>
pigment { Blue }
finish {
ambient .3
phong .75
}
}

Figura 8: Un sencillo objeto torneado (lathe)

Trazamos esto, y lo que veremos es un objeto muy sencillo, similar a una peonza. Veamos cómo este
código produce dicho efecto.

Primero, se declaran seis puntos que el programa conecta con líneas. Observa que sólo indicamos dos
componentes en los vectores que describen esos puntos. Se asume que las líneas están trazadas sobre el
plano x-y, como si la tercera componente fuese siempre cero. Es obligatorio usar vectores de dos
PERSISTENCE OF VISION RAYTRACER 45

componentes (usar vectores de tres componentes ocasionará un error, excepto en un caso que
exploraremos posteriormente, relacionado con la discusión de las curvas spline).

Una vez que las líneas están determinadas, podemos imaginar que el trazador de rayos gira esta línea
alrededor del eje y, dejando la forma del objeto al paso de la línea (realmente, es como si cortara sobre
un cilindro de material azul usando esta línea de patrón, y descartara todo lo que queda en el exterior de
ésta).

Los puntos especificados están unidos por trazos rectos porque usamos la clave linear_spline. Hay
otros tipos de curvas permitidas para este fin, que producen curvas más suaves, redondeando las
transiciones entre un trazo y otro, pero volveremos a hablar de ello dentro de un momento.

Primero, estudiemos la diferencia entre un objeto torneado y una superficie de revolución (sor). La
superficie de revolución, descrito en un tutorial aparte, es terriblemente similar a primera vista. También
declara una serie de puntos, los une mediante líneas y después rota el resultado alrededor del eje y. El
objeto torneado tiene ciertas ventajas, como diferentes tipo de trazos de unión (lineales, cuadráticos y
cúbicos) y algo más.

Las sencillas matemáticas usadas en un SOR no permiten que la curva se doble y tome por dos veces el
mismo valor de y, es decir, que todo intento de que un objeto SOR se curve hasta volver a tomar la
misma altura produce un error. Por ejemplo, supongamos que queremos tornear una curva que sube de
<0, 0> hasta <2, 2>, y después baja hasta <4, 0>. Girado en torno al eje y, esto produciría algo similar
a un molde para gelatina (un semitoro), hundido en el centro. Sin embargo, en un SOR, el intento dará
un mensaje de error debido a intentar curvarse en la dirección equivocada.

Sin embargo, los objetos SOR utilizan matemática de inferior orden, por lo que su cálculo es más rápido
que el equivalente objeto torneado. De manera que es preferible usar un objeto SOR si sus limitaciones
no nos afectan, pero si necesitamos tornear de una forma más flexible, sólo podemos utilizar un objeto
torneado.

4.4.4.1. Entendiendo el concepto de splines

Sería útil, a fin de comprender las splines, si tuviéramos un ejemplo donde pudiéramos practicar
manipulando puntos y tipos de splines y ver cuales son los efectos. Así que, ¡hagamos uno! Ahora que
sabemos como crear un torno básico, será fácil (ver archivo LATHDEM2.POV):
#include "colors.inc"

camera {
orthographic
up <0, 5, 0>
right <5, 0, 0>
location <2.5, 2.5, -100>
look_at <2.5, 2.5, 0>
}

/* Definir los puntos de control que serán usados */

#declare Red_Point = <1.00, 0.00, 0>

#declare Orange_Point = <1.75, 1.00, 0>
#declare Yellow_Point = <2.50, 2.00, 0>
#declare Green_Point = <2.00, 3.00, 0>
#declare Blue_Point = < 1.50, 4.00, 0>

/* Hacer visibles los puntos de control */

cylinder { Red_Point, Red_Point - 20*z, .1

pigment { Red }
4. TUTORIAL PARA PRINCIPIANTES 46

finish { ambient 1 }
}

cylinder { Orange_Point, Orange_Point - 20*z, .1

pigment { Orange }
finish { ambient 1 }
}

cylinder { Yellow_Point, Yellow_Point - 20*z, .1

pigment { Yellow }
finish { ambient 1 }
}

cylinder { Green_Point, Green_Point - 20*z, .1

pigment { Green }
finish { ambient 1 }
}

cylinder { Blue_Point, Blue_Point- 20*z, .1

pigment { Blue }
finish { ambient 1 }
}

/* Algo para hacer aparecer la curva */

lathe {
linear_spline
5,
Red_Point,
Orange_Point,
Yellow_Point,
Green_Point,
Blue_Point

pigment { White }
finish { ambient 1 }
}

Figura 9: Un simple ejemplo de spline

Ahora, retomamos el aliento. Vemos que tiene una apariencia un poco rara, pero con algunas simples
explicaciones, podemos ver fácilmente qué es lo que hace todo esto.

En primer lugar decir que estamos usando la cámara ortográfica. Si aún no hemos leído nada sobre ella,
aquí hay un breve resumen: traza la escena plana, eliminando la distorsión de la perspectiva para que en
PERSISTENCE OF VISION RAYTRACER 47

una vista lateral, los objetos tengan la misma apariencia que si hubieran sido dibujado en un plano de
papel (como en la vista lateral de un modelador o programa de CAD). Hay varios usos para este
práctico nuevo tipo de cámara, pero aquí nos permitirá ver nuestro torno y cilindros como si fueran una
sección transversal de la curva que forma el torno, más que el torno en sí mismo. Para reforzar el efecto
hemos eliminado el sombreado con el acabado ambient 1 que, en efecto también elimina la necesidad
de una fuente de luz. También hemos posicionado esta particular vista lateral para que el punto <0, 0>
aparezca en la esquina inferior izquierda de nuestra escena.

A continuación hemos declarado un conjunto de puntos. Nótese que hemos usado vectores de tres
componentes para estos puntos, en lugar de los vectores de dos que solemos usar en un torno. Esta es
una excepción que ya mencionamos antes. Cuando declaramos un punto 3D y lo usamos en un torno,
este solo usa las dos primeras componentes del vector y la tercera componente es ignorada. Esto es
práctico aquí, ya que hace posible este ejemplo.

Ahora hacemos dos cosas con los puntos declarados. Primeros los usamos para colocar cilindros de
pequeño diámetro con las bases apuntando a la cámara. Entonces volvemos a usar esos mismos
vectores para determinar el torno. Ya que intentar declarar vectores en 2D puede ocasionar resultados
no esperados y no es lo que necesitan nuestras declaraciones de cilindros, podemos aprovechar la
tendencia del torno a ignorar la tercera componente poniendo la coordenada z a 0 en los vectores en
3D.

El resultado final es: cuando trazamos este código, vemos un torno de color blanco contra un fondo
negro mostrándonos la forma de la curva que hemos declarado y las bases circulares de los cilindros nos
muestran nuestros puntos de control sobre el plano xy. En este caso, es muy simple. La spline lineal ha
sido usada de forma que nuestra curva está compuesta por una serie de líneas conectando los puntos.
Ahora cambiamos las declaraciones de Red_Point y Blue_Point de la siguiente forma (ver fichero
LATHDEM3.POV).

#declare Red_Point = <2.00, 0.00 , 0>

#declare Blue_Point = <0.00, 4.00, 0>

Figura 10: Moviendo algunos puntos de la spline

Trazamos de nuevo y lo que podemos ver es que los segmentos rectos se han movido para acomodarse
a las nuevas posiciones de los puntos rojo y azul.

Vamos a intentar algo distinto. Primero cambiamos los puntos por estos otros (ver fichero
LATHDEM4.POV).
4. TUTORIAL PARA PRINCIPIANTES 48

#declare Red_Point = <1.00, 0.00, 0>

#declare Orange_Point = <2.00, 1.00, 0>
#declare Yellow_Point = <3.50, 2.00, 0>
#declare Green_Point = <2.00, 3.00, 0>
#declare Blue_Point = <1.50, 4.00, 0>

Figura 11: La spline cuadrática.

Ahora vamos a la declaración del torno y cambiamos linear_spline por quadratic_spline.

Trazamos de nuevo y ¿qué tenemos? Bien, esta vez hay varias cosas que comentar. Primero, vemos que,
en lugar de líneas rectas, tenemos redondeados arcos conectando los puntos. Estos arcos están
formados a partir de curvas cuadráticas, de manera que ahora nuestro torno parece mucho más
interesante. También vemos que el punto rojo no está conectado a la curva. ¿Qué ha pasado?

Bien, mientras que cualquier pareja de puntos puede determinar una línea recta, se necesitan tres para
determinar una curva cuadrática. POV-Ray no solo tiene en cuenta los dos puntos a ser conectados, si
no también el punto que los precede para determinar la fórmula de la curva cuadrática que será usada
para conectarlos. El problema está al principio de la curva. Más allá de su primer punto no hay punto
previo. Así que necesitamos declarar uno. Por lo tanto, cuando se usa una spline cuadrática, debemos
recordar que el primer punto que especificamos solo está allí para que POV-Ray pueda determinar la
curva para conectar los dos primeros puntos. No se mostrará como parte de la curva.

Solo hay una cosa más acerca de este ejemplo. A pesar de que nuestra curva está formada ahora por
líneas redondeadas, las transiciones entre estas líneas son... bueno, un poco picadas. Parece que las
líneas hubieran sido conectadas en los puntos de forma equivocada. Dependiendo de lo que intentemos
hacer, esto puede ser aceptable, o podemos desear una forma más redondeada. Afortunadamente
tenemos otra opción.

La spline cuadrática necesita más tiempo de trazado que la lineal. La fórmula matemática es más
compleja. Más tiempo necesita aún la spline cúbica, aunque para una figura realmente redondeada, esta
es la única opción. Volvemos a nuestro ejemplo y reemplazamos quadratic_spline por
cubic_spline (ver archivo LATHDEM5.POV). Trazamos una vez más y vemos lo que tenemos.
PERSISTENCE OF VISION RAYTRACER 49

Figura 12: La spline cúbica

Mientras que una spline cuadrática necesita tres puntos para determinar la curva, una cúbica necesita
cuatro. Así que, como esperábamos, el punto azul ha dejado de formar parte de la curva, como antes
pasó con el punto rojo. Ahora el primer y el último punto de la curva son solo puntos de control para
determinar las curvas entre los restantes puntos. Pero echemos un vistazo a las transiciones desde el
punto naranja hasta el punto amarillo y después hasta el verde. Ahora, en lugar de parecer equivocados,
los segmentos forman una sola y completamente redondeada curva.

El concepto de las splines es algo útil y necesario, que se volverá a ver de nuevo en los objetos prisma y
polígono. Con un poco de práctica podemos aprenderlo a usar rápidamente.

4.4.5. Malla de triángulos

Los objetos malla (mesh) son muy útiles, porque nos permiten crear objetos conteniendo cientos o
miles de triángulos. Comparados con una simple unión de triángulos, las mallas almacenan los
triángulos de manera más eficiente. Las copias de los objetos malla necesitan muy poca memoria
adicional, porque los triángulos se almacenan sólo una vez.

Casi todos los objetos se pueden aproximar usando triángulos, pero necesitaríamos muchos triángulos
para crear formas complejas. De modo que crearemos una malla muy simple como ejemplo. Este
ejemplo nos mostrará además una característica muy útil de las mallas de triángulos: se puede aplicar
una textura diferente a cada triángulo.

Comencemos. Crearemos una simple caja con caras de diferente color. Crea un archivo llamado
MESHDEMO.POV y añade las siguientes líneas:
camera {
location <20, 20, -50>
look_at <0, 5, 0>
}

light_source { <50, 50, -50> color rgb<1, 1, 1> }

#declare Red = texture {

pigment { color rgb<0.8, 0.2, 0.2> }
finish { ambient 0.2 diffuse 0.5 }
}
4. TUTORIAL PARA PRINCIPIANTES 50

#declare Green = texture {

pigment { color rgb<0.2, 0.8, 0.2> }
finish { ambient 0.2 diffuse 0.5 }
}

#declare Blue = texture {

pigment { color rgb<0.2, 0.2, 0.8> }
finish { ambient 0.2 diffuse 0.5 }
}
Debemos declarar todas las texturas que queremos incluir en la malla antes de crear ésta. Las texturas
no se pueden especificar dentro de la malla debido a que el rendimiento de la memoria decaería.

Ahora añadimos la malla. Tres caras de la caja usarán textura individual, mientras que las otras tres
usarán la textura global de la malla.
mesh {
/* top side */
triangle { <-10, 10, -10>, <10, 10, -10>, <10, 10, 10>
texture { Red }
}
triangle { <-10, 10, -10>, <-10, 10, 10>, <10, 10, 10>
texture { Red }
}
/* bottom side */
triangle { <-10, -10, -10>, <10, -10, -10>, <10, -10, 10> }
triangle { <-10, -10, -10>, <-10, -10, 10>, <10, -10, 10> }
/* left side */
triangle { <-10, -10, -10>, <-10, -10, 10>, <-10, 10, 10> }
triangle { <-10, -10, -10>, <-10, 10, -10>, <-10, 10, 10> }
/* right side */
triangle { <10, -10, -10>, <10, -10, 10>, <10, 10, 10>
texture { Green }
}
triangle { <10, -10, -10>, <10, 10, -10>, <10, 10, 10>
texture { Green }
}
/* front side */
triangle { <-10, -10, -10>, <10, -10, -10>, <-10, 10, -10>
texture { Blue }
}
triangle { <-10, 10, -10>, <10, 10, -10>, <10, -10, -10>
texture { Blue }
}
/* back side */
triangle { <-10, -10, 10>, <10, -10, 10>, <-10, 10, 10> }
triangle { <-10, 10, 10>, <10, 10, 10>, <10, -10, 10> }
texture {
pigment { color rgb<0.9, 0.9, 0.9> }
finish { ambient 0.2 diffuse 0.7 }
}
}
Trazando la escena a 320x240 veremos que la cara superior, la derecha y la frontal tienen diferente
textura. De acuerdo que este no es un ejemplo impresionante de lo que podemos hacer con las mallas.
Puedes encontrar ejemplos más complejos, usando triángulos suavizados, en el directorio de escenas
con los nombres CHESMSH.POV y ROBOTMSH.POV.

4.4.6. Polígono
El objeto polígono se puede usar para crear formas planas de n lados, como cuadrados, rectángulos,
pentágonos, hexágonos, octógonos, etc.
PERSISTENCE OF VISION RAYTRACER 51

Un polígono se define por un determinado número de puntos que describen su forma. Como los
polígonos han de ser cerrados, el primer punto y el último deben coincidir.

En el siguiente ejemplo crearemos la palabra POV usando polígonos.

Comenzaremos considerando los puntos que necesitamos para describir la forma deseada. Queremos
que las letras se encuentren sobre el plano x-y, con la letra O en el centro. Las letras se extienden desde
y=0 hasta y=1. De modo que tenemos los siguientes puntos para cada letra (la coordenada z se pone
automáticamente a 0).
Letra P (polígono externo):
<-0.8, 0.0>, <-0.8, 1.0>,
<-0.3, 1.0>, <-0.3, 0.5>,
<-0.7, 0.5>, <-0.7, 0.0>

Letra P (polígono interno):

<-0.7, 0.6>, <-0.7, 0.9>,
<-0.4, 0.9>, <-0.4, 0.6>

Letra O (polígono externo):

<-0.25, 0.0>, <-0.25, 1.0>,
< 0.25, 1.0>, < 0.25, 0.0>

Letra O (polígono interno):

<-0.15, 0.1>, <-0.15, 0.9>,
< 0.15, 0.9>, < 0.15, 0.1>

Letra V:
<0.45, 0.0>, <0.30, 1.0>,
<0.40, 1.0>, <0.55, 0.1>,
<0.70, 1.0>, <0.80, 1.0>,
<0.65, 0.0>
Las letras P y O tienen un agujero, mientras que la letra V consiste sólo en un polígono. Empezaremos
por la letra V ya que es la más fácil de definir.

Creamos un archivo llamado POLYDEM.POV y añadimos el siguiente texto:

camera {
orthographic
location <0, 0, -10>
right 1.3 * 4/3 * x
up 1.3 * y
look_at <0, 0.5, 0>
}

light_source { <25, 25, -100> color rgb 1 }

polygon {
8,

<0.45, 0.0>, <0.30, 1.0>, // Letra "V"

<0.40, 1.0>, <0.55, 0.1>,
<0.70, 1.0>, <0.80, 1.0>,
<0.65, 0.0>,
<0.45, 0.0>

pigment { color rgb <1, 0, 0> }

}
Como ya hemos dicho el polígono ha de cerrarse añadiendo el primer punto al final de la secuencia. Un
polígono cerrado siempre se define como una secuencia de puntos que termina cuando un punto es el
mismo que el primero.
4. TUTORIAL PARA PRINCIPIANTES 52

Después de crear la letra V continuaremos con la letra P. Como tiene un agujero hemos de encontrar
una manera de recortar este agujero de la forma original. Esto es muy fácil. Definimos la forma externa
de la letra P, que es un polígono cerrado, y añadimos la secuencia de puntos que definen el agujero, que
también es un polígono cerrado. Así tendremos un agujero en donde los dos polígonos se solapen.

En general obtendremos agujeros siempre que un número par de subpolígonos se solapen en una única
sentencia de polígono. Un subpolígono está definido por una secuencia cerrada de puntos.

La letra P consiste en dos subpolígonos, uno para la forma exterior y el otro para el agujero. Como el
polígono del agujero solapa al polígono externo, tendremos un agujero.

Una vez que sabemos como funcionan varios subpolígonos dentro de una única sentencia de polígono,
es bien fácil añadir la letra O.

Finalmente, tenemos la palabra completa POV.

polygon {
30,

<-0.8, 0.0>, <-0.8, 1.0>, // Letra "P"

<-0.3, 1.0>, <-0.3, 0.5>, // forma exterior
<-0.7, 0.5>, <-0.7, 0.0>,
<-0.8, 0.0>,

<-0.7, 0.6>, <-0.7, 0.9>, // agujero

<-0.4, 0.9>, <-0.4, 0.6>,
<-0.7, 0.6>

<-0.25, 0.0>, <-0.25, 1.0>, // Letra "O"

< 0.25, 1.0>, < 0.25, 0.0>, // forma exterior
<-0.25, 0.0>,

<-0.15, 0.1>, <-0.15, 0.9>, // agujero

< 0.15, 0.9>, < 0.15, 0.1>,
<-0.15, 0.1>,

<0.45, 0.0>, <0.30, 1.0>, // Letra "V"

<0.40, 1.0>, <0.55, 0.1>,
<0.70, 1.0>, <0.80, 1.0>,
<0.65, 0.0>,
<0.45, 0.0>

pigment { color rgb <1, 0, 0> }

}
PERSISTENCE OF VISION RAYTRACER 53

Figura 13: La palabra "POV" hecha con polígonos

4.4.7. Prisma
Un prisma es esencialmente un polígono o una curva cerrada barrida a lo largo de una trayectoria recta..
Podemos imaginarnos la figura como la superficie que dejaría la curva al arrastrarla por el espacio. La
curva o polígono que define un prisma puede estar formada por cualquier número de subformas, puede
usar cualquiera de los tres tipos de curvas spline, y puede incluso mantener una anchura constante a lo
largo del barrido o ir estrechándose lentamente hasta acabar en un punto. Pero antes de que todo esto
comience a ser confuso, vamos a ir paso a paso con la forma más simple de prisma. Tecleamos y
trazamos el siguiente trozo de código, (ver PRISMDM1.POV)
#include "colors.inc"

camera {
angle 20
location <2, 10, -30>
look_at <0, 1, 0>
}

light_source { <20, 20, -20> color White }

prism {
linear_sweep
linear_spline
0, // barrer la siguiente curva desde aquí ...
1, // ... hasta aquí
7, // el número de puntos que forman la curva ...

<3,5>, <-3,5>, <-5,0>, <-3,-5>, <3, -5>, <5,0>, <3,5>

pigment { Green }
}
4. TUTORIAL PARA PRINCIPIANTES 54

Figura 14: Un prisma hexagonal

Esto produce un hexágono, que es barrido desde y=0 hasta y=1. En otras palabras, ahora tenemos un
hexágono con grosor. Un punto a tener en cuenta es que aunque esta sea una figura de seis caras,
hemos usado en total siete puntos. Esto es debido a que el polígono se supone que es cerrado, lo cual
hacemos que el último punto coincida con el primero. Técnicamente, con polígonos lineales, si no
hacemos esto POV-Ray uniría automáticamente los dos extremos con una línea para forzar el cerrado,
aunque nos daría una advertencia. Sin embargo, esto sólo funciona con splines lineales, así que no
debemos pasar por alto estos mensajes de advertencia.

4.4.7.1. Nuevos trucos para las curvas spline

Si hemos seguido la sección sobre splines cubierta en el tutorial del torno (ver sección "Entendiendo el
concepto de splines"), sabremos que hay dos tipos adicionales de spline a parte de la lineal: la spline
cuadrática y la cúbica. Por supuesto las podemos usar con los prismas para crear una forma más libre y
redondeada.

Solo hay una cosa tener en cuenta y deberíamos leer esta sección con cuidado para no acabar tirándonos
de los pelos debido a misteriosos mensajes de que nos hacen falta puntos y que nos impiden renderizar
el prisma. Podemos adivinar a donde nos lleva todo esto: como cerrar una spline no lineal.

A diferencia de una spline lineal, que simplemente dibuja una línea entre el primer y último punto si
olvidamos hacer que estos sean el mismo, las splines cuadráticas y cúbicas son un poco más exigentes.

Antes que nada, recordemos que las splines cuadráticas determinan la ecuación de la curva que conecta
dos puntos cualesquiera basándose en esos dos puntos y el punto previo, de manera que el primer
punto en cualquier spline cuadrática es tan solo un punto de control y no será parte de la curva. Lo que
esto significa es: cuando construimos nuestra figura a partir de una spline cuadrática, debemos igualar el
segundo punto con el último, ya que el primer punto no está sobre la curva, solo es un punto de control
necesario por motivos computacionales.

Igualmente, las splines cúbicas necesitan que el primer y último punto sea un punto de control, por lo
tanto, para cerrar una figura construida a partir de una spline cúbica debemos igualar el segundo punto
con el penúltimo. Si no igualamos los puntos correctos en una figura cuadrática o cúbica, entonces
recibiremos los mensajes de error que nos idican que necesitamos más puntos para definir el prisma.
PERSISTENCE OF VISION RAYTRACER 55

POV-Ray espera que nosotros cerremos la figura y cuando termina de procesar todos los puntos sin
encontrar el cierre, se produrce un error.

¿ Confuso? ¿Qué tal un ejemplo? Reemplazamos el prisma en nuestro último fragmento de código por
este (ver archivo PRISMDM2.POV).
prism {
cubic_spline
0, // levantar la figura desde aqui ...
1, // ... hasta aqui
6, // el numero de puntos que formaran la figura ...

< 3, -5>, // point#1 (punto de control... no esta sobre la curva)

< 3, 5>, // point#2 ... ESTE PUNTO ...
<-5, 0>, // point#3
< 3, -5>, // point#4
< 3, 5>, // point#5 ... ES IGUAL QUE ESTE
<-5, 0> // point#6 (punto de control... no esta sobre la curva)

pigment { Green }
}

Figura 15: Forma cúbica para un prisma triangular

Este simple prisma produce lo que parece un triangulo grueso con sus vértices redondeados. Los
puntos dos, tres y cuatro son los vertices del triángulo y el punto cinco cierra la figura volviendo a la
posición del punto dos. En lo que respecta a los puntos uno y seis, son nuestros puntos de control y no
forman parte de la figura. Están allí para ayudar a computar que curvas serán usadas entre los otros
puntos.

4.4.7.2. Transiciones suaves

Ahora fijémonos en que hemos hecho que el punto uno sea igual al punto cuatro, y el punto seis que
sea igual al tres. Esto es importante. A pesar de que este prisma ya estaría legalmente cerrado sin
necesidad de manipular los puntos de control, las transiciones entre las curvas en cada punto no
hubieran sido tan suaves. Cambiamos los puntos uno y seis a <4, 6> y <0, 7> respectivamente y
renderizamos de nuevo para ver como el vertice trasero de la figura es alterado (ver archivo
PRISMDM3.POV).
4. TUTORIAL PARA PRINCIPIANTES 56

Para generalizar, si queremos un cierre suave de una spline cúbica, hacemos que el primer punto de
control sea igual al tercero empezando por el final. Para una spline cuadrática el truco es similar, pero,
ya que solamente el primer punto es un punto de control, hay que hacer que sea igual al penúltimo
punto.

4.4.7.3. Múltiples subformas

Al igual que con el objeto polígono (ver seccion "4.4.6. Polígono") el objeto prisma es muy flexible, y
nos permite construir un prisma a partir de varios sub-prismas. Para hacer esto, todo lo que
necesitamos es seguir añadiendo puntos después de haber cerrado la primera forma. La segunda forma
puede ser simplemente añadida en otra dirección a partir de la primera, pero una de las características
más interesantes es que si cierto número de subformas se superponen en una región determinada, esa
región queda vacía. Veamos otro ejemplo. Una vez más tenemos el mismo código para la cámara y la
fuente de luz, pero sustituimos el prisma por este otro (ver archivo PRISMDM4.POV).
prism {
linear_sweep
cubic_spline
0, // barrer la figura desde aqui ...
1, // ... hasta aqui
18, // el numero de puntos que formaran la figura ...

<3,-5>, <3,5>, <-5,0>, <3, -5>, <3,5>, <-5,0>, // subforma #1

<2,-4>, <2,4>, <-4,0>, <2,-4>, <2,4>, <-4,0>, // subforma #2
<1,-3>, <1,3>, <-3,0>, <1, -3>, <1,3>, <-3,0> // subforma #3

pigment { Green }
}

Figura 16: Usando subformas para crear formas más complejas

Por motivos de legibilidad, hemos empezado una nueva línea cada vez que cambiamos a la siguiente
subforma, pero el trazador de rayos determina donde termina cada subforma basándose en el cierre de
las figuras (como fue descrito antes). Renderizamos el nuevo prisma y vemos lo que tenemos. Es la
misma y familiar forma de antes, pero ahora parece que una pequeña versión de la forma haya sido
extraída del centro y dentro del espacio vacío haya sido colocada otra versión todavía más pequeña.

Simplemente, la región exterior está formada por la subforma #1, el agujero excavado es donde las
subforma #1 y la subforma #2 se superponen. En el centro el objeto reaparece debido a que las
PERSISTENCE OF VISION RAYTRACER 57

subformas #1, #2 y #3 se superponen, devolviendo un número impar de piezas superpuestas. Usando

esta técnica podemos construir prismas extremadamente complejos.

4.4.7.4. Barrido cónico y el efecto de estrechamiento

En nuesto prisma original, el identificador linear_sweep es opcional. Este es el tipo de barrido asumido
por defecto para un prisma si no se especifica ninguno. Pero hay otro tipo de barrido extremamente
útil: el barrido cónico. La idea básica es la del prisma original, excepto que cuando estamos barriendo la
forma desde la primera altura hasta la segunda, la estamos constantemente expandiendo desde un único
punto hasta que, al llegar a la segunda altura, el objeto tiene la forma que delimitan los puntos a partir
de los cuales está hecho. Para dar una ligera idea de la utilidad de este efecto, reemplazamos nuestro
prisma por este (ver fichero PRISMDM5.POV):
prism {
conic_sweep
linear_spline
0, // altura 1
1, // altura 2
5, // el numero de puntos que forman la figura...

<4,4>,<-4,4>,<-4,-4>,<4,-4>,<4,4>

rotate <180, 0, 0>

translate <0, 1, 0>
scale <1, 4, 1>
pigment { gradient y scale .2 }
}

Figura 17: Creando una pirámide usando el barrido cónico

El pigmento gradiente fue seleccionado para dar algo de definición a nuestro objeto sin tener que fijar
las fuentes de luz y el ángulo de la cámara, pero cuando lo trazamos, ¿qué es lo que hemos creado?,
¡Una pirámide rayada horizontalmente! Por ahora podemos reconocer la spline lineal conectando los
cuatro puntos de un cuadrado y el familiar punto final que cierra la spline.

Notemos todas las transformaciones en la declaración del objeto. Esto va a necesitar una serie de
explicaciones. La rotación y la traslación son fáciles de entender. Normalmente, un barrido cónico
empieza con el máximo tamaño en la parte superior y se va estrechando hasta un punto en y=0, pero
por supuesto esto seria al reves si estamos haciendo una pirámide. Así que giramos el objeto respecto al
4. TUTORIAL PARA PRINCIPIANTES 58

eje x para colocarlo correctamente. Entonces, ya que hemos rotado respecto al vertice, trasladamos el
objeto hacia arriba para ponerlo en la misma posición en la que estaba cuando empezamos.

El escalado sirve para adecuar las proporciones a este ejemplo. La base mide ocho unidades por ocho
unidades, pero la altura (desde y=1 hasta y=0) es solode una unidad, así que la estiramos un poco.
Llegados a este punto, probablemente estaremos pensando, “¿Por que no simplemente hacer el barrido
desde y=0 hasta y=4 y evitar este escalado?”

Este es un error frecuente con los barridos cónicos. Para ver lo que está mal, pongámoslo en práctica
(ver archivo PRISMDM6.POV). Debemos asegurarnos de quitar el escalado y reemplazar la siguiente línea
1, // altura 2
por
4, // altura 2
Esto sitúa la segunda altura a y=4, así que rendericemos de nuevo y veamos si el efecto es el mismo.

Figura 18: Escogiendo una segunda altura mayor que uno para el
barrido cónico

Vaya... La altura es correcta, pero la base de nuestra pirámide es enorme. ¿Qué es lo que ha ido mal?
Simple, la base, tal como la hemos descrito con los puntos que hemos usado, está situada en y=1 sin
importar donde hayamos situado la segunda altura. Pero si definimos la segunda altura mayor que uno,
una vez que el barrido ha pasado por y=1, continua expandiendo el objeto a lo largo de las mismas
líneas que ha seguido hasta la base original, haciendo que la nueva base sea cada vez más grande.

Para evitar perder el control de un prisma construido a partir de un barrido cónico, es mejor dejar la
segunda altura en y=1 y hacer un escalado para ajustar la altura desde su tamaño unitario. De esta forma
siempre podremos estar seguros de que las esquinas de la base permanecen donde creemos que deben
estar.

Esto nos lleva a otro punto interesante acerca de los barridos cónicos. ¿Qué pasa si, por alguna razón,
no queremos que el estrechamiento llegue a un único punto? ¿Qué pasa si en lugar de una pirámide
completa, lo que queremos es algo mas parecido a un zigurat escalonado? Nada más fácil. Después de
poner la segunda altura otra vez a uno y poner de nuevo el escalado, cambiamos la siguiente línea
0, // altura 1
PERSISTENCE OF VISION RAYTRACER 59

por
0.9, // altura 1

Figura 19: Incrementando la primera altura para el barrido

cónico

Cuando trazamos de nuevo, vemos que el barrido termina poco antes de llegar al vértice, mostrándonos
una pirámide sin punta. La altura a la que es cortada la pirámide depende de lo cerca que esté la primera
altura de la segunda.

4.4.8. Elipsoide supercuádrico

A veces queremos utilizar un objeto similar a una caja cuyos bordes no son rectos, si no redondeados
(suavizados). Este objeto es muy útil para ese fin. Se describe mediante la sintaxis:
superellipsoid { <r, n> }
Donde r y n son valores decimales entre cero y uno. Probemos alguno para ver que tipo de formas
producen.

Abrimos un archivo llamado SUPELLPS.POV y escribimos lo siguiente:

#include "colors.inc"
camera {
location <10, 5, -20>
look_at 0
angle 15
}
background { color rgb <.5, .5, .5> }
light_source { <10, 50, -100> White }
El color de fondo gris hace más sencillo ver nuestro objeto. Ahora escribimos:
superellipsoid { <.25, .25>
pigment { Red }
}
Guardamos el archivo y lo trazamos a tamaño 200x150. Parece una caja, pero sus bordes están
redondeados. Ahora experimentemos diferentes valores para r y n.

Para la siguiente prueba, intenta <1, 0.2>. La forma parece un cilindro, aunque los bordes de las caras
están redondeados.
4. TUTORIAL PARA PRINCIPIANTES 60

Intentémoslo ahora con <0.1, 1>. Es difícil describir esta figura, pero es interesante.

Finalmente, probemos <1, 1>. Bueno, esto es más familiar... ¡una esfera!

Debemos tener en cuenta algunas cosas para usar los superelipsoides. En primer lugar, no debemos
usar el valor cero para ninguno de los dos parámetros. Esto causaría el dibujo de una caja negra en lugar
de nuestra figura. En segundo lugar, valores muy próximos a cero de r y n producen resultados muy
extraños, así que es conveniente evitarlos. Finalmente, el método Sturm para resolver ecuaciones no
funcionará con estas figuras.

Los superelipsoides son objetos finitos, de forma que responden bien al encapsulado automático
(método que permite acelerar el cálculo de imágenes, evitando la necesidad de usar la instrucción
bounded_by). Pueden usarse bien en composición de objetos (CSG, uniones e intersección).

Ahora, usemos esta figura para hacer algo útil en una escena. Haremos un suelo agrupando varios,
usándolos como baldosas, y situaremos un puñado de ellos flotando encima. Podemos empezar con el
archivo anterior.

Le cambiamos el nombre a TILES.POV y lo editamos para que contenga lo siguiente:

#include "colors.inc"
#include "textures.inc"

camera {
location <10, 5, -20>
look_at 0
angle 15
}

background { color rgb <.5, .5, .5> }

light_source{ <10, 50, -100> White }

Observa que hemos añadido #include "textures.inc" para que podamos usar texturas
predefinidas. Ahora definimos el superelipsoide que usaremos de baldosa.
#declare Tile = superellipsoid { <0.5, 0.1>
scale <1, .05, 1>
}
Los superelipsoides miden alrededor de 2 por 2 por 2, de forma que lo escalamos para que tengan el
tamaño apropiado. Como queremos apilarlos juntos, hemos de tener cuidado al separarlos para que no
se solapen. Elegimos un valor de 2.1 como desplazamiento con el fin de dejar un poco de espacio que
se llenará con cemento. Añadamos esto:
#declare Offset = 2.1
Coloquemos una fila de baldosas. Cada una será desplazada un múltiplo del desplazamiento escogido en
la dirección del eje z (en ambos sentidos). Multiplicamos este desplazamiento por el orden que ocupa la
baldosa en la fila para lograr este efecto. Unimos todos estos objetos en uno solo llamado Row, como
este:
#declare Row = union {
object { Tile }
object { Tile translate z*Offset }
object { Tile translate z*Offset*2 }
object { Tile translate z*Offset*3 }
object { Tile translate z*Offset*4 }
object { Tile translate z*Offset*5 }
object { Tile translate z*Offset*6 }
object { Tile translate z*Offset*7 }
object { Tile translate z*Offset*8 }
PERSISTENCE OF VISION RAYTRACER 61

object { Tile translate z*Offset*9 }

object { Tile translate z*Offset*10 }
object { Tile translate -z*Offset }
object { Tile translate -z*Offset*2 }
object { Tile translate -z*Offset*3 }
object { Tile translate -z*Offset*4 }
object { Tile translate -z*Offset*5 }
object { Tile translate -z*Offset*6 }
}
Esto nos da una fila sencilla de 17 baldosas, suficiente para llenar la pantalla. Ahora debemos hacer
copias de esta fila y trasladarlas con ayuda del desplazamiento (Offset) prefijado en la dirección del eje
x, de la misma forma:
object { Row }
object { Row translate x*Offset }
object { Row translate x*Offset*2 }
object { Row translate x*Offset*3 }
object { Row translate x*Offset*4 }
object { Row translate x*Offset*5 }
object { Row translate x*Offset*6 }
object { Row translate x*Offset*7 }
object { Row translate -x*Offset }
object { Row translate -x*Offset*2 }
object { Row translate -x*Offset*3 }
object { Row translate -x*Offset*4 }
object { Row translate -x*Offset*5 }
object { Row translate -x*Offset*6 }
object { Row translate -x*Offset*7 }
Finalmente, las unimos para darles una sola textura, un mármol blanco como pigmento y un acabado
brillante con algo de reflexión.
union{
object { Row }
object { Row translate x*Offset }
object { Row translate x*Offset*2 }
object { Row translate x*Offset*3 }
object { Row translate x*Offset*4 }
object { Row translate x*Offset*5 }
object { Row translate x*Offset*6 }
object { Row translate x*Offset*7 }
object { Row translate -x*Offset }
object { Row translate -x*Offset*2 }
object { Row translate -x*Offset*3 }
object { Row translate -x*Offset*4 }
object { Row translate -x*Offset*5 }
object { Row translate -x*Offset*6 }
object { Row translate -x*Offset*7 }
pigment { White_Marble }
finish { phong 1 phong_size 50 reflection .35 }
}
Ahora añadimos el cemento. Esto será sencillamente un plano de color blanco. Incrementamos su valor
de luz ambiente para que parezca más blanco.
plane { y, 0 //esto es el cemento
pigment { color White }
finish { ambient .4 diffuse .7 }
}
4. TUTORIAL PARA PRINCIPIANTES 62

Para completar la escena, añadimos cinco superelipsoides diferentes, cada uno de un color, de forma
que floten sobre las baldosas reflejándose en ellas.
superellipsoid {
<0.1, 1>
pigment { Red }
translate <5, 3, 0>
scale .45
}

superellipsoid {
<1, 0.25>
pigment { Blue }
translate <-5, 3, 0>
scale .45
}

superellipsoid {
<0.2, 0.6>
pigment { Green }
translate <0, 3, 5>
scale .45
}

superellipsoid {
<0.25, 0.25>
pigment { Yellow }
translate <0, 3, -5>
scale .45
}

superellipsoid {
<1, 1>
pigment { Pink }
translate y*3
scale .45
}
Trazamos la escena a 320x 200 para ver el resultado. Si estamos contentos con él, la imagen final
podemos crearla a 640x480 y con antialias 0.2.

Figura 20: Objetos superelipsoides flotando sobre un suelo

embaldosado
PERSISTENCE OF VISION RAYTRACER 63

4.4.9. Superficie de revolución

Botellas, vasijas y vasos son bonitos objetos para las imágenes de trazado de rayos. Vamos a crear una
copa dorada usando el objeto superficie de revolución (objeto SOR, por sus iniciales en inglés).

Empezamos pensando la forma del objeto final. Es bastante difícil obtener los puntos que describen
una curva dada sin la ayuda de un programa modelador que soporte este tipo de objetos. Si tal
programa está disponible podemos sacar mucho partido de él.

Figura 21: Los puntos que configuran nuestro objeto copa

Usaremos la configuración de puntos que muestra la figura anterior. Hay ocho puntos que describen la
curva que será rotada alrededor del eje y para obtener la copa. La curva se calcula usando el método
descrito en la sección de referencia (ver "Superficie de Revolución").

Es el momento de empezar con la escena. Editamos un archivo llamado SORDEMO.POV y escribimos el

siguiente texto:
#include "colors.inc"
#include "golds.inc"

global_settings { assumed_gamma 2.2 }

camera {
location <10, 15, -20>
look_at <0, 5, 0>
angle 45
}

background { color rgb<0.2, 0.4, 0.8> }

light_source { <100, 100, -100> color rgb 1 }

plane { y, 0
pigment { checker color Red, color Green scale 10 }
}

sor {
4. TUTORIAL PARA PRINCIPIANTES 64

8,
<0.0, -0.5>,
<3.0, 0.0>,
<1.0, 0.2>,
<0.5, 0.4>,
<0.5, 4.0>,
<1.0, 5.0>,
<3.0, 10.0>,
<4.0, 11.0>
texture { T_Gold_1B }
}
Esta escena contiene nuestra copa sobre un plano ajedrezado. Trazar la escena a una resolución de
320x200 produce la imagen siguiente:

Figura 22: Un objeto superficie de revolución

La superficie de revolución se describe escribiendo, en primer lugar, el número de puntos, seguido por
los puntos en orden ascendente de altura. Cada punto determina el radio de la curva a una altura
determinada. Por ejemplo, el primero de ellos le dice a POV-Ray que a una altura de -0.5 el radio es 0.
Podemos observar que cada punto tiene una altura mayor que su predecesor. Si no se hace así el
programa se detendrá con un error.

4.4.10. Texto
Crear texto usando POV-Ray solía significar que las letras había que construirlas usando composición
de objetos (CSG), un proceso bastante pesado, o usando una imagen en blanco y negro de las letras
como campo de alturas, un método que no siempre es satisfactorio. Ahora, en POV-Ray 3.0, se ha
introducido un nuevo tipo de objeto que permite usar cualquier fuente de tipo True Type para crear
objetos de texto. Estos objetos se pueden usar en composición y transformarse en posición, tamaño y
apariencia como cualquier otra primitiva de POV-Ray.

En este tutorial haremos dos usos de este objeto. En primer lugar, colocaremos unas cuantas letras
sobre un plano ajedrezado. Podemos usar cualquier fuente TTF, aunque aquí se usará sólo las incluidas
con POV-Ray 3.0.

Creamos un archivo llamado TEXTDEMO.POV y escribimos:

#include "colors.inc"
PERSISTENCE OF VISION RAYTRACER 65

camera {
location <0, 1, -10>
look_at 0
angle 35
}

light_source { <500,500,-1000> White }

plane { y,0
pigment { checker Green White }
}
Ahora, incluyamos el objeto de texto. Usaremos el archivo TIMROM.TTF con la cadena POV-RAY 3.0.
De momento, haremos nuestras letras de color rojo. La sintaxis es muy sencilla. La primera cadena
entrecomillada es el nombre de la fuente, la segunda es el texto que aparecerá en el dibujo. Los dos
números decimales que las siguen son el grosor y el desplazamiento. El grosor determina el tamaño del
bloque sobre el que están recortadas las letras. Los valores apropiados pueden estar entre 0.5 y 2. El
desplazamiento es un valor que se añadirá al valor definido por la propia fuente para separar las letras.
De momento se dejará a cero.
text { ttf "timrom.ttf" "POV-RAY 3.0" 1, 0
pigment { Red }
}
Al trazar esta escena a 200x150, observamos que las letras se salen por la derecha de la imagen. Esto es
así porque POV-Ray sitúa el texto de forma que la esquina inferior izquierda delantera de la primera
letra coincide con el origen. Para centrarlo debemos desplazar el texto en el sentido negativo del eje x.
Pero ¿cuanta distancia? En la documentación vemos que la altura de las letras está entre 0.5 y 0.75
unidades. Si asumimos que la distancia entre una y otra ronda las 0.5 unidades, significa que la cadena
en total tendrá unas 6 unidades, de forma que trasladaremos el objeto 3 unidades en el sentido negativo
del eje x.
text { ttf "timrom.ttf" "POV-RAY 3.0" 1, 0
pigment { Red }
translate -3*x
}
Mucho mejor. Ahora vamos a jugar un poco con los parámetros del objeto. En primer lugar,
aumentaremos su grosor hasta un valor grande... ¡pongamos 25!
text { ttf "timrom.ttf" "POV-RAY 3.0" 25, 0
pigment { Red }
translate -2.25*x
}
Realmente, queda un tanto extraño. Devolvamos este valor a 1 e intentemos un valor diferente para el
desplazamiento. Pongamos 0.1 en lugar de 0 y volvamos a trazar.

¡Un momento! ¡Las letras se desplazan en ángulo! ¡Esto no es lo que describe el manual! Parece que el
valor de desplazamiento se aplica tanto en el eje x como en el eje y, en lugar de desplazarlas sólo en la
dirección x. ¿Se necesita aquí un vector en lugar de un solo número? Probemos. Reemplazaremos 0.1
por 0.1*x y probaremos de nuevo.

¡Ahora funciona! Las letras siguen en línea recta, aunque un poco más separadas de lo que lo estaban
antes. Verifiquemos esta propiedad haciendo que las letras se desplacen en otra dirección. Cambiando
0.1*x por 0.1*y, observamos que las letras suben un poco al desplazarnos de izquierda a derecha, sin
separarse horizontalmente más de lo que estaban. Ahora, probemos el eje z. Reemplacemos 0.1*y por
0.1*z. Trazar esto produce una pequeña desilusión: no hay tal desplazamiento, sólo funciona en las
direcciones x e y.
4. TUTORIAL PARA PRINCIPIANTES 66

Acabemos nuestra escena dando a las letras una textura mejor, usando un gran valor para el grosor y
añadiendo un pequeño desplazamiento vertical a nuestras letras. Para obtener un mejor resultado,
usaremos una esfera celeste, adornaremos un poco nuestro plano y buscaremos una situación de la
cámara mejor (trazamos la siguiente escena a 640x480 y con antialias).
#include "colors.inc"

camera {
location <-5,.15,-2>
look_at <.3,.2,1>
angle 35
}

light_source { <500,500,-1000> White }

plane { y,0
texture {
pigment { SeaGreen }
finish { reflection .35 specular 1 }
normal { ripples .35 turbulence .5 scale .25 }
}
}

text { ttf "timrom.ttf" "POV-RAY 3.0" 25, 0.1*y

pigment { BrightGold }
finish { reflection .25 specular 1 }
translate -3*x
}

#include "skies.inc"

sky_sphere { S_Cloud5 }
Ahora, vamos a usar un objeto de texto en una operación CSG. Intentaremos crear un bajorrelieve en
un bloque de piedra usando unas letras. Creamos un nuevo archivo llamado TEXTCSG.POV y lo editamos
de la siguiente forma:
#include "colors.inc"
#include "stones.inc"

background { color rgb 1 }

camera {
location <-3, 5, -15>
look_at 0
angle 25
}

light_source { <500,500,-1000> White }

Ahora, creamos el bloque de piedra. Lo queremos de ocho unidades de largo para centrar en el interior
nuestra frase (POV-RAY 3.0), que mide alrededor de seis unidades. Lo haremos también de cuatro
unidades de alto y una de grueso. Como queremos evitar una coincidencia accidental entre la superficie
del bloque y la del texto, usaremos una coordenada z inicial de 0.1 en lugar de 0. Finalmente, le damos
una agradable textura de piedra escogida del archivo STONES.INC.
box { <-3.5, -1, 0.1>, <3.5, 1, 1>
texture { T_Stone10 }
}
Ahora, creamos nuestro texto. Usamos el mismo objeto que en el primer ejemplo, sólo variando un
poco el grosor y el desplazamiento.
text { ttf "timrom.ttf" "POV-RAY 3.0" 0.15, 0
pigment { BrightGold }
finish { reflection .25 specular 1 }
PERSISTENCE OF VISION RAYTRACER 67

translate -3*x
}
Recordemos que, por defecto, el texto se coloca de forma que su cara frontal se apoya en el plano x-y.
Como el frontal del bloque se inicia en 0.1, resulta que nuestro texto penetra en la piedra un total de
0.05 unidades. Ahora, basta situar alrededor de ambos objetos una operación de diferencia y tendremos
nuestro objetivo:
difference {
box { <-3.5, -1, 0.1>, <3.5, 1, 1>
texture { T_Stone10 }
}
text { ttf "timrom.ttf" "POV-RAY 3.0" 0.15, 0
pigment { BrightGold }
finish { reflection .25 specular 1 }
translate -3*x
}
}
Lo trazamos a 200x150. Nos fijamos si se aprecia realmente la profundidad del texto, y su textura en
oro brillante. Lo volvemos a trazar, esta vez a 640x480 y con antialias para ver el resultado más
claramente, pero seamos pacientes, porque esta imagen tardará algo de tiempo en estar lista.

Figura 23: Texto excavado en piedra

4.4.11. Toro
Podemos pensar en un toro como en un "donut" o un neumático. Es una forma que se usa mucho en
operaciones de composición de objetos, de forma que POV-Ray ha adoptado esta forma polinómica de
cuarto grado como forma primitiva. Su sintaxis es muy sencilla, así que es sencillo aprender a usarla una
vez que se ha comprendido lo que significan los dos valores decimales que se deben indicar. En lugar de
describirlos, creemos un objeto de este tipo y experimentemos con él.

Creamos un archivo llamado TORDEMO.POV y escribimos:

#include "colors.inc"

camera {
location <0, .1, -25>
look_at 0
angle 30
4. TUTORIAL PARA PRINCIPIANTES 68

background { color Gray50 } // para hacer el toro más visible

light_source{ <300, 300, -1000> White }

torus { 4, 1 // radio interno y radio externo

rotate -90*x // para verlo desde arriba
pigment { Green }
}
Trazamos la escena. Bien, lo que vemos es una especie de neumático. Cambiemos el radio interno y el
externo y veamos qué pasa. Escribimos:
torus { 5, .25 // radio interno y radio externo
¡Esto parece un aro! Probemos lo siguiente:
torus { 3.5, 2.5 // radio interno y radio externo
Esto es... ¡un neumático excesivamente inflado!

Con una sintaxis tan simple, no hay mucho que hacer con un toro salvo cambiarle la textura...¿no?
Veamos...

Los toros son muy útiles en composición de formas. Hagamos un pequeño experimento. Veamos qué
forma tiene la diferencia entre un toro y una caja:
difference {
torus { 4, 1
rotate x*-90 // para verlo desde arriba
}
box { <-5, -5, -1>, <5, 0, 1> }
pigment { Green }
}
Interesante... medio toro. Ahora añadiremos otro al revés. Sólo hay que declararlo y hacer las
transformaciones necesarias para usarlo en dos posiciones distintas:
#declare Half_Torus = difference {
torus { 4, 1
rotate -90*x // para verlo desde arriba
}
box { <-5, -5, -1>, <5, 0, 1> }
pigment { Green }
}

#declare Flip_It_Over = 180*x

#declare Torus_Translate = 8 // doble del radio mayor

Ahora, creamos la unión de dos semitoros:
union {
object { Half_Torus }
object { Half_Torus
rotate Flip_It_Over
translate Torus_Translate*x
}
}
Esto produce un objeto con forma de S, pero no lo podemos ver totalmente desde la posición actual de
la cámara. Añadamos unos cuantas piezas más de ese tipo, moviendo nuestro objeto en la dirección del
eje z y girándolo un poco con respecto al eje y para poder verlo algo más. También observamos que
aparece un pequeño vacío donde se juntan los dos semitoros. Este defecto se debe al hecho de ver esta
escena directamente desde el plano x-z (un defecto debido al tipo de cálculo que hace el programa; en
PERSISTENCE OF VISION RAYTRACER 69

general, no conviene que nuestra cámara coincida con un plano de alguna de las cajas utilizadas en la
imagen). Cambiaremos la coordenada y de la cámara de 0 a 0.1 para evitar este defecto.
union {
object { Half_Torus }
object { Half_Torus
rotate Flip_It_Over
translate x*Torus_Translate
}
object { Half_Torus
translate x*Torus_Translate*2
}
object { Half_Torus
rotate Flip_It_Over
translate x*Torus_Translate*3
}
object { Half_Torus
rotate Flip_It_Over
translate -x*Torus_Translate
}
object { Half_Torus
translate -x*Torus_Translate*2
}
object { Half_Torus
rotate Flip_It_Over
translate -x*Torus_Translate*3
}
object { Half_Torus
translate -x*Torus_Translate*4
}
rotate y*45
translate z*20
}
Al crear la imagen veremos una forma serpenteante muy curiosa. Pero queremos modelar algo más útil,
que podamos encontrar en la vida real ¿que tal una cadena?

Pensemos un momento. Hay que observar que un eslabón de la cadena puede ser modelado de forma
muy sencilla usando dos semitoros y dos cilindros. Creamos un nuevo archivo, en el que podemos usar
los mismos fondo, cámara, luz y declaraciones de objetos que usábamos en TORDEMO.POV:
#include "colors.inc"

camera {
location <0, .1, -25>
look_at 0
angle 30
}

background { color Gray50 }

light_source{ <300, 300, -1000> White }

#declare Half_Torus = difference {

torus { 4,1
sturm
rotate x*-90 // para verlo desde arriba
}
box { <-5, -5, -1>, <5, 0, 1> }
pigment { Green }
}

#declare Flip_It_Over = x*180

#declare Torus_Translate = 8
Ahora, creamos un toro completo a partir de dos semitoros:
4. TUTORIAL PARA PRINCIPIANTES 70

union {
object { Half_Torus }
object { Half_Torus rotate Flip_It_Over }
}
Esto parece ser una forma algo artificiosa de crear un toro, pero realmente vamos a desplazar cada
mitad para dejar sitio a los cilindros. Primero, declararemos los cilindros que utilizaremos:
#declare Chain_Segment = cylinder { <0, 4, 0>, <0, -4, 0>, 1
pigment { Green }
}
Después, añadiremos dos de estos cilindros a la unión de los semitoros trasladándolos de forma que
queden alineados con el radio exterior de los toros a cada lado:
union {
object { Half_Torus }
object { Half_Torus rotate Flip_It_Over }
object { Chain_Segment translate x*Torus_Translate/2 }
object { Chain_Segment translate -x*Torus_Translate/2 }
}
Ahora, trasladamos los semitoros en la dirección vertical para que sus extremos coincidan con los de los
cilindros. La distancia coincide con la mitad de la definida como Torus_Tranlate:
union {
object { Half_Torus
translate y*Torus_Translate/2
}
object { Half_Torus
rotate Flip_It_Over
translate -y*Torus_Translate/2
}
object { Chain_Segment
translate x*Torus_Translate/2
}
object { Chain_Segment
translate -x*Torus_Translate/2
}
}
Trazamos el resultado y tenemos un eslabón de la cadena. ¡Pero aún no hemos acabado! ¿Alguien ha
visto una cadena de color verde? Usemos una apariencia metálica sobre ellos. En primer lugar,
borremos todos los pigmentos de las declaraciones de los toros y cilindros. Después, declaremos lo
siguiente antes de la unión:
#declare Chain_Gold = texture {
pigment { BrightGold }
finish {
ambient .1
diffuse .4
reflection .25
specular 1
metallic
}
}
Ahora, añadamos esta textura a la unión y nombrémosla apropiadamente:
#declare Link = union {
object { Half_Torus
translate y*Torus_Translate/2
}
object { Half_Torus
rotate Flip_It_Over
translate -y*Torus_Translate/2
}
object { Chain_Segment
PERSISTENCE OF VISION RAYTRACER 71

translate x*Torus_Translate/2
}
object { Chain_Segment
translate -x*Torus_Translate/2
}
texture { Chain_Gold }
}
Por fin, uniremos dos eslabones. El segundo debe ser trasladado en dirección vertical de forma que su
cara interior coincida con la cara interior del primer eslabón. La distancia adecuada resulta ser el doble
de la distancia Torus_Translate menos dos (dos veces el radio exterior). Esto puede describirse
mediante la expresión:
(Torus_Translate*2-2)*y
Declaramos la expresión como sigue:
#declare Link_Translate = (Torus_Translate*2-2)*y
En el bloque en el que situemos el objeto, usaremos este valor multiplicándolo para insertar nuevos
eslabones. Ahora, rotaremos el segundo eslabón noventa grados respecto al eje vertical para que sea
perpendicular al primero (como los verdaderos eslabones de una cadena). Finalmente, reduciremos el
tamaño de la unión a un cuarto de su tamaño para poder ver el resultado completamente:
union {
object { Link }
object { Link translate y*Link_Translate rotate y*90 }
scale .25
}
Al trazar esto, podremos ver un par de eslabones muy realistas. Si queremos hacer una cadena
completa, necesitamos declarar esta unión y crear otra unión usando como pieza este par de eslabones.
Quitamos el escalado de la primera declaración para poder escalar sólo el objeto definitivo:
#declare Link_Pair =
union {
object { Link }
object { Link translate y*Link_Translate rotate y*90 }
}
Ahora declaramos nuestra cadena:
#declare Chain = union {
object { Link_Pair}
object { Link_Pair translate y*Link_Translate*2 }
object { Link_Pair translate y*Link_Translate*4 }
object { Link_Pair translate y*Link_Translate*6 }
object { Link_Pair translate -y*Link_Translate*2 }
object { Link_Pair translate -y*Link_Translate*4 }
object { Link_Pair translate -y*Link_Translate*6 }
}
Y, finalmente, situamos nuestra cadena añadiendo unas transformaciones para hacerla visible en su
totalidad. Estas transformaciones incluyen escalarla en un factor 1/10, trasladarla y girarla para poder
ver bien todos los enlaces:
object { Chain scale .1 rotate <0, 45, -45> }
4. TUTORIAL PARA PRINCIPIANTES 72

Figura 24: El objeto toro puede usarse para crear cadenas

En la imagen podemos ver una cadena dorada que cruza diagonalmente la pantalla.

4.5. Objetos CSG (Geometría Sólida Constructiva)

La Geometría Sólida Constructiva, CSG son sus iniciales en inglés, es una poderosa herramienta que
usamos para combinar primitivas simples para crear objetos más complejos, como se verá en las
secciones siguientes.

4.5.1. ¿Qué es CSG?

POV-Ray nos permite construir sólidos complejos combinando formas primitivas de cuatro formas
diferentes (realmente, sólo tres). En la unión, dos o más formas se asocian para ser utilizadas como una
sola pieza. En el caso de la intersección, sólo aparece el volumen común a todas las figuras. La
diferencia, como veremos, es análoga a la intersección, aunque no lo parezca, ya que en este caso las
formas recortan su propio volumen de la que aparece en primer lugar. Y por último, aunque no sea la
menos importante, citaremos la fusión (merge), que es un tipo especial de unión en la que las superficies
interiores a los objetos desaparecen, lo cual es especialmente útil en los objetos transparentes.
Trataremos estas formas de CSG en detalle en las secciones siguientes.

Los objetos CSG pueden se extremadamente complejos. Pueden estar anidados profundamente (una
unión puede contener varias intersecciones, y éstas varias diferencias...).Los objetos CSG son (casi
siempre) objetos finitos y por tanto responden al método automático de simplificación que usa POV-
Ray (auto-bounding) y pueden también ser transformados como si fuesen cualquier otra forma
primitiva. A pesar de esto, en determinadas circunstancias, conviene utilizar (con moderación) la
instrucción bounded_by si creamos un CSG muy complejo.

4.5.2. Unión
Intentemos diseñar una unión sencilla. Crea un archivo llamado CSGDEMO.POV y escribe:
#include "colors.inc"

camera {
location <0, 1, -10>
PERSISTENCE OF VISION RAYTRACER 73

look_at 0
angle 36
}

light_source { <500, 500, -1000> White }

plane { y, -1.5
pigment { checker Green White }
}
Añade dos esferas, trasladando cada una de ellas en un sentido distinto del eje x 0.5 unidades.
Colorearemos una roja y otra azul.
sphere { <0, 0, 0>, 1
pigment { Blue }
translate -0.5*x
}
sphere { <0, 0, 0>, 1
pigment { Red }
translate 0.5*x
}
Trazamos esta unión a 200x150. Coloquemos una unión agrupando ambas esferas. Esto creará un solo
objeto, unión de ambas esferas.
union{
sphere { <0, 0, 0>, 1
pigment { Blue }
translate -0.5*x
}
sphere { <0, 0, 0>, 1
pigment { Red }
translate 0.5*x
}
}
Si lo volvemos a trazar, no observaremos ningún cambio, pero ahora podemos dar a ambas esferas la
misma textura, moverlas como si de una sola pieza se tratase, o escalarlas. Hagámoslo:
union{
sphere { <0, 0, 0>, 1
translate -0.5*x*
}
sphere { <0, 0, 0>, 1
translate 0.5*x
}
pigment { Red }
scale <1, .25, 1>
rotate <30, 0, 45>
}
Al trazarlo ahora, observaremos que la imagen ha cambiado radicalmente. Podemos escalarla con
diferentes valores, o probar sobre este objeto varias texturas distintas.

Aplicar una textura a una unión en lugar de hacerlo sobre los objetos aislados tiene varias ventajas. En
primer lugar, cambiar de decisión sobre la apariencia del objeto es más si sólo hemos de escribirla una
vez que si debemos cambiarla en todos los objetos que compongan la figura. En segundo lugar, la
escena se interpreta más rápido, ya que sólo es necesario que el ordenador la interprete una vez. En
tercer lugar, ahorra memoria, ya que el programa construye un solo modelo de textura (y referencia cada
objeto a este modelo). Si la aplicamos sobre varios objetos, aunque la textura sea idéntica, almacena una
copia por cada uno de ellos.
4. TUTORIAL PARA PRINCIPIANTES 74

4.5.3. Intersección
Ahora usemos las mismas esferas de la sección anterior para ilustrar el siguiente tipo de objeto CSG, la
intersección. Cambiamos la palabra "union" por "intersection", y borramos las transformaciones:
intersection {
sphere { <0, 0, 0>, 1
translate -0.5*x
}
sphere { <0, 0, 0>, 1
translate 0.5*x
}
pigment { Red }
}
Al trazar la escena, veremos un objeto similar a una lente, en lugar de las dos esferas. Esto sucede
porque la intersección encierra el volumen compartido por todas las formas, en este caso la figura que
vemos, donde las esferas se solapan. Me gusta este objeto, de forma que lo usaremos para explicar las
diferencias.

4.5.4. Diferencia
Rotemos el objeto de forma que presente su frente a la cámara.
intersection{
sphere { <0, 0, 0>, 1
translate -0.5*x
}
sphere { <0, 0, 0>, 1
translate 0.5*x
}
pigment { Red }
rotate 90*y
}

Ahora creemos un cilindro y situémoslo atravesando el centro de la lente.

cylinder { <0, 0, -1> <0, 0, 1>, .35

pigment { Blue }
}
Trazamos la esfera para ver la posición del cilindro. Después incluiremos la lente y el cilindro en el
interior de un bloque diferencia, como sigue:
difference {
intersection {
sphere { <0, 0, 0>, 1
translate -0.5*x
}
sphere { <0, 0, 0>, 1
translate 0.5*x
}
pigment { Red }
rotate 90*y
}
cylinder { <0, 0, -1> <0, 0, 1>, .35
pigment { Blue }
}
}
Al trazar de nuevo la escena, veremos el objeto con forma de lente con un hoyo cortado limpiamente
en su centro. El cilindro ha sido sustraído de la intersección. Observa que el color del cilindro hace que
el interior del cilindro aparezca de color azul. Si lo eliminamos, toda su superficie se verá roja.
PERSISTENCE OF VISION RAYTRACER 75

En realidad, la diferencia no es un objeto diferente, es idéntica a la intersección, sólo que todos los
objetos excepto el primero llevan la clave inverse, que hace que cambien de nombre su interior y su
interior. Es decir, que lo anterior también podría haberse escrito como:
intersection{
sphere { <0, 0, 0>, 1
translate -0.5*x
}
sphere { <0, 0, 0>, 1
translate 0.5*x
}
pigment { Red }
rotate 90*y
cylinder { <0, 0, -1> <0, 0, 1>, .35
inverse
pigment { Blue }
}
}
Bueno, hagamos algo mejor: declaremos nuestra lente perforada de forma que podamos ponerle un
nombre. Antes, habremos eliminado todas las texturas de su interior, ya que las utilizaremos en su
ubicación definitiva.
#declare Lens_With_Hole = difference {
intersection {
sphere { <0, 0, 0>, 1
translate -0.5*x
}
sphere { <0, 0, 0>, 1
translate 0.5*x
}
rotate 90*y
}
cylinder { <0, 0, -1> <0, 0, 1>, .35 }
}
Ahora usaremos una unión para construir una figura compuesta de copias de este objeto:
union {
object { Lens_With_Hole translate <-.65, .65, 0> }
object { Lens_With_Hole translate <.65, .65, 0> }
object { Lens_With_Hole translate <-.65, -.65, 0> }
object { Lens_With_Hole translate <.65, -.65, 0> }
pigment { Red }
}
Trazamos la escena. Un objeto interesante ¿no? Pero intentemos algo más. Hagamos las lentes
parcialmente transparentes añadiéndoles algo de filtro al pigmento de la unión:
union {
object { Lens_With_Hole translate <-.65, .65, 0> }
object { Lens_With_Hole translate <.65, .65, 0> }
object { Lens_With_Hole translate <-.65, -.65, 0> }
object { Lens_With_Hole translate <.65, -.65, 0> }
pigment { Red filter .5 }
}
Trazamos de nuevo la imagen. Está bien, salvo que... podemos ver trozos de los objetos lente dentro de
otros. Esto no está tan bien.

4.5.5. Fusión
Esto nos lleva al cuarto tipo de construcción CSG. la fusión. Es muy similar a la unión, salvo que las
superficies de los objetos que deben estar dentro de otro de la unión no se trazan, es decir, desaparecen.
Esto eliminará el problema al que hemos hecho alusión antes. Probémoslo:
4. TUTORIAL PARA PRINCIPIANTES 76

merge {
object { Lens_With_Hole translate <-.65, .65, 0> }
object { Lens_With_Hole translate <.65, .65, 0> }
object { Lens_With_Hole translate <-.65, -.65, 0> }
object { Lens_With_Hole translate <.65, -.65, 0> }
pigment { Red filter .5 }
}
¡Desde luego que lo hace!

4.5.6. Observaciones sobre los objetos CSG

Hay algunos detalles sobre los objetos CSG contra los que debemos de estar prevenidos.

4.5.6.1. Coincidencia de superficies

POV-Ray utiliza pruebas numéricas en cada punto para determinar si se encuentra en el interior o en el
exterior de un objeto. Un problema muy frecuente es que este punto se encuentre exactamente en la
superficie de dos objetos, ya que el error numérico puede situar el punto en el interior o en el exterior
de ambos objetos, y no hay manera numérica de saber con seguridad a que superficie pertenece con
exactitud, para darle una textura, o para determinar su invisibilidad (por ejemplo, si pertenece a una
fusión, o a la parte eliminada por una intersección).

Veamos qué sucede cuando usamos un cilindro para abrir un agujero en una caja más grande:
difference {
box { -1, 1 pigment { Red } }
cylinder { -z, z, 0.5 pigment { Green } }
}
Al trazarlo, veremos una nube de puntos rojos donde el agujero debería estar, provocados por la
coincidencia de la base del cilindro y el frontal de la caja. A veces, un rayo de luz impacta primero en la
superficie del cilindro, decidiendo que debe pasar a través de ella. En otras ocasiones, es alcanzada antes
la superficie de la caja, rebotando en ella. Esto produce un mal resultado, y causa la aparición de la nube
de puntos.

Este problema se puede remediar aumentando un poco la longitud del cilindro, evitando así la
coincidencia de superficies:
difference {
box { -1, 1 pigment { Red } }
cylinder { -1.001*z, 1.001*z, 0.5 pigment { Green } }
}
En general, debemos hacer el objeto que restamos algo más grande en una diferencia para evitar
coincidencias.

Un problema similar ocurre con las intersecciones (que, como hemos comentado, son muy similares a
las diferencias, con las fusiones (especialmente, ya que su objetivo es eliminar las superficies interiores,
y, cuando coinciden, ambas pueden ser consideradas interiores a la otra) e incluso, aunque con menos
frecuencia, con uniones en las que ambas superficies usan distinta textura. Habitualmente todos los
casos tienen una sencilla solución, que consiste en agrandar algo alguno de los objetos implicados.

4.6. Las fuentes de luz.

En cualquier escena de trazado de rayos, la luz necesaria para iluminar nuestros objetos y superficies
debe provenir de una fuente de luz. Hay muchos tipos de fuentes de luz disponibles en POV-Ray y el
PERSISTENCE OF VISION RAYTRACER 77

uso adecuado del tipo correcto puede dar lugar a resultados muy impresionantes. Tomémonos un
momento para explorar algunos de los diferentes tipos de fuentes de luz y sus diferentes parámetros.

4.6.1. La fuente de luz ambiente.

La fuente de luz ambiente es usada para simular el efecto de la reflexión interdifusa. Si no hubiera
reflexión interdifusa todas las áreas no iluminadas directamente por una fuente de luz serían
completamente oscuras. POV-Ray utiliza la palabra clave ambient para determinar que cantidad de luz
proveniente de la fuente de luz es reflejada por una superficie.

Por defecto la fuente de luz, la cual emite su luz en todas partes y en todas direcciones, y es blanca pura
(rgb <1, 1, 1>). El cambio de color puede ser utilizado para crear efectos interesantes. Lo primero de
todo el nivel de luz global de la escena puede ser ajustado fácilmente. En lugar de cambiar todos los
valores ambient en cada finish, sólo la fuente de luz ambiente es modificada. Asignando diferentes
colores nosotros podemos crear bonitos efectos como una caprichosa luz de ambiente rojiza. Para más
detalles sobre la fuente de luz ambiente véase "Luz de Ambiente".

He aquí un ejemplo de una fuente de luz ambiente roja.

global_settings { ambient_light rgb<1, 0, 0> }

4.6.2. La fuente de luz puntual.

Las luces puntuales son exactamente lo que su nombre indica. Un punto de luz no tiene tamaño, es
invisible e ilumina todo en la escena por igual independientemente de la distancia a la fuente de luz (este
comportamiento puede ser modificado). Esta es la forma más simple y básica de fuente de luz. Hay sólo
dos parámetros importantes, location y color. Diseñemos una escena simple y coloquemos una
fuente de luz puntual en ella.

Creamos un fichero nuevo con nombre LITEDEMO.POV. Lo editamos como sigue:

#include "colors.inc"
#include "textures.inc"

camera {
location <-4, 3, -9>
look_at <0, 0, 0>
angle 48
}
Añadimos los siguientes objetos simples:
plane { y, -1
texture {
pigment {
checker
color rgb<0.5, 0, 0>
color rgb<0, 0.5, 0.5>
}
finish {
diffuse 0.4
ambient 0.2
phong 1
phong_size 100
reflection 0.25
}
}
}

torus { 1.5, 0.5

4. TUTORIAL PARA PRINCIPIANTES 78

texture { Brown_Agate }
rotate <90, 160, 0>
translate <-1, 1, 3>
}

box { <-1, -1, -1>, <1, 1, 1>

texture { DMFLightOak }
translate <2, 0, 2.3>
}

cone { <0,1,0>, 0, <0,0,0>, 1

texture { PinkAlabaster }
scale <1, 3, 1>
translate <-2, -1, -1>
}

sphere { <0,0,0>,1
texture { Sapphire_Agate }
translate <1.5, 0, -2>
}
Ahora añadimos una fuente de luz puntual:
light_source {
<2, 10, -3>
color White
}
Trazamos esto a "200x150 -A" y vemos que los objetos son claramente visibles y con sombras
pronunciadas. Los lados de objetos curvados próximos a la fuente de luz son de color brillante y las
áreas que están en el lado opuesto a la fuente de luz son más oscuras. También apreciamos que el plano
ajedrezado está iluminado incluso en todo el horizonte. Esto nos permite ver el plano, pero no es muy
realista.

4.6.3. La fuente de luz cónica (focos).

Los focos son un tipo de fuente de luz muy útil. Pueden ser usados para añadir brillos y características
de iluminación del mismo modo que un fotógrafo utiliza los focos. Hay algunos parámetros más para
luces focales que para luces puntuales. Estos son radius, falloff, tightness y point_at. El
parámetro radius es el ángulo del cono completamente iluminado. El parámetro falloff es el
ángulo del cono de sombra donde la luz se desvanece hacia la oscuridad. El parámetro tightness
determina la proporción de la luz que se desvanece. El parámetro point_at es, como su nombre dice,
la posición hacia la que la fuente de luz está apuntando. Cambiemos la fuente de luz en nuestra escena
como sigue:
light_source {
<0, 10, -3>
color White
spotlight
radius 15
falloff 20
tightness 10
point_at <0, 0, 0>
}
Trazamos esto a "200x150 -A" y vemos que solamente los objetos están iluminados. El resto del plano
y las porciones exteriores de los objetos no están ahora iluminados. Hay una área amplia de
desvanecimiento pero las sombras son todavía muy marcadas. Intentemos jugar con alguno de estos
parámetros para ver qué ocurre. Modificamos el valor de falloff a 16 (debe ser siempre mayor que el
valor del radio) y trazamos de nuevo. Ahora el desvanecimiento es muy estrecho y los objetos están
iluminados brillantemente o en total oscuridad. Ahora volvemos a establecer el valor de falloff en 20
y cambiamos el valor de tightness a 100 (cuanto más alto más cerrado) y trazamos otra vez. La luz
PERSISTENCE OF VISION RAYTRACER 79

focal parece haberse hecho mucho más pequeña, pero lo que realmente ha sucedido es que el falloff
ha llegado a ser tan exagerado que el radio actual aparece mucho más pequeño.

Decidimos que un valor de tightness de 10 (el valor por defecto) y un valor de falloff de 18 son
los mejores para esta luz focal y ahora pondremos algunas luces más alrededor de la escena para
conseguir efectos. Coloquemos un foco azul ligeramente más estrecho y uno rojo además del blanco
que ya teníamos.
light_source {
<10, 10, -1>
color Red
spotlight
radius 12
falloff 14
tightness 10
point_at <2, 0, 0>
}

light_source {
<-12, 10, -1>
color Blue
spotlight
radius 12
falloff 14
tightness 10
point_at <-2, 0, 0>
}
Trazando esto veremos que la escena ahora tiene un aire maravillosamente misterioso. Las tres luces
focales convergen sobre los objetos haciéndolos azules en un lado y rojos en el otro, con suficiente
blanco en el medio para proporcionar un equilibrio.

4.6.4. La fuente de luz cilíndrica.

Las luces focales tiene forma de cono, lo que quiere decir que su efecto cambia con la distancia. Cuanto
más lejos de la fuente de luz está un objeto, más grande será el radio aparente. Pero podemos querer
que radius y falloff sean de un tamaño particular independientemente de la distancia a la luz focal.
Por esta razón, son necesarias las fuentes de luz cilíndricas. Una fuente de luz cilíndrica es
prácticamente como una luz focal, excepto por que las regiones de radius y falloff son las mismas,
independientemente de la distancia a la que se encuentra nuestro objeto de la fuente de luz. La forma es,
por tanto, un cilindro en lugar de un cono. Podemos especificar una fuente de luz cilíndrica
reemplazando la palabra reservada spotlight por cylinder. Probemos ahora esto en nuestra
escena reemplazando las tres luces focales por luces cilíndricas y tracemos de nuevo. Veremos que la
escena es más suavizada. Esto es debido a que las restricciones cilíndricas no permiten que la luz se
extienda como la de una luz focal. Son necesarios valores mayores de radius y falloff para hacer el
trabajo. Probemos un radius de 20 y un falloff de 30 para las tres luces.

4.6.5. La fuente de luz extendida.

Hasta aquí todas nuestras fuentes de luz han tenido una cosa en común: producían sombras
pronunciadas. Esto es debido a que la fuente de luz actual es un punto que es infinitamente pequeño.
Los objetos están o directamente expuestos a la luz, en cuyo caso están completamente iluminados, o
no lo están, en cuyo caso están completamente en la sombra. En la vida real, este tipo de situación con
sombra y luz extrema existe únicamente en el espacio exterior, donde la luz directa del sol penetra en la
oscuridad total del espacio. Pero aquí en la Tierra, la luz se curva alrededor de los objetos, rebota en
ellos y normalmente la fuente tiene alguna dimensión, lo que significa que puede estar parcialmente
oculta a la vista (las sombras ya no serán bruscas). Esto es conocido como penumbra, un área
4. TUTORIAL PARA PRINCIPIANTES 80

intermedia donde no hay ni luz total ni oscuridad. Para simular esta suave sombra, un trazador de rayos
debe dar a sus fuentes de luz dimensión. POV-Ray lleva a cabo esto con una característica conocida
como luz extendida3.

Las luces extendidas tienen dimensiones en dos ejes. Estos están especificados por los dos primeros
vectores en la sintaxis de superficie. Debemos también especificar cuántas luces hay en el array. Cuantas
más coloquemos, las sombras serán más suaves, pero nos llevará más tiempo de trazado. Normalmente
un array de 3x3 ó 5x5 será suficiente. También tenemos la posibilidad de especificar un valor de
adaptación. La palabra reservada adaptive le dice al trazador de rayos que puede adaptarse a la
situación y enviar sólo los rayos necesarios para determinar el valor del pixel. Si no se usa adaptive se
enviará un rayo por cada luz en la luz de superficie. Esto puede realmente ralentizar el proceso. Cuanto
más alto sea el valor de adaptive, más suave será la penumbra, pero más tiempo empleará el trazado.
Normalmente un valor adaptive de 1 es suficiente. Finalmente, es probable que debamos usar la
palabra reservada jitter. Ésta le dice al trazador que mueva ligeramente la posición de cada luz en la
fuente extendida, de forma que las sombras aparezcan realmente suaves en lugar de darnos una
penumbra formada por franjas de sombras cada vez más claras.

Probémoslo. Comentamos las luces cilíndricas y añadimos lo siguiente:

light_source {
<2, 10, -3>
color White
area_light <5, 0, 0>, <0, 0, 5>, 5, 5
adaptive 1
jitter
}
Esta es una luz de superficie blanca centrada en <2, 10, -3>. Tiene un tamaño de 5 unidades (a lo largo
del eje x) por 5 unidades (a lo largo del eje z) y tiene 25 (5x5) luces. Hemos especificado un valor
adaptive de 1 y jitter. Trazamos esto a 200x150 -A.

Después de hacer esto, apreciamos dos cosas. El trazado se hace un poco más largo que con una fuente
de luz puntual o focal y las sombras no son tan marcadas. Todo tiene una bonita y suave penumbra a su
alrededor. Pero esto se puede mejorar.

¡Las luces puntuales y cilíndricas pueden también ser luces extendidas! ¿Recuerdas esas sombras
marcadas originadas por las luces puntuales de nuestra escena? No tendría mucho sentido usar un array
de 5x5 para una luz puntual, pero un array más pequeño podría hacer un buen trabajo y
proporcionarnos la cantidad óptima de penumbra para una luz puntual. Probémoslo. Comentamos la
fuente extendida y modificamos las luces cilíndricas para que sean como las siguientes:
light_source {
<2, 10, -3>
color White
spotlight
radius 15
falloff 18
tightness 10
area_light <1, 0, 0>, <0, 0, 1>, 2, 2
adaptive 1
jitter
point_at <0, 0, 0>
}

light_source {

3 Son las “Area Lights” (N. de los T.)

PERSISTENCE OF VISION RAYTRACER 81

<10, 10, -1>

color Red
spotlight
radius 12
falloff 14
tightness 10
area_light <1, 0, 0>, <0, 0, 1>, 2, 2
adaptive 1
jitter
point_at <2, 0, 0>
}

light_source {
<-12, 10, -1>
color Blue
spotlight
radius 12
falloff 14
tightness 10
area_light <1, 0, 0>, <0, 0, 1>, 2, 2
adaptive 1
jitter
point_at <-2, 0, 0>
}
Ahora tenemos tres luces puntuales de superficie, de tamaño una unidad y con cuatro (2x2) luces, tres
colores diferentes, todas iluminando nuestra escena. Trazamos esto a 200x150 -A. Esto parece
funcionar perfectamente. Todas nuestras sombras tienen pequeñas bandas de penumbra, exactamente
como cabría esperar en un objeto iluminado con luz puntual real.

4.6.6. Asignando un objeto a una fuente de luz.

Las fuentes de luz son invisibles. Son sólo una posición desde donde la luz se emite. No tienen tamaño
real o forma. Si queremos que nuestra fuente de luz tenga una forma visible, podemos usar la palabra
clave looks_like. Podemos especificar que nuestra fuente de luz pueda parecerse a cualquier objeto
que elijamos. Cuando usamos looks_like, no_shadow se aplica automáticamente al objeto. Esto se
hace para evitar que el objeto bloquee cualquier iluminación proveniente de la fuente de luz. Si
queremos que ocurra un bloqueo (como en una lámpara apantallada), es más sencillo usar una unión.
Añadamos tales objetos a nuestra escena. Aquí tenemos una bombilla creada para este propósito:
#declare Lightbulb = union {
merge {
sphere { <0,0,0>,1 }
cylinder { <0,0,1>, <0,0,0>, 1
scale <0.35, 0.35, 1.0>
translate 0.5*z
}
texture {
pigment {color rgb <1, 1, 1>}
finish {ambient .8 diffuse .6}
}
}
cylinder { <0,0,1>, <0,0,0>, 1
scale <0.4, 0.4, 0.5>
texture { Brass_Texture }
translate 1.5*z
}
rotate -90*x
scale .5
}
Le añadimos la fuente de luz:
light_source {
4. TUTORIAL PARA PRINCIPIANTES 82

<0, 2, 0>
color White
looks_like { Lightbulb }
}
Trazando esto veremos que ahora una bonita bombilla con apariencia realista ilumina la escena. Sin
embargo, si no especificamos un valor alto de ambient la bombilla no estará iluminada por la fuente
de luz. Por otro lado, todas las sombras provienen de la bombilla como en una situación real. Las
sombras son marcadas, así que convirtamos nuestra bombilla en una luz extendida:
light_source {
<0, 2, 0>
color White
area_light <1, 0, 0>, <0, 1, 0>, 2, 2
adaptive 1
jitter
looks_like { Lightbulb }
}
Apreciamos que hemos colocado esta luz de superficie en el plano xy en lugar de en el plano xz.
También apreciamos que la apariencia real de la bombilla no se ve afectada en ningún modo por la
fuente de luz. La bombilla debe ser iluminada por alguna otra fuente de luz o, como en este caso,
proporcionar un valor alto de ambient. Se pueden obtener resultados más interesantes empleando
halos (véase sección "Halos").

4.6.7. Fuentes de luz especiales.

4.6.7.1. Empleando luces sin sombra.

A las fuentes de luz se les puede asignar la palabra clave shadowless y no serán arrojadas sombras
debidas a su presencia en la escena. Algunas veces, las escenas son difíciles de iluminar adecuadamente
empleando las luces que hemos elegido para iluminar nuestros objetos. No es práctico ni realista aplicar
un valor alto de ambient a la textura de todos los objetos de la escena. En su lugar podríamos colocar
un par de luces de relleno rodeando la escena. Las luces de relleno son simplemente luces de poca
intensidad, con la palabra reservada shadowless, que actúan para incrementar la iluminación de otras
áreas de la escena que pueden estar no muy bien iluminadas. Probémoslo usando una en nuestra escena.

¿Recuerdas las tres luces de color puntuales de superficie? Volvamos a ellas, quitémosles los
comentarios y comentemos el resto de las fuentes. Añadamos lo siguiente:
light_source {
<0, 20, 0>
color Gray50
shadowless
}
Ésta es una bonita luz de poca intensidad colocada 20 unidades sobre el centro de nuestra escena. Dará
una ligera iluminación a todos los objetos incluyendo el plano de la parte posterior. Tracemos y
veámosla.

4.6.7.2. Usando atenuación de la luz.

Si lo que queremos es realismo, no es muy realista que el plano esté completamente iluminado hasta el
horizonte. En la vida real, la luz se reparte a medida que se propaga de forma que disminuye su
capacidad de iluminar los objetos según van estando más alejados de la fuente. Para simular esto, POV-
Ray nos permite usar dos palabras clave: fade_distance, la cual nos permite especificar la distancia
hasta la cual se alcanza la iluminación plena, y fade_power, un valor exponencial que determina la
proporción real de atenuación. Apliquemos estas palabras reservadas a nuestra luz de relleno.
PERSISTENCE OF VISION RAYTRACER 83

Primero hagamos nuestra luz de relleno un poco más brillante cambiando Gray50 a Gray75. Ahora,
modifiquemos la luz de relleno como sigue:
light_source {
<0, 20, 0>
color Gray75
fade_distance 5
fade_power 1
shadowless
}
Esto significa que el valor completo de la luz de relleno alcanzará una distancia de 5 unidades desde la
fuente de luz. El valor 1 de fade_power quiere decir que la atenuación será lineal (la luz se desvanece
según un valor constante). Tracemos para ver el resultado.

¡Esto funciona! Probemos un valor de fade_power de 2 y un valor de fade_distance de 10.

Nuevamente esto funciona bien. La atenuación es mucho más rápida con un valor de fade_power de
2, así que incrementemos el valor de fade_distance hasta 10.

4.6.7.3. Las fuentes de luz y la atmósfera.

Por definición, más que por defecto, las fuentes de luz se ven afectadas por la atmósfera, por ejemplo,
su luz está siendo dispersada por la atmósfera. Esto puede ser desactivado añadiendo atmosphere
off a la fuente de luz. La luz emitida por una fuente de luz también puede ser atenuada por la
atmósfera (e incluso por la niebla), lo que significa que disminuirá a medida que se propaga por ella,
para lo cual añadimos atmospheric_attenuation on. La atenuación es exponencial y depende del
parámetro distance de la atmósfera (o niebla). Apreciamos que esto sólo afecta a la luz que proviene
directamente de una fuente de luz. La luz reflejada y refractada se ignora.

Experimentemos con estas palabras reservadas. Primero añadimos una atmósfera a nuestra escena:
#include "atmos.inc"
atmosphere { Atmosphere2 }
Comentemos las tres líneas que convierten cada una de las luces puntuales en luces de superficie. De
otro modo el trazado se hará muy largo.
//area_light <1, 0, 0>, <0, 0, 1>, 2, 2
//adaptive 1
//jitter
Generando esta escena a 200x150 -A veremos que realmente las luces puntuales son visibles. Veremos
cómo el haz rojo y el azul se entrecruzan y cómo la luz superior blanca ilumina la parte inferior
atravesando el centro de la escena. También apreciamos que las luces puntuales parecen disminuir su
intensidad a medida que la luz desciende desde la fuente de luz hacia los objetos. La luz roja inunda
todo excepto en la parte baja de la izquierda de la escena y la luz azul inunda todo excepto en la parte
baja de la derecha. Esto es debido a la atenuación atmosférica y añade más realismo a la escena. La
interacción entre atmósfera y fuente de luz da a nuestra escena una apariencia ahumada y misteriosa,
pero el trazado empleará más tiempo. Convirtiendo estas fuentes puntuales en luces de superficie
todavía empleará más tiempo. Este es el precio a pagar para obtener una imagen de calidad.

4.7. Opciones de textura simples

Las imágenes trazadas hasta ahora son aburridas en lo que respecta a la apariencia de los objetos.
Añadámosle algunos divertidos efectos a la textura.
4. TUTORIAL PARA PRINCIPIANTES 84

4.7.1. Acabado de superficies.

Una de las características principales de un trazador de rayos es su capacidad para hacer cosas
interesantes con el acabado de superficies, tales como brillos y reflexiones. Añadámosle un bonito y
pequeño brillo (punto brillante) a la esfera. Para hacer esto necesitamos añadir la palabra reservada
finish seguida por un parámetro. Cambiamos la definición de la esfera a esto:
sphere { <0, 1, 2>, 2
texture {
pigment { color Yellow } // Yellow está predefinido en colors.inc
finish { phong 1 }
}
}
Trazamos la escena. La palabra reservada phong añade un brillo del mismo color que la luz que ilumina
el objeto. Dota a la imagen de mayor credibilidad y hace que el objeto parezca más suave y brillante.
Valores menores de phong harán el brillo menos brillante (los valores deben encontrarse entre 0 y 1).

4.7.2. Añadiendo abolladuras.

Los brillos que hemos añadido ilustran como nuestra percepción depende de las propiedades reflexivas
de un objeto. El trazado de rayos puede explotar esto engañando a nuestra percepción para hacernos
ver detalles complejos donde realmente no los hay.

Supongamos que queremos una superficie muy abollada sobre un objeto. Sería muy difícil modelar
matemáticamente esa cantidad de abolladura. Podemos, sin embargo, simular las abolladuras alterando
la forma en que la luz se refleja en la superficie. Los cálculos de reflexión dependen de un vector
denominado normal a la superficie. Este es un vector que apunta hacia afuera de la superficie y es
perpendicular a ella. Modificando artificialmente (o perturbando) este vector normal, podemos simular
abolladuras. Cambiamos la escena a lo siguiente y la trazamos:
sphere { <0, 1, 2>, 2
texture {
pigment { color Yellow }
normal { bumps 0.4 scale 0.2 }
finish { phong 1}
}
}
Esto informa a POV-Ray de que use un patrón de abolladura para modificar la normal a la superficie.
El valor 0.4 controla la profundidad aparente de las abolladuras. Normalmente las abolladuras son de
aproximadamente una unidad de ancho, lo cual no parece encajar muy bien con una esfera de radio 2.
El escalado hace que las abolladuras tengan 1/5 de anchura, pero no afecta a su profundidad.

4.7.3. Creando patrones de colores.

Podemos hacer algo más que asignar colores sólidos a un objeto. Podemos crear patrones complejos en
el bloque pigment como en este ejemplo:
sphere { <0, 1, 2>, 2
texture {
pigment {
wood
color_map {
[0.0 color DarkTan]
[0.9 color DarkBrown]
[1.0 color VeryDarkBrown]
}
turbulence 0.05
scale <0.2, 0.3, 1>
PERSISTENCE OF VISION RAYTRACER 85

}
finish { phong 1 }
}
}
La palabra clave wood especifica un patrón de pigmento de anillos concéntricos como los anillos de la
madera. La palabra clave color_map especifica que el color de la madera debe mezclarse desde
DarkTan a DarkBrown en el primer 90% del veteado y de DarkBrown a VeryDarkBrown sobre el restante
10%. La palabra clave turbulence agita ligeramente el patrón de forma que el veteado no sean
círculos perfectos y la palabra clave scale ajusta el tamaño del patrón.

Muchos patrones nos vienen dados por defecto para ofrecernos esa característica alrededor de una
esfera de radio 1.0. Una característica se puede definir burdamente como una transición de color. Por
ejemplo, una textura de madera debería tener una banda sobre una esfera de radio 1.0. En este ejemplo
escalamos el patrón usando la palabra clave scale seguida por un vector. En este caso escalamos 0.2
en la dirección x, 0.3 en la dirección y, y 1 en la dirección z, lo cual lo deja inalterado. Valores de
escalado mayores que 1 extenderán un elemento. Valores de escalado menores que 1 encogerán un
elemento. Un valor de escalado de 1 dejará el elemento inalterado.

4.7.4. Texturas predefinidas.

POV-Ray tiene algunas texturas muy sofisticadas predefinidas en los ficheros de inclusión estándar:
GLASS.INC, METALS.INC, STONES.INC y WOODS.INC. Algunos son texturas completas con los parámetros
pigment, normal y/o finish ya definidos. Algunos son simplemente pigmentos o sólo acabados.
Cambiamos la definición de nuestra esfera a lo siguiente y trazamos:
sphere { <0, 1, 2>, 2
texture {
pigment {
DMFWood4 // predefinida en textures.inc
scale 4 // escalada la misma cantidad
// en todas las direcciones
}
finish { Shiny } // predefinida en finish.inc
}
}
El identificador de pigmento DMFWood4 ha sido ya reducido en escala suficientemente al ser definido.
Para este ejemplo queremos aumentar la escala del patrón. Como queremos escalarlo uniformemente
ponemos un valor simple después de la palabra clave scale en lugar de un vector con factor de
escalado x, y, z.

Miremos el fichero TEXTURES.INC para ver qué pigmentos y acabados están definidos y probémoslos.
Insertemos el nombre del nuevo pigmento donde está ahora DMFWood4 o probemos un acabado
diferente en lugar de Shiny y volvamos a trazar nuestro fichero.

Aquí tenemos un ejemplo de un uso de identificador de textura completo en lugar de sólo las piezas.
sphere { <0, 1, 2>, 2
texture { PinkAlabaster }
}

4.8. Opciones avanzadas de texturas

Las amplias posibilidades para elegir la textura de un objeto es lo que realmente aparta a POV-Ray de
otros programas trazadores de rayos. Hasta ahora no hemos intentado algo realmente complejo, pero
ahora, que nos hemos acostumbrado a la sintaxis del programa, podemos probar algunas de las
opciones más avanzadas de textura.
4. TUTORIAL PARA PRINCIPIANTES 86

Obviamente, no podemos probarlas todas. En ese caso, nuestro tutorial aún tendría más páginas. En
este tutorial sólo probaremos unas cuantas de las opciones, para proporcionar una muestra de lo que
puede crearse con POV-Ray. Con un poco de práctica, pronto podrá el lector crear sus propias texturas.

4.8.1. Patrones de pigmentación y de normal

Las versiones anteriores de POV-Ray distinguían entre patrones de color y patrones para la normal (es
decir, entre los patrones que podían ser usados en el apartado pigment y los que podían ser usados en
el apartado normal). En POV-Ray 3.0 se suprimió esta restricción, de forma que todos los patrones
listados como tales pueden ser usados como pigmentos o como normales.

4.8.2. Pigmentos
Todas las superficies deben tener un color. En POV-Ray este color se denomina pigmento. No tiene
porqué ser un color uniforme. Puede ser un patrón de color, uno de los tres dibujos permitidos o una
imagen extendida. Pueden colocarse diferentes capas de pigmentos, de forma que las superiores tengan
partes transparentes a través de las que se muestren las inferiores. Probemos algunas de las posibilidades
de este concepto.

Creamos un archivo llamado "TEXTDEMO.POV" y escribimos algo como lo siguiente:

#include "colors.inc"

camera {
location <1, 1, -7>
look_at 0
angle 36
}

light_source { <1000, 1000, -1000> White }

plane { y, -1.5
pigment { checker Green, White }
}

sphere { <0,0,0>, 1
pigment { Red }
}
Trazando esta imagen en una prueba a 200x150, vemos que se trata de una sencilla bola roja sobre un
suelo a cuadros blancos y verdes. Usaremos esta esfera para probar nuestras texturas.

4.8.2.1. Usando pigmentos con lista de colores

Ya hemos utilizado en los ejemplos previos este tipo de pigmentos, en el suelo a cuadros verdes y
blancos. Hay otros dos permitidos, hexágonos y ladrillos. Probemos ambos. En primer lugar
cambiaremos el pigmento del plano como sigue:
pigment { hexagon Green, White, Yellow }
Esto crea un patrón hexagonal sobre el plano con tres colores. Este patrón requiere escribir los tres
colores. Ahora cambiemos de nuevo el pigmento...
pigment { brick Gray75, Red rotate -90*x scale .25 }
Al mirar la imagen resultante, veremos que el plano tiene aspecto de estar construido con ladrillos rojos
unidos con un cemento gris claramente visible. Observa que hemos tenido que girar este patrón para
que aparezca en un plano horizontal, ya que habitualmente se usa directamente sobre superficies
verticales. Podemos jugar con estos patrones, cambiar los colores usados, etc.
PERSISTENCE OF VISION RAYTRACER 87

4.8.2.2. Usando pigmentos y patrones

Cambiemos ahora la textura de nuestra esfera, usando un patrón con mapa de colores, usando para ello
tres colores. Reemplazamos el bloque del pigmento con el siguiente:
pigment {
gradient x
color_map {
[0.00 color Red]
[0.33 color Blue]
[0.66 color Yellow]
[1.00 color Red]
}
}
Veremos que se forma un interesante patrón de líneas verticales. Si utilizamos la dirección y en lugar de
la x (junto a la palabra gradient), tendremos líneas horizontales. Cambiando a la dirección z, las
bandas de color parecerán anillos concéntricos. Esto sucede porque la dirección de la variación es la
misma en la que apunta la cámara. Volvemos a poner la dirección x y añadimos lo siguiente en el bloque
del pigmento.
pigment {
gradient x
color_map {
[0.00 color Red]
[0.33 color Blue]
[0.66 color Yellow]
[1.00 color Red]
}
rotate -45*z // <- añadimos esta línea
}
Ahora, las bandas verticales aparecen inclinadas 45 grados. Todos los patrones pueden ser girados,
escalados y trasladados de esta forma (sin desplazar la superficie sobre la que se aplican). Probemos
diferentes tipos de patrón. Sustituiremos sucesivamente la línea "gradient x" por la siguientes
palabras clave, y trazaremos para ver el resultado: bozo, marble, agate, granite, leopard,
spotted y wood (si quieres, puedes probar todos los patrones que aparecen en la sección "Patrones").

Veremos que cada uno de ellos da lugar a una disposición de los colores ligeramente diferente (bozo y
spotted puede que resulten idénticos). Pero para obtener buenos resultados, cada tipo de patrón
requiere el uso de algunos modificadores.

4.8.2.3. Usando modificadores de patrones

Echemos un vistazo a algunos de los modificadores de patrón. Primero, utilizaremos el patrón bozo,
añadiendo el siguiente cambio:
pigment {
bozo
frequency 3 // <- añadimos esta línea
color_map {
[0.00 color Red]
[0.33 color Blue]
[0.66 color Yellow]
[1.00 color Red]
}
rotate -45*z
}
El modificador frecuency determina el número de veces que se repiten los colores indicados en el
mapa de colores, que por defecto es 1. En este caso, vemos más bandas (el triple) en el patrón bozo de
las que había antes, aunque los colores que aparecen son los mismos.
4. TUTORIAL PARA PRINCIPIANTES 88

Cambiemos el patrón a marble. Al observarlo, veremos que es muy similar al gradient y, que no se
parece en absoluto al mármol, como parece sugerir su nombre. Situemos una frecuencia de 3
(frequency 3) y una turbulencia de 1 (turbulence 1) y probemos otra vez. Mucho mejor ¿no?
Prueba a cambiar el orden en el que sitúas la turbulencia y la frecuencia ¿qué sucede?

La turbulencia tiene de por sí unos modificadores específicos que nos permiten tener más control sobre
lo que hace. En primer lugar, el valor que sigue a la palabra turbulence puede tener decimales, e
indica lo "revuelta" que quedará la textura. Valores más altos hacen más caótico el resultado. En
segundo lugar, podemos usar los modificadores omega, lambda y octaves para cambiar los
parámetros internos de la turbulencia. Probemos esto ahora:
pigment {
marble
turbulence 0.5
lambda 1.5
omega 0.8
octaves 5
frequency 3
color_map {
[0.00 color Red]
[0.33 color Blue]
[0.66 color Yellow]
[1.00 color Red]
}
rotate 45*z
}
Trazar esto nos permitirá ver que la turbulencia ha cambiado, dando lugar a un patrón ligeramente
distinto. Podemos jugar con los valores de turbulence, lambda, omega y octaves para observar
lo que hacen.

4.8.2.4. Usando pigmentos transparentes y texturas superpuestas

Los colores se describen por valores numéricos que indican la proporción de rojo, verde y azul que los
componen (color rgb <1,0,0> nos proporciona el color rojo). Pero esta sintaxis nos permite usar
algo más que la composición rgb de un color. Podemos especificar transparencia (con filtro) escribiendo
rgbf <1,0,0,1>. La f representa filtro, y un valor de 1 supone que la superficie será totalmente
transparente, filtrando la luz según el color que tenga. En el caso del ejemplo, se comportará como
papel celofán rojo.

Hay otra clase de transparencia en POV-Ray. Se llama transmitancia o transparencia sin filtro. Su
palabra clave es transmit, y difiere de la anterior en que no filtra la luz de acuerdo con el color de la
superficie. Permite que la luz pase a través sin cambios. Puede especificarse como sigue: rgbt
<1,0,0,1>.

Usaremos ahora colores transparentes para crear otro tipo de texturas, las texturas superpuestas.
Volviendo a nuestro ejemplo anterior, declaramos la siguiente textura:
#declare LandArea = texture {
pigment {
agate
turbulence 1
lambda 1.5
omega .8
octaves 8
color_map {
[0.00 color rgb <.5, .25, .15>]
[0.33 color rgb <.1, .5, .4>]
[0.86 color rgb <.6, .3, .1>]
[1.00 color rgb <.5, .25, .15>]
PERSISTENCE OF VISION RAYTRACER 89

}
}
}
}
Esta será la textura del suelo. Ahora, crearemos lo océanos declarando lo siguiente:
#declare OceanArea = texture {
pigment {
bozo
turbulence .5
lambda 2
color_map {
[0.00, 0.33 color rgb <0, 0, 1>
color rgb <0, 0, 1>]
[0.33, 0.66 color rgbf <1, 1, 1, 1>
color rgbf <1, 1, 1, 1>]
[0.66, 1.00 color rgb <0, 0, 1>
color rgb <0, 0, 1>]
}
}
}
}
Observa que el área transparente permitirá ver la tierra, mientras que el azul opaco representará el
océano.

Ahora, declaremos otra textura que represente la atmósfera, con remolinos de nubes.
#declare CloudArea = texture {
pigment {
agate
turbulence 1
lambda 2
frequency 2
color_map {
[0.0 color rgbf <1, 1, 1, 1>]
[0.5 color rgbf <1, 1, 1, .35>]
[1.0 color rgbf <1, 1, 1, 1>]
}
}
}
Por fin, apliquemos estas texturas sobre nuestra esfera:
sphere { <0,0,0>, 1
texture { LandArea }
texture { OceanArea }
texture { CloudArea }
}
Trazando esto, veremos una reconstrucción bastante buena de un pequeño planeta. Pero la capa de
nubes no es muy realista. Hay formas de hacerlas mucho mejor.

4.8.2.5. Usando mapas de pigmentos

Los pigmentos pueden combinarse de la misma forma que los colores, usando los mismos patrones que
hemos visto. Intentémoslo.

Añadamos las siguientes declaraciones, delante de las anteriormente escritas:

#declare Clouds1 = pigment {
bozo
turbulence 1
color_map {
[0.0 color White filter 1]
4. TUTORIAL PARA PRINCIPIANTES 90

[0.5 color White]

[1.0 color White filter 1]
}
}
#declare Clouds2 = pigment {
agate
turbulence 1
color_map {
[0.0 color White filter 1]
[0.5 color White]
[1.0 color White filter 1]
}
}
#declare Clouds3 = pigment {
marble
turbulence 1
color_map {
[0.0 color White filter 1]
[0.5 color White]
[1.0 color White filter 1]
}
}
#declare Clouds4 = pigment {
granite
turbulence 1
color_map {
[0.0 color White filter 1]
[0.5 color White]
[1.0 color White filter 1]
}
}
Ahora usaremos estos pigmentos en la capa de nubes de nuestro planeta. Escribamos lo siguiente en
lugar de esta capa:
#declare CloudArea = texture {
pigment {
gradient y
pigment_map {
[0.00 Clouds1]
[0.25 Clouds2]
[0.50 Clouds3]
[0.75 Clouds4]
[1.00 Clouds1]
}
}
}
Observa que ahora aparecen en el planeta unas patrones muy similares a los de nuestro planeta, ya que
las nubes están separadas en bandas, cada una de las cuales tiene una estructura diferente, simulando
distintos climas a diferentes latitudes.

4.8.3. Normales
Los objetos de POV-Ray tienen superficies muy lisas. Esto no es muy real, de forma que hay varios
sistemas de distorsionar la superficie, modificando su normal. La normal es el vector perpendicular a
una superficie en un punto dado. La luz se refleja, o traspasa este objeto en función de esa normal, de
forma que alterarla significa que la superficie puede aparecer abollada, ondulada, arrugada, o modificada
de cualquiera de las formas disponibles. Probemos un puñado de ellas.
PERSISTENCE OF VISION RAYTRACER 91

4.8.3.1. Usando modificadores de normal básicos

De momento, marcaremos como comentario nuestro planeta en el archivo de prueba, y crearemos una
nueva esfera al final de éste con una sencilla textura de un solo color:
sphere { <0,0,0>, 1
pigment { Gray75 }
normal { bumps 1 scale .2 }
}
Hemos añadido un bloque normal, además del bloque pigmento (no ha de ser incluido en un bloque
textura, salvo que se desee modificar ambos simultáneamente, o que formen parte de una textura
superpuesta). Una vez que hayamos comprobado el aspecto que tiene, substituiremos la palabra bumps
por las siguientes: dents, wrinkles, ripples y waves (podemos usar cualquiera de los patrones
listados en la sección "Patrones"). Probaremos cómo queda cada uno de ellos. Podemos probar a
modificar el valor numérico (decimal) que sigue a la palabra clave. También podemos experimentar con
el valor de escala.

Como añadido interesante, cambiaremos la textura del suelo a un solo color con una normal como la
que sigue:
plane { y, -1.5
pigment { color rgb <.65, .45, .35> }
normal { dents .75 scale .25 }
}

4.8.3.2. Combinando normales

Las normales pueden superponerse, como los pigmentos, pero los resultados pueden ser inesperados.
Probemos a modificar la textura de la esfera como sigue:
sphere { <0,0,0>, 1
pigment { Gray75 }
normal { radial frequency 10 }
normal { gradient y scale .2 }
}
Como puedes ver, el patrón resultante no es radial o gradiente. Es el resultado de calcular el patrón
radial y después el patrón gradiente. El resultado se suma, por lo que el resultado es difícil de controlar.
El programa POV-Ray ofrece a sus usuarios otras formas de combinar las normales.

Una de las formas es usar mapas de normales. Un mapa de normales funciona igual que los mapas de
pigmentos usados con anterioridad. Cambiemos la textura de nuestra esfera de la siguiente forma:
sphere { <0,0,0>, 1
pigment { Gray75 }
normal {
gradient y
frequency 3
turbulence .5
normal_map {
[0.00 granite]
[0.25 spotted turbulence .35]
[0.50 marble turbulence .5]
[0.75 bozo turbulence .25]
[1.00 granite]
}
}
}
Al ver la imagen, observaremos que la esfera tiene una superficie con bultos muy irregular. El patrón
gradiente separa las normales en bandas, pero la turbulencia las ha agitado, dándole un aspecto caótico.
Pero esto nos da una idea.
4. TUTORIAL PARA PRINCIPIANTES 92

Podemos usar el mismo patrón para un mapa de normales que el que usamos para crear los océanos, de
forma que las zonas de tierra se vean rugosas, mientras que los océanos parezcan más lisos. ¿Quiere
esto decir que si aplicamos el mismo patrón con los mismos modificadores en una esfera del mismo
tamaño obtendremos la misma forma? Probémoslo. Primero, tracemos las dos esferas, de forma que
podremos ver que el patrón es realmente el mismo. Quitamos las señales de comentario a la primera
esfera y realizamos los siguientes cambios.
sphere { <0,0,0>, 1
texture { LandArea }
texture { OceanArea }
//texture { CloudArea } // <-lo convertimos en comentario
translate -x // <- añadimos esta transformación
}
Modificamos la esfera gris de la siguiente forma:
sphere { <0,0,0>, 1
pigment { Gray75 }
normal {
bozo
turbulence .5
lambda 2
normal_map {
[0.4 dents .15 scale .01]
[0.6 agate turbulence 1]
[1.0 dents .15 scale .01]
}
}
translate x // <- añadimos esta transformación
}
Ahora estamos seguros de que el patrón es el mismo. Ahora, marquemos como comentario la esfera
gris y añadamos el bloque de normales a la textura del suelo del otro planeta. Quitaremos la traslación
para que vuelva a quedar centrado.
#declare LandArea = texture {
pigment {
agate
turbulence 1
lambda 1.5
omega .8
octaves 8
color_map {
[0.00 color rgb <.5, .25, .15>]
[0.33 color rgb <.1, .5, .4>]
[0.86 color rgb <.6, .3, .1>]
[1.00 color rgb <.5, .25, .15>]
}
}
normal {
bozo
turbulence .5
lambda 2
normal_map {
[0.4 dents .15 scale .01]
[0.6 agate turbulence 1]
[1.0 dents .15 scale .01]
}
}
}
Mirando el resultado, nos haremos una idea de como funciona la idea. Las zonas terrestres están llenas
de bultos mientras que los océanos son lisos. Añadiendo de nuevo la capa de nubes, el planeta estará
completo.
PERSISTENCE OF VISION RAYTRACER 93

Por razones de espacio, hay muchas cosas que no hemos tratado. Por ejemplo, deberías experimentar
los llamados mapas de cuestas (slope maps), las medias (average) y mapas de bultos (bump maps).

4.8.4. Acabados
La parte final de una textura de POV-Ray es el acabado. Controla las propiedades de la superficie de un
objeto. Puede hacer que sea brillante y reflexivo o monótono y apagado. También puede especificar lo
que ocurre con la luz que pasa a través de pigmentos transparentes, con la que es dispersada debido a
superficies imperfectas y con la que es reflejada por superficies con delgadas películas que producen
interferencias. Hay doce propiedades diferentes disponibles en POV-Ray para especificar el acabado de
un objeto dado. Estas están controladas por los siguientes identificadores: ambient, diffuse,
brilliance, phong, specular, metallic, reflection, refraction, caustics,
attenuation, crand e iridiscence. Diseñemos un par de texturas que usen estos parámetros.

4.8.4.1. Usando ambient

Debido a que, en POV-Ray los objetos están iluminados por fuentes de luz, las porciones de estos
objetos que estén en la sombra serían completamente oscuras si no fuera por las dos primeras
propiedades del acabado, ambient y diffuse. Ambient se usa para simular la luz dispersada por
toda la escena que no viene directamente de ninguna fuente de luz. Diffuse determina que cantidad
de luz proviene de fuentes directas. Estos dos identificadores trabajan juntos para controlar la
simulación de luz ambiental. Usemos nuestra esfera gris para demostrar esto. Cambiemos también
nuestro plano a su diseño original de cuadros verdes y blancos.
plane {y,-1.5
pigment {checker Green, White}
}

sphere { <0,0,0>, 1
pigment {Gray75}
finish {
ambient .2
diffuse .6
}
}
En este ejemplo se usan los valores por defecto para ambient y diffuse. Trazamos para ver cuales
son los resultados y después hacemos el siguiente cambio al acabado.
ambient 0
diffuse 0
La esfera es negra debido a que hemos especificado que la luz no sea reflejada por ella. Cambiemos
ahora diffuse por su valor por defecto de 0.6.

Ahora vemos la superficie gris donde la luz de la fuente incide directamente sobre la esfera, pero el lado
sombreado sigue siendo absolutamente negro. Ahora cambiemos diffuse a 0.3 y ambient a 0.3.

La superficie de la esfera se ha vuelto ahora más monótona. Es debido a que hemos especificado un
alto grado de luz ambiental y solo una pequeña cantidad de la luz proveniente de la fuente de luz es
difusamente reflejada hacia la cámara. Los valores por defecto de ambient y diffuse son una media
bastante buena y un buen punto de partida. En la mayoría de los casos, un valor para ambient entre
0.1 y 0.2 es suficiente y un valor para diffuse entre 0.5 y 0.7 generalmente quedará bien. Hay un par
de excepciones. Si tenemos una superficie completamente transparente con unos altos valores de
refracción o reflexión, usar valores bajos para ambient y diffuse es lo mejor. He aquí un ejemplo.
sphere { <0,0,0>, 1
4. TUTORIAL PARA PRINCIPIANTES 94

pigment { White filter 1 }

finish {
ambient 0
diffuse 0
reflection .25
refraction 1
ior 1.33
specular 1
roughness .001
}
}
Obviamente la esfera es de cristal. El cristal es un material que toma casi toda su apariencia de lo que le
rodea. Poca parte de la superficie es vista debido a que transmite o refleja prácticamente toda la luz que
brilla sobre el. Ver GLASS.INC para más ejemplos.

Si alguna vez necesitamos que un objeto esté totalmente iluminado independientemente de las fuentes
de luz en una escena dada, podemos hacerlo artificialmente especificando un valor de 1 para ambient
y un valor de 0 para diffuse. Esto eliminará todo el sombreado y simplemente dará al objeto su color
en su forma más brillante en todos sus puntos. Esto es útil para simular objetos que emiten luz como
bombillas y para cielos en escenas donde el este no deba ser iluminado por ningún otro medio

Ahora intentemos esto con nuestra esfera.

sphere { <0,0,0>, 1
pigment { White }
finish {
ambient 1
diffuse 0
}
}
Nos da como resultado una esfera de un blanco cegador sin ningún punto de brillo ni partes
sombreadas. Podría servir, por ejemplo, para la luz de una farola.

4.8.4.2. Usando los reflejos de superficie

En el ejemplo anterior del cristal, nos dimos cuenta de que había pequeños puntos brillantes sobre la
superficie. Esto daba a la esfera una apariencia dura y brillante. POV-Ray nos proporciona dos métodos
para especificar los reflejos especulares sobre la superficie. El primero es el reflejo phong y se describe
mediante dos identificadores: phong y phong_size. El valor decimal que sigue a phong determina su
brillo y el que sigue a phong_size, su tamaño. Intentemos esto.
sphere { <0,0,0>, 1
pigment { Gray50 }
finish {
ambient .2
diffuse .6
phong .75
phong_size 25
}
}
Trazando esto vemos un reflejo amplio y atenuado que da a la esfera una apariencia semejante al
plástico. Ahora cambiemos phong_size a 150. Esto causa un reflejo más pequeño que da a la esfera
una apariencia más dura y brillante.

Hay otro tipo de reflejo, que es calculado usando un método distinto, llamado reflejo especular. Se
especifica usando el identificador specular y opera en conjunción con otro identificador llamado
roughness. En muchos aspectos, estos dos identificadores trabajan juntos del mismo modo que
PERSISTENCE OF VISION RAYTRACER 95

phong y phong_size para crear reflejos que alteren el aparente brillo de la superficie. Intentémoslo
ahora usando specular en nuestra esfera.
sphere { <0,0,0>, 1
pigment { Gray50 }
finish {
ambient .2
diffuse .6
specular .75
roughness .1
}
}
}
Observando los resultados vemos un amplio y atenuado reflejo similar al que teníamos cuando
usábamos phong_size 25. Cambiemos roughness a 0.001 y tracemos de nuevo. Ahora vemos un
pequeño y ceñido reflejo similar al que teníamos cuando usábamos phong_size 150. Hablando en
general. specular es ligeramente más preciso y por lo tanto ligeramente más realista que phong, pero
de todos modos deberías probar ambos métodos al diseñar una textura. Incluso hay veces en las que
ambos métodos pueden ser usados en un mismo acabado.

4.8.4.3. Usando reflection y metallic

Existe otro parámetro muy relacionado con los reflejos, reflection. Las superficies muy brillantes
normalmente tienen un cierto grado de reflexión. Echemos un vistazo a este ejemplo.
sphere { <0,0,0>, 1
pigment { Gray50 }
finish {
ambient .2
diffuse .6
specular .75
roughness .001
reflection .5
}
}
}
Vemos que ahora nuestra esfera refleja el plano a cuadros verdes y blancos y el fondo negro, pero el
color gris de la esfera parece fuera de lugar. Este es otro caso en el que se necesita un valor bajo para
diffuse. Generalmente, cuanto mayor sea la reflexión, menor deberá ser el valor de diffuse.
Bajamos el valor de diffuse a 0.3 y el valor de ambient a 0.1 y trazamos de nuevo. Ahora está
mucho mejor. Hagamos que nuestra esfera sea tan brillante como una pulimentada bola de oro.
sphere { <0,0,0>, 1
pigment { BrightGold }
finish {
ambient .1
diffuse .1
specular 1
roughness .001
reflection .75
}
}
}
El resultado es muy aproximado, pero hay algo que todavía esta mal en el reflejo. Para hacer que la
superficie tenga un aspecto más metálico se usa el identificador metallic. Lo añadimos para ver la
diferencia
sphere { <0,0,0>, 1
pigment { BrightGold }
finish {
ambient .1
4. TUTORIAL PARA PRINCIPIANTES 96

diffuse .1
specular 1
roughness .001
reflection .75
metallic
}
}
}
Vemos que el reflejo a tomado su color de la superficie en lugar de la fuente de luz. Esto da a la
superficie una apariencia más metálica.

4.8.4.4. Usando refraction

Los objetos transparentes permiten a la luz pasar a través de ellos. Con algunas sustancias, los rayos de
luz son desviados al pasar de una sustancia a otra debido a la diferencia de densidades ópticas entre los
objetos. A esto se le llama refracción. El agua y el cristal desvían la luz de esta forma. Para crear agua o
cristal, POV-Ray nos proporciona un método para especificar la refracción. Esto se consigue mediante
los identificadores refraction e ior. La cantidad de luz que pasa a través de un objeto se
determinan mediante el filtrado y la transmitancia en el pigmento. Deberíamos usar el valor de
refraction solo para activar o desactivar la refracción usando los valores 1 ó 0 respectivamente (o
los valores booleanos on y off). Ver la sección "Refracción" para una explicación detallada de las
razones.

El grado de refracción se especifica mediante el identificador ior, abreviación de index of refraction

(índice de refracción). Si conocemos el índice de refracción de la sustancia que estamos creando lo
podemos usar directamente. Como ejemplo el agua tiene un índice de 1.33, el cristal está alrededor de
1.45 y el diamante de 1.75. Volvamos al ejemplo de una esfera de cristal que usamos anteriormente.
sphere { <0,0,0>, 1
pigment { White filter 1 }
finish {
ambient 0
diffuse 0
reflection .25
refraction 1
ior 1.45
specular 1
roughness .001
}
}
}
Trazamos esto de nuevo y observamos como la porción del plano que es visible a través de la esfera es
distorsionado y vuelto de arriba a abajo. Esto es debido a que la luz que pasa a través de la esfera es
desviada o refractada según el grado especificado. Reducimos el valor de ior a 1.25 y trazamos de
nuevo. Después lo incrementamos a 1.75. Podemos observar como cambia la distorsión.

4.8.4.5. Añadiendo la atenuación luminosa

Los objetos transparentes pueden estar hechos de forma que la intensidad de la luz que pasa a través de
ellos sea reducida. En la realidad, esto es debido a impurezas que dispersan los rayos de luz. Dos valores
decimales determinan este efecto: fade_distance es la distancia hasta la cual deben llegar los rayos
de luz para alcanzar la mitad de su intensidad original y fade_power es el grado según el cual
disminuye esa intensidad. Veamos un ejemplo de esto.
sphere { <0,0,0>, 1
pigment { White filter 1 }
finish {
PERSISTENCE OF VISION RAYTRACER 97

ambient .1
diffuse .1
reflection .15
refraction 1
ior 1.45
specular 1
roughness .001
fade_distance 5
fade_power 1
}
}
Esto da a la esfera un aspecto nublado, como si no toda la luz fuera capaz de pasar a través de ella. Para
variaciones interesantes de esta textura, bajemos el valor de ior a 1.15 y subamos el de reflection a
0.5.

4.8.4.6. Usando cáusticas simuladas

4.8.4.6.1. ¿Qué es la cáustica?

Primero, hagamos una incursión en la alacena de la cocina. Estamos buscando vasos de cristal. Si tienen
una superficie decorada, mucho mejor. Uno a uno los colocamos debajo de una lámpara y observamos
la sombra que proyectan sobre la mesa. Si observamos de cerca distinguiremos regiones brillantes entre
las sombras. Estos serán los lugares donde las propiedades refractivas de los vasos de cristal están
concentrando la suficiente luz como para formar puntos brillantes. Si hay un diseño tallado sobre la
superficie del cristal veremos ese diseño formado por las áreas brillantes. Estas regiones son la cáustica
causada por la refracción, la cáustica refractiva. Habrá también regiones brillantes causadas por la luz
reflejada por el cristal. A esto se le llama cáustica reflexiva.

Una vez sabemos lo que estamos buscando, seremos capaces de observar la cáustica en muchas
situaciones cotidianas: la sombra proyectada por una lupa, la luz que atraviesa una pecera, a través de un
trozo arrugado de celofán, etc. Podremos verla incluso en el fondo de una piscina en un día soleado. La
cáustica es un sutil efecto luminoso que puede dar realismo a las imágenes trazadas con objetos que lo
usen.

POV-Ray usa algoritmos que simulan la cáustica refractiva (la cáustica reflexiva no es posible). Existen
limitaciones inherentes al proceso estándar de trazado de rayos en general que la hacen inadecuada para
algunas aplicaciones de la simulación de la luz, tales como testeo óptico y muy pocos y particulares
casos de proyectos arquitectónicos de iluminación. Los métodos que llevan a cabo cálculos más
extensos necesarios para realizar simulaciones completas del comportamiento de la luz, incluyendo la
cáustica (como el path-tracing, el photon-tracing o el ray-tracing bidireccional) son muy lentos y poco prácticos
en plataformas normales.

Esto significa que nos tenemos que arreglar con la cáustica para obtener el mejor resultado posible,
pero con un poco de experimentación, veremos que podemos emular de forma muy cercana la realidad.
La mejor forma de hacerlo es, cuando sea posible, estudiando antes un ejemplo de lo que estamos
intentando trazar. Tenemos que conocer el diseño de su cáustica y ajustar entonces nuestra imagen final
hasta que estemos satisfechos.

4.8.4.6.2. Aplicando la cáustica a una escena

La cáustica es una nueva propiedad de la textura en el área de los acabados. La aplicamos a las sombras
de un objeto transparente y refractivo añadiendo el identificador caustics al acabado. Para empezar,
probamos el siguiente ejemplo (ver fichero CAUSTIC1.POV).
4. TUTORIAL PARA PRINCIPIANTES 98

#include "colors.inc"
#include "textures.inc"

camera {
location <0, 15, -40>
look_at <-2, 0, 1>
angle 10
}

light_source { <10, 20, 10> color White }

// crear un aburrido suelo para ver la sombra proyectada contra el

plane { y, 0
pigment { Grey }
}
// he aquí algo para aplicar la cáustica sobre ello

sphere { <0, 3, 0>, 2

texture {
Glass3
finish { caustics .6 }
}
}

Figura 25: La cáustica de una esfera translúcida

Cuando tracemos esto veremos nuestra esfera en la esquina superior derecha de la imagen, flotando a
escasa distancia del plano y la sombra que proyecta se extiende sobre la parte central de la escena. Y allí,
en el centro hay una cáustica básica. Esa área brillante en el centro representa la luz que normalmente la
refracción concentraría en medio de la sombra.

La única cuestión que esto desprende es: ¿qué pasa con el valor decimal que sigue al identificador
caustics? Bien, aquí es donde aparece nuestra discusión sobre como ajustar la cáustica. ¿Recuerdas
los vasos de cristal? Si tuviéramos uno de paredes delgadas y una base gruesa veríamos lo que queremos
decir en la sombra que proyectaría. En la parte superior, con las paredes delgadas (con menor
refracción) la cáustica es menos pronunciada y más difundida entre la sombra, pero cuando llegamos a
la parte de la sombra proyectada por la base más gruesa y refractiva, de repente la cáustica se vuelve más
pronunciada y más enfocada cerca del centro.

Por supuesto, ya que la cáustica es simulada, no hay correspondencia entre el grado en que la cáustica es
enfocada o difuminada y la forma, tamaño o refractividad del objeto. Sin embargo, podemos controlarla
PERSISTENCE OF VISION RAYTRACER 99

manualmente con el valor decimal que sigue al identificador caustics. Cuanto más se acerca este
valor a cero, más difusa y tenue será la cáustica, mientras que cuanto más cerca este de 1, más enfocada
y pronunciada será esta. Con el valor 1 tenemos la cáustica de una gruesa y altamente refractiva pieza de
cristal, mientras que con el valor 0.1, parece más bien una esfera de cristal vacía. Trazamos de nuevo la
escena anterior con una rango de valores entre 0.1 y 1.0 y vamos viendo las diferentes cáusticas que
tenemos.

Los valores fuera de rango también funcionan. Los números mayores que 1 nos llevan a cáusticas cada
vez más enfocadas. Los números negativos producen efectos extraños pero interesantes. Esencialmente,
el objeto se ilumina de formas extravagantes y la sombra parece más bien un negativo fotográfico de si
misma. Parecido a los efectos de las pistolas de rayos de ciencia ficción de los años 50. Tiene una
apariencia extraña y no del todo foto-realísta, pero si nos gusta el surrealismo podemos querer probarlo
al menos una vez y anotar el efecto que produce sobre nuestra mente en caso de que alguna vez lo
necesitemos.

4.8.4.6.3. Cáustica y normales

POV-Ray hace el uso de la perturbación de la normal de una superficie de una forma más especial que
la que la gente se pararía a pensar. Cuando aplicamos la normal de una superficie en una textura,
estamos no solo alterando la superficie si no, además diciendo a POV-Ray que trate a la superficie
como si esta hubiera sido alterada, por motivos del computo de la iluminación que cae sobre cada
punto individual. En pocas palabras, se trata de un truco de luces y sombras que, suponiendo que no lo
observamos desde un ángulo demasiado agudo, efectivamente crea la ilusión de distorsiones sobre la
superficie del objeto.

Las cáustica es también un truco artificial, como vimos antes y se puede tener por seguro, que ha sido
diseñada para reaccionar sobre los diseños de la normal de la superficie para hacer que estos parezcan
genuinos. ¿Recuerdas el experimento del vaso de agua? Si encontramos un vaso con diseños tallados
sobre su superficie probablemente veremos esos diseños resaltados en la cáustica proyectada por el
cristal. Cuando tenemos una superficie transparente con una normal aplicada, esta hace que la cáustica
proyectada por esa superficie imite el diseño de la normal, de forma que aparezca en la sombra.

A continuación hay un ejemplo de lo que queremos decir: está pensado para representar el agua en una
piscina. Lo conseguimos mediante un plano superior para el agua, otro inferior que representa el suelo
de la piscina, una cámara justo debajo de la superficie, mirando al suelo y una fuente de luz situada a
bastante altura. (ver CAUSTIC2.POV).
#include "colors.inc"

// Nuestra cámara esta bajo agua, mirando al fondo de

// la piscina para una mejor visión de la cáustica producida

camera {
location <0, -5, 0>
look_at <0, -10, -5>
}

light_source { <0, 100, 49.5> color White }

// el fondo de la piscina...

plane { y, -10
texture {
pigment { color rgb <0.6, 0.7, 0.7> }
finish { ambient 0.1 diffuse 0.7 }
scale 0.01
}
4. TUTORIAL PARA PRINCIPIANTES 100

// y la superficie del agua

plane { y, 0
texture {
pigment { rgbf <0.6, 0.67, 0.72, 0.9> }
normal {
bumps .6
scale <.75, .25, .25>
rotate <0, 45, 0>
}
finish { caustics .9 }
}
}

Figura 26: La cáustica en una piscina

Las ondulaciones que le hemos dado al plano del agua están pensadas para representar las pequeñas y
aleatorias crestas que se forman sobre una piscina cuando una ligera brisa sopla sobre ella. Podríamos
haber usado ripples o waves también, como si algo se hubiera zambullido en ella en algún punto,
pero bumps será suficiente para un ejemplo.

Observamos que nuestra vista del suelo de la piscina muestra docenas de pequeñas cáusticas,
correspondientes a un diseño de ondulaciones aleatorias. Si queremos podemos usar ripples o
waves y ver como cambia el diseño de la cáustica. A pesar de que un plano liso no produciría cáustica
por si mismo (podemos intentarlo sin la normal), la generación simulada de cáustica de POV-Ray sabe
que si la superficie fuera realmente abultada como esta normal está indicando, la refracción de esta sería
suficiente para concentrar la luz en cáusticas por todo el suelo de la piscina.

Vemos que al igual que con una superficie curva, como la anterior esfera, el diseño de la normal
también afecta a las cáusticas proyectadas por un objeto. Lo curioso del caso es que esto sería la prueba
de que la cáustica es simulada: a nuestra agua no se le ha dado ninguna propiedad de refracción en su
acabado, pero la cáustica está allí.

4.8.4.7. Usando la iridiscencia

La iridiscencia es lo que vemos en la superficie de una mancha de petróleo cuando el sol brilla sobre
ella. El efecto de arco iris es creado por algo llamado interferencia de películas delgadas (ver sección
("Iridiscencia" para detalles). Por ahora simplemente intentemos usarla. La iridiscencia se especifica
PERSISTENCE OF VISION RAYTRACER 101

mediante el identificador irid y tres valores: cantidad, anchura y turbulencia. La cantidad es la

contribución al color de la superficie. Usualmente de 0.1 a 0.5 es suficiente. La anchura, precedida del
identificador thickness, afecta a la magnitud del efecto. Manténla entre 0.25 y 1 para mejores
resultados. La turbulencia, precedida del identificador turbulence, es un poco diferente a la
turbulencia del pigmento o la normal. No podemos definir octavas, lambda u omega pero podemos
especificar una cantidad que afectará al grosor de una forma ligeramente distinta al valor de
thickness. Aquí también funcionan mejor los valores entre 0.25 y 1. Finalmente, la iridiscencia
responderá a la normal de la superficie ya que depende del ángulo de incidencia de los rayos de luz
sobre la superficie. Con todo esto en mente, añadamos algo de iridiscencia a nuestra esfera de cristal.
sphere { <0,0,0>, 1
pigment { White filter 1 }
finish {
ambient .1
diffuse .1
reflection .2
refraction 1
ior 1.5
specular 1
roughness .001
fade_distance 5
fade_power 1
caustics 1
irid {
0.35
thickness .5
turbulence .5
}
}
}
Variemos los valores de la cantidad, thickness y turbulence para ver que cambios tienen lugar.
Añadamos también un bloque de declaración de la normal para ver que pasa.

4.8.5. Halos
Nota importante: el halo es una característica experimental de POV-Ray 3.0. Hay una alta probabilidad
de que el diseño e implementación de estas características cambie en futuras versiones. No podemos
garantizar que las escenas que las usen den los mismos resultados en futuras versiones o que se
mantenga la compatibilidad de la sintaxis del lenguaje.

Los halos son una poderosa característica que puede ser usada para crear gran cantidad de efectos
distintos como nubes, niebla, fuego, láseres, etc. El nombre se debe a la posibilidad de trazar halos,
como los que se ven alrededor de la luna o del sol.

Debido a la complejidad del halo y de la gran cantidad de parámetros proporcionados es muy difícil
conseguir resultados satisfactorios. Las siguientes secciones ayudarán a crear un halo paso a paso,
empezando por lo más básico hasta llegar a los conceptos más sutiles.

Es también aconsejable leer las secciones de referencia para un mejor entendimiento de las
características de los halos. En especial las secciones "Objetos Vacíos y Objetos Sólidos" y "Mapeado
del Halo" debido a que son esenciales para entender los halos.

4.8.5.1. ¿Qué son los halos?

Los halos son una característica de las texturas que nos permiten rellenar con partículas el interior de un
objeto. La distribución de estas partículas puede ser modificada usando distintos mapeados y funciones
4. TUTORIAL PARA PRINCIPIANTES 102

de densidad. Las partículas pueden emitir luz, para crear efectos de fuego o láseres, o absorberla para
crear nubes o niebla.

Un halo esta vinculado a un objeto, llamado objeto contenedor, al igual que un pigmento, una normal o
un acabado. El objeto contenedor esta completamente rellenado con el halo, pero no podremos ver
nada si no nos aseguramos de que el objeto es vacío y su superficie translúcida. Como se consigue esto
lo veremos en la siguiente sección.

Cuando trabajemos con los halos siempre tendremos que tener en cuenta que el objeto contenedor
tiene que ser vacío y translúcido.

4.8.5.2. El halo emisor

Empezamos con uno de los tipos más simples, el halo emisor. Usa partículas que solo emiten luz. No
hay partículas que absorban la luz proveniente de otras partículas o de las fuentes de luz.

4.8.5.2.1. Empezando con un halo básico

Una forma inteligente de conseguir un halo bien diseñado es empezar con una figura simple, de tamaño
unitario que repose sobre el origen de coordenadas.

En el primer ejemplo (HALO01.POV) intentamos crear una salvaje explosión, en la cual la esfera es el
objeto más adecuado. Empezamos con una simple escena que consiste de una cámara, una fuente de
luz (no nos preocupan las sombras así que añadimos el identificador shadowless), un plano a cuadros y
una esfera unitaria que contiene el halo.
camera {
location <0, 0, -2.5>
look_at <0, 0, 0>
}

light_source { <10, 10, -10> color rgb 1 shadowless }

plane { z, 2
pigment { checker color rgb 0, color rgb 1 }
finish { ambient 1 diffuse 0 }
scale 0.5
hollow
}

sphere { 0, 1
pigment { color rgbt <1, 1, 1, 1> }
halo {
emitting
spherical_mapping
linear
color_map {
[ 0 color rgbt <1, 0, 0, 1> ]
[ 1 color rgbt <1, 1, 0, 0> ]
}
samples 10
}
hollow
}
Observamos que la esfera está declarada como vacía (mediante el identificador hollow) y tiene una
superficie translúcida (el canal de transmitancia en el color de pigmento es 1), tal como es requerido
para los halos. También notamos que el plano tiene el identificador hollow a pesar de que no tiene
halo. ¿Por qué es necesario esto?
PERSISTENCE OF VISION RAYTRACER 103

La razón es bastante simple. Tal como se describe en la sección "Objetos Vacíos y Objetos Sólidos" no
puede haber un halo en un objeto no vacío. Ya que la cámara está dentro del plano, es decir, está en la
región considerada como interior del plano, el halo nunca será visto a no ser que el plano sea declarado
como vacío (o el identificador negative sea añadido para situar la cámara en la parte exterior del
plano).

¿Que significan todos esos identificadores y valores en el halo? Al principio de la declaración se usa el
identificador emitting para especificar que tipo de halo queremos usar. El halo emisor emite luz. Eso
es lo más adecuado para nuestra salvaje explosión.

Los identificadores spherical_mapping y linear necesitan una explicación más detallada de cono
funciona un halo (esto también es llevado a cabo en el capítulo "Halo" en más detalle).

Como se ha dicho anteriormente el halo está formado de una gran cantidad de pequeñas partículas. La
distribución de estas partículas es descrita por una función de densidad. En general, una función de
densidad nos dirá que cantidad de partículas encontraremos en una posición dada.

En lugar de usar una función matemática explícita de densidad, los halos se basan en un determinado
número de mapeados y funciones de densidad para modelar una variedad de distribuciones de
partículas.

El primer paso en este modelado es determinar la función de mapeado que será usada para asignar a
cada punto tridimensional un valor perteneciente a un rango unidimensional. En nuestro ejemplo
hemos usado un mapeado esférico, es decir, tomamos la distancia de un punto desde el origen del
sistema de coordenadas. Esa es la razón por la que es recomendable empezar con un objeto contenedor
situado en el origen del sistema de coordenadas. Ya que todos los mapeados de densidad son relativos a
este origen, no veremos nada si empezamos con un objeto situado en cualquier otro lugar. La forma
correcta de situar un objeto contenedor es mover todo el objeto (incluyendo texturas y halos).

Ahora tenemos un solo valor comprendido en un rango que va de 0 a 1. Este valor será transformado
usando una función de densidad para obtener esta a partir de la distancia. Usar solo este valor no es
suficiente debido a que queremos tener una distribución de partículas en la densidad descienda según
nos movemos desde el centro del objeto contenedor al exterior.

Esto se consigue mediante la función de densidad. Existen varias alternativas disponibles tal como se
describe en la referencia del halo (ver sección "Función de densidad"). Usamos una simple función
lineal que transforma los valores de rango de 0 a 1 a un rango de 1 a 0. De esta forma tenemos un valor
de 1 en el centro de nuestra esfera y de 0 en la superficie.

Ahora que tenemos una función de densidad, ¿qué hacemos para que se vea algo? Aquí es donde el
identificador color_map entra en juego. Se usa para describir un mapa de color que indicará al
programa que color debe ser usado para cada densidad. La relación es bastante simple: los colores al
principio del mapa de color (valores bajos) serán usados para valores bajos de densidad y los colores al
final del mapa (valores altos) serán usados para densidades altas. En nuestro ejemplo el halo será
amarillo en el centro de la esfera, donde la densidad es mayor y se irá transformando en rojo hasta llegar
a la superficie de la esfera donde la densidad se aproxima a cero.

El canal de transmitancia de los colores en el mapa de color sirve para modelar la translucidez del
campo de densidad. Un valor de 0 representa translucidez nula, es decir, que las áreas con la
correspondiente densidad serán (casi completamente) opacas, mientras que un valor de 1 significa (casi
completamente) translúcido.
4. TUTORIAL PARA PRINCIPIANTES 104

En nuestro ejemplo usamos

color_map {
[ 0 color rgbt <1, 0, 0, 1> ]
[ 1 color rgbt <1, 1, 0, 0> ]
}
que resulta en un halo con una rojiza y muy translúcida área exterior y una casi opaca zona interior de
color amarillo tal como podemos ver después de trazar la imagen de ejemplo.

Figura 27: El halo básico usado para modelar una salvaje

explosión

Hay un parámetro que todavía necesita ser explicado: el identificador samples. Este identificador le
dice a POV-Ray cuantas muestras deben ser tomadas a lo largo de cualquier rayo que viaje a través del
halo para calcular su efecto. El uso de un valor bajo resultará en una alta velocidad de trazado y
viceversa. El valor de samples debe ser incrementado si el halo tiene una apariencia incorrecta debido a
la baja tasa de muestreo. Para más detalles ver "Muestreo del Halo".

4.8.5.2.2. Incrementando el brillo

Los colores del halo en la imagen anterior son algo tenues. El fondo es demasiado visible a través del
halo. No se parece demasiado al fuego, ¿verdad? Una forma fácil de arreglar esto es decrementar la
transparencia de las partículas en las áreas de alta densidad. Lo conseguimos usando el siguiente mapa
de color en lugar del anterior (la transmitancia negativa es correcta).
color_map {
[ 0 color rgbt <1, 0, 0, 1> ]
[ 1 color rgbt <1, 1, 0, -1> ]
}
Observando los resultados en HALO02.POV vemos que el halo es efectivamente más brillante.
PERSISTENCE OF VISION RAYTRACER 105

Figura 28: El halo es más brillante ahora

4.8.5.2.3. Añadiendo algo de turbulencia

Lo que tenemos ahora tampoco parece una salvaje explosión. Se parece más a una bola brillante que a
cualquier otra cosa. De alguna forma tenemos que hacer que parezca más caótica, tenemos que añadir
algo de turbulencia.

Esto se consigue usando el identificador turbulence junto con la cantidad de turbulencia que queremos
añadir. Tal como se muestra en el siguiente ejemplo.
sphere { 0, 1
pigment { color rgbt <1, 1, 1, 1> }
halo {
emitting
spherical_mapping
linear
turbulence 1.5
color_map {
[ 0 color rgbt <1, 0, 0, 1> ]
[ 1 color rgbt <1, 1, 0, -1> ]
}
samples 10
}
hollow
}
Añadir turbulencia al halo provoca que todos los puntos en el interior del objeto contenedor se muevan
de forma pseudo-aleatoria. El resultado es un cambio en la distribución de partículas como si se hubiera
producido un flujo o corriente en el interior del halo (dependiendo de la cantidad indicada que sigue al
identificador turbulence tendremos un flujo más uniforme o más turbulento). En este ejemplo usamos
un valor alto, ya que una explosión es altamente turbulenta.

Observando la imagen de ejemplo (HALO03.POV) vemos que se parece más a una salvaje explosión que a
la bola brillante que teníamos hasta ahora.
4. TUTORIAL PARA PRINCIPIANTES 106

Figura 29: Añadir algo de turbulencia hace que la explosión sea

más realista

Nos damos cuenta que el tiempo que tarda en ser trazada la imagen se ha incrementado al añadir la
turbulencia. Esto es debido al hecho de que por cada una de las muestras tomadas del halo, la lenta
función de turbulencia tiene que ser evaluada.

4.8.5.2.4. Reescalando el halo

Todavía hay algo extraño en nuestra salvaje explosión. Sigue pareciendo una esfera. ¿Por qué ocurre
esto? y ¿qué podemos hacer para evitarlo?

Tal como se dijo antes, la turbulencia mueve las partículas en el interior del objeto contenedor del halo.
El problema es que algunas de estas partículas son desplazadas fuera del objeto contenedor. Esto lleva a
altas densidades en la superficie del objeto revelando su forma (todas las partículas fuera del objeto
contenedor se pierden y no serán visibles resultando en un abrupto cambio de densidad en la
superficie).

Una forma fácil de evitar esto es asegurarnos de que las partículas permanecen en el interior del objeto
contenedor incluso si añadimos turbulencia. Esto se consigue escalando el halo para reducir su tamaño.
No escalamos el objeto contenedor, solo el halo.

Incluimos el identificador scale dentro de la declaración del halo.

sphere { 0, 1
pigment { color rgbt <1, 1, 1, 1> }
halo {
emitting
spherical_mapping
linear
turbulence 1.5
color_map {
[ 0 color rgbt <1, 0, 0, 1> ]
[ 1 color rgbt <1, 1, 0, -1> ]
}
samples 10
scale 0.5
}
hollow
scale 1.5
PERSISTENCE OF VISION RAYTRACER 107

}
El comando scale 0.5 indica a POV-Ray que escale todos los puntos dentro del halo por esta
cantidad. Esto efectivamente escala el radio que tenemos después del mapeado de densidad a un rango
de 0 a 0.5 en lugar de 0 a 1 (sin turbulencia). Si añadimos la turbulencia los puntos pueden moverse
media unidad en cualquier dirección sin abandonar el objeto contenedor. Esto es exactamente lo que
queremos.

Para compensar el menor tamaño del halo escalamos la esfera (y el halo interior) por 1.5.

Observando la nueva imagen de ejemplo (HALO04.POV) no veremos ni rastro de la esfera contenedora.

Finalmente tenemos una bonita explosión.

Figura 30: Reescalando el halo mejoramos su apariencia

La cantidad por la cual debemos escalar el halo depende de la cantidad de turbulencia que usemos. A
más turbulencia, menor deberá ser el halo. He aquí algo con lo que experimentar.

Otra forma de evitar que los puntos abandonen la esfera es que esta sea más grande, es decir, una esfera
con un radio mayor que uno. Es importante reescalar la esfera antes de añadir el halo debido a que de
otra forma el halo sería también escalado.

Notemos que esto solo funciona para el mapeado esférico y de caja (y una función de densidad no
constante). Todos los demás tipos de mapeado son (parcialmente) infinitos, es decir, la distribución de
partículas resultante cubre un espacio infinito (ver también "Mapeado del Halo").

4.8.5.2.5. Usando frequency para mejorar el realismo

Otra forma muy efectiva de mejorar el realismo de nuestra explosión es usar un valor de frecuencia
distinto de uno. La forma en que funciona frequency se explica en "El Modificador de Frecuencia"
en la parte de referencia.

La explicación, más bien matemática, usada aquí no ayuda mucho en entender como se utiliza esta
característica. Aunque es bastante simple. El valor de frecuencia solo le indica al programa cuantas
veces se tiene que repetir el mapa de color en el rango de densidad de 0 a 1. Si se tiene una frecuencia
de uno (el valor por defecto) se especifica que el mapa de color solo será visible una vez en el campo de
4. TUTORIAL PARA PRINCIPIANTES 108

densidad, es decir, el color en 0 será usado para densidad 0, el color en 0.5 para densidad 0.5 y el color
en 1 para densidad 1. Simple, ¿verdad?.

Si elegimos una frecuencia de dos, el color en 0 será usado para densidad 0, el color en 0.5 será usado
para densidad 0.25 y el color en 1 será usado para densidad 0.5. ¿Qué pasa para densidades superiores a
0.5? Ya que no hay entradas en el mapa de color para valor superiores a 1 simplemente volvemos a
empezar de 0 otra vez. De esta forma el color en 0.1 será usado para densidad 0.55 ((2*0.55) mod 1 =
1.1 mod 1 = 0.1), el color en 0.5 será usado para densidad 0.75 y el color en 1 será usado para densidad
1.

Si se nos dan bien la matemáticas notaremos que este ejemplo no es del todo correcto debido a que (1 *
2) mod 1 = 0 y no 1. Simplemente imaginemos que hemos usado un valor ligeramente menor que uno y
todo irá bien.

Deberíamos darnos cuenta de que para evitar cambios repentinos en el color del halo para frecuencias
mayores que uno tendríamos que usar un mapa de color periódico, es decir, un mapa de color cuyas
entradas en 0 y en 1 sean las mismas.

Cambiamos nuestro ejemplo usando un mapa de color periódico y cambiando el valor de la frecuencia a
dos.
sphere { 0, 1
pigment { color rgbt <1, 1, 1, 1> }
halo {
emitting
spherical_mapping
linear
turbulence 1.5
color_map {
[ 0.0 color rgbt <1, 0, 0, 1> ]
[ 0.5 color rgbt <1, 1, 0, -1> ]
[ 1.0 color rgbt <1, 0, 0, 1> ]
}
frequency 2
samples 20
scale 0.5
}
hollow
scale 1.5
}
PERSISTENCE OF VISION RAYTRACER 109

Figura 31: Usando un mapa de color periódico y una frecuencia

de dos obtenemos mejores resultados

Observando el resultado de (HALO05.POV) podemos estar bastante satisfechos con la explosión que
hemos creado.

Todavía hay algo más a tener en cuenta cuando se incrementa la frecuencia. A menudo es necesario
incrementar la tasa de muestreo (samples) casi del mismo modo que incrementamos la frecuencia. Si
no hacemos esto probablemente notaremos graves efectos de aliasing (como saltos o bandas extrañas
de color). Si esto ocurre simplemente se ha de cambiar el valor de samples de acuerdo con el nuevo
valor de frequency (dos veces la tasa de muestreo si doblamos la frecuencia).

4.8.5.2.6. Cambiando el color del halo

Tenemos una bonita explosión, pero queremos añadir un toque de ciencia-ficción usando colores
distintos. ¿Qué tal una menos turbulenta explosión verde que se vuelve roja en sus extremos?

¡Nada más fácil que eso!

sphere { 0, 1.5
pigment { color rgbt <1, 1, 1, 1> }
halo {
emitting
spherical_mapping
linear
turbulence 0.5
color_map {
[ 0 color rgbt <0, 1, 0, 1> ]
[ 1 color rgbt <1, 0, 0, -1> ]
}
samples 10
scale 0.75
}
hollow
scale 1.5
}
4. TUTORIAL PARA PRINCIPIANTES 110

Figura 32: Usando los colores rojo y verde obtenemos un resultado

inesperado

Eso es exactamente lo que nos hacía falta. Observando los resultados de HALO06.POV podemos quedar
algo decepcionados. ¿Donde está el centro rojo de la explosión? Los bordes son verdes como
esperábamos pero hay gran cantidad de amarillo en el centro y solo un poco de rojo. ¿Qué esta
pasando?

Usamos un halo emisor para nuestro ejemplo. De acuerdo con la correspondiente sección en el capítulo
de referencia del halo (ver "Emisor") este tipo de halo utiliza partículas muy pequeñas que no atenúan la
luz que atraviesa el halo. Especialmente las partículas cerca del observador no atenúan la luz
proveniente de partículas más lejanas.

Durante el cálculo del color del halo cerca del centro de la esfera contenedora, el rayo pasa a través de
casi todas las posibles densidades de la distribución de partículas. De esta manera tenemos partículas
rojas y verdes según avanzamos, dependiendo de la posición actual en el halo. Se usa la suma de estos
colores, lo que da el color amarillo (la suma del rojo y el verde es el amarillo). Esto es lo que ocurre
aquí.

¿Como podemos conseguir lo que queremos? La respuesta es usar un halo brillante en lugar de un halo
emisor. El halo brillante es muy similar al emisor excepto que el primero atenúa la luz que pasa a través
de él. De esta forma la luz de las partículas situadas detrás de otras será atenuada por estas últimas.

4.8.5.3. El halo brillante

Hemos mencionado el halo brillante en la sección sobre el halo emisor como una forma de evitar la
mezcla de color que ocurre con este tipo de halo.

El halo brillante es muy similar al emisor con la diferencia de que también absorbe la luz. Podemos
verlo como una combinación del halo emisor y del atenuante descrito en la sección "El Halo
Atenuante".

Simplemente reemplazando el identificador emitting en el ejemplo de la sección "Cambiando el

Color del Halo" por el identificador glowing obtenemos el efecto deseado como se ve en la imagen
del ejemplo (HALO11.POV).
PERSISTENCE OF VISION RAYTRACER 111

Figura 33: Usando un halo brillante obtenemos el resultado

esperado

A pesar de que el color rojo de las áreas de alta densidad no es muy visible debido a la coloración verde,
las áreas de baja densidad situadas al frente absorben la mayor parte de la luz roja, no vemos el color
amarillo donde hubiéramos esperado un color rojo.

Debido a su similitud con el halo emisor tenemos que experimentar con este tipo de halo. Solo tenemos
que retener en mente todo lo aprendido en las secciones previas pare obtener resultados satisfactorios.

4.8.5.4. El halo atenuante

Otro tipo de halo es el halo atenuante que solo absorbe luz. No emite luz propia.

Una gran diferencia entre el halo atenuante y los otros tipos de halos es que el color del halo atenuante
es calculado a partir del mapa de color usando la densidad total de partículas a lo largo de un rayo dado.
Los otros tipos utilizan una media pesada de los colores calculados a partir de la densidad en cada
muestra.

4.8.5.4.1. Haciendo una nube

Los halos atenuantes son ideales para crear nubes y humo. En los siguientes ejemplos intentaremos
hacer una pequeña nube. Empezamos de nuevo usando una esfera unitaria rellenada con un halo
atenuante básico (HALO21.POV).
camera {
location <0, 0, -2.5>
look_at <0, 0, 0>
}

light_source { <10, 10, -10> color rgb 1 shadowless }

plane { z, 2
pigment { checker color rgb 0, color rgb 1 }
finish { ambient 1 diffuse 0 }
scale 0.5
hollow
}
4. TUTORIAL PARA PRINCIPIANTES 112

sphere { 0, 1
pigment { color rgbt <1, 1, 1, 1> }
halo {
attenuating
spherical_mapping
linear
color_map {
[ 0 color rgbt <1, 0, 0, 1> ]
[ 1 color rgbt <1, 0, 0, 0> ]
}
samples 10
}
hollow
}
A pesar de que normalmente las nubes no son rojas, si no blancas o grises, usamos el color rojo para
hacerla más visible contra el fondo a cuadros blancos y negros.

El color de un halo atenuante se calcula a partir de la densidad total acumulada después de que el rayo
haya atravesado por completo el campo de partículas. Esto debe ser tenido en cuenta cuando se
especifica el mapa de color. Queremos que las áreas de la nube con baja densidad sean altamente
translúcidas, así que usamos un color rgbt <1,0,0,1> y queremos que las áreas de alta densidad
sean opacas, así que usamos un color rgbt <1,0,0,0>.

Figura 34: El halo atenuante básico usado para crear una nube

4.8.5.4.2. Escalando el contenedor del halo

La nube que hemos creado no es muy realista. Es solo una translúcida bola roja. Para obtener un mejor
resultado usamos algunos de los métodos que ya hemos aprendido en las secciones acerca de los halos
emisores. Añadimos algo de turbulencia para conseguir una forma más realista, escalamos el halo para
evitar que la superficie del objeto contenedor sea visible y decrementamos la translucidez de las áreas
con una alta densidad de partículas.

Otra idea es escalar el objeto contenedor para obtener una forma elipsoide que puede ser usada para
modelar una nube de forma bastante efectiva. Esto se consigue con el comando scale
<1.5,0.75,1> al final de la declaración de la esfera. Escala ambos, la esfera y el halo interior.
sphere { 0, 1
pigment { color rgbt <1, 1, 1, 1> }
halo {
PERSISTENCE OF VISION RAYTRACER 113

attenuating
spherical_mapping
linear
turbulence 1
color_map {
[ 0 color rgbt <1, 0, 0, 1> ]
[ 1 color rgbt <1, 0, 0, -1> ]
}
samples 10
scale 0.75
}
hollow
scale <1.5, 0.75, 1>
}
Observando los resultados de HALO22.POV vemos que se parece más a una nube real (aparte del color).

Figura 35: Escalando el contenedor del halo y añadiendo algo de

turbulencia obtenemos mejores resultados

4.8.5.4.3. Añadiendo halos adicionales

Otro truco para conseguir algo más de realismo es usar múltiples halos. Si observamos un grupo
cúmulos notaremos que a menudo se extienden en la parte superior mientras que son bastante más
planos en la inferior.

Queremos modelar esta apariencia añadiendo dos halos adicionales a nuestro objeto contenedor (ver
sección "Múltiples Halos" para más detalles). Esto se consigue de la siguiente forma.
sphere { 0, 1.5
pigment { color rgbt <1, 1, 1, 1> }
halo {
attenuating
spherical_mapping
linear
turbulence 1
color_map {
[ 0 color rgbt <1, 0, 0, 1> ]
[ 1 color rgbt <1, 0, 0, -1> ]
}
samples 10
scale <0.75, 0.5, 1>
translate <-0.4, 0, 0>
}
4. TUTORIAL PARA PRINCIPIANTES 114

halo {
attenuating
spherical_mapping
linear
turbulence 1
color_map {
[ 0 color rgbt <1, 0, 0, 1> ]
[ 1 color rgbt <1, 0, 0, -1> ]
}
samples 10
scale <0.75, 0.5, 1>
translate <0.4, 0, 0>
}
halo {
attenuating
spherical_mapping
linear
turbulence 1
color_map {
[ 0 color rgbt <1, 0, 0, 1> ]
[ 1 color rgbt <1, 0, 0, -1> ]
}
samples 10
scale 0.5
translate <0, 0.2, 0>
}
hollow
}
Los tres halos utilizados solo difieren en su localización, es decir, en el vector de traslación que hemos
usado. Los dos primeros halos sirven para formar la base de la nube, mientras el último se encuentra
situado sobre estos. La esfera tiene un radio distinto que la previa debido a que se necesita más espacio
para los tres halos.

El resultado de HALO23.POV de alguna forma parece una nube, a pesar de que puede necesitar algunos
retoques.

Figura 36: Usando varios halos mejora mucho nuestra nube

4.8.5.5. El halo de polvo

El halo de polvo es un tipo muy complejo de halo. Nos permite ver la interacción de la luz proveniente
de una fuente con las partículas del halo. Estas partículas absorben la luz de la misma forma que en el
PERSISTENCE OF VISION RAYTRACER 115

halo atenuante. Además también la dispersan. Esto hace que los rayos de luz y las sombras proyectadas
por objetos sobre el halo sean visibles.

4.8.5.5.1. Empezando con un objeto iluminado por un foco

Empezamos con un objeto en forma de caja que es iluminado por un foco. No usamos ningún halo de
momento, debido a que queremos ver el objeto completamente iluminado por la luz (HALO31.POV).
camera {
location <0, 0, -2.5>
look_at <0, 0, 0>
}

background { color rgb <0.2, 0.4, 0.8> }

light_source {
<2.5, 2.5, -2.5>
colour rgb <1, 1, 1>
spotlight
point_at <0, 0, 0>
radius 12
falloff 15
tightness 1
}

difference {
box { -1, 1 }
box { <-1.1, -0.8, -0.8>, <1.1, 0.8, 0.8> }
box { <-0.8, -1.1, -0.8>, <0.8, 1.1, 0.8> }
box { <-0.8, -0.8, -1.1>, <0.8, 0.8, 1.1> }
pigment { color rgb <1, 0.2, 0.2> }
scale 0.5
rotate 45*y
rotate 45*x
}

Figura 37: El objeto que queremos usar

Como vemos el objeto entero es iluminado por la fuente de luz. Ahora podemos empezar a añadir algo
de polvo.
4. TUTORIAL PARA PRINCIPIANTES 116

4.8.5.5.2. Añadiendo algo de polvo

Usamos una caja para contener el halo de polvo. Ya que usamos una función de densidad constante no
importa que tipo de mapeado usemos. La densidad toma el valor especificado por el identificador
max_value en cualquier lugar en el interior del halo (el valor por defecto es uno). La dispersión
isotrópica es seleccionada con el identificador dust_type.
box { -1, 1
pigment { colour rgbt <1, 1, 1, 1> }
halo {
dust
dust_type 1
box_mapping
constant
colour_map {
[ 0 color rgbt <1, 1, 1, 1> ]
[ 1 color rgbt <1, 1, 1, 0> ]
}
samples 10
}
hollow
scale 5
}

Figura 38: Este polvo es demasiado espeso

El resultado de HALO32.POV es prometedor pero el polvo es demasiado espeso y solo podemos ver
algunas partes del objeto y nada del fondo.

4.8.5.5.3. Decrementando la densidad del polvo

La densidad en el interior del halo tiene un valor constante de uno. Esto significa que solo la entrada en
la posición uno del mapa de color se usa para determinar la densidad y el color del polvo.

Usamos un valor de transmitancia de 0.7 para obtener un polvo más fino.

box { -1, 1
pigment { colour rgbt <1, 1, 1, 1> }
halo {
dust
dust_type 1
box_mapping
constant
PERSISTENCE OF VISION RAYTRACER 117

colour_map {
[ 0 color rgbt <1, 1, 1, 1.0> ]
[ 1 color rgbt <1, 1, 1, 0.7> ]
}
samples 10
}
hollow
scale 5
}

Figura 39: Un polvo más fino le da un mejor aspecto

A parte de los feos efectos de aliasing la imagen queda mejor. Podemos ver el objeto entero e incluso el
fondo es ligeramente visible (HALO33.POV).

4.8.5.5.4. Mejorar la apariencia de las sombras

Para reducir los efectos de aliasing usamos tres técnicas distintas: jittering, super-muestreo y un
incremento total sobre la tasa de muestreo.

Jittering se usa para añadir algo de aleatoriedad a los puntos de muestreo haciendo que la imagen
parezca más irregular. Esto es mejor que los efectos de aliasing. Un bajo valor para jittering es una
buena elección.

El super-muestreo intenta reducir las diferencias tomando muestras adicionales en áreas de grandes
cambios de intensidad. El umbral en el cual se usa el super-muestreo y el nivel máximo de recursión
pueden ser especificados mediante los identificadores aa_threshold y aa_level respectivamente.

La manera de enfocar el problema que siempre funciona es incrementar la tasa general de muestreo. Ya
que también es el método más lento deberíamos usar los demás métodos primero. Si no son suficientes
tenemos que incrementar la tasa de muestreo.

Usamos el siguiente halo para reducir los efectos de aliasing (HALO34.POV).

box { -1, 1
pigment { colour rgbt <1, 1, 1, 1> }
halo {
dust
dust_type 1
box_mapping
constant
4. TUTORIAL PARA PRINCIPIANTES 118

colour_map {
[ 0 color rgbt <1, 1, 1, 1.0> ]
[ 1 color rgbt <1, 1, 1, 0.7> ]
}
samples 50
aa_level 3
aa_threshold 0.2
jitter 0.1
}
hollow
scale 5
}

Figura 40: Distintos métodos de anti-aliasing ayudan a obtener

un resultado satisfactorio

La imagen tiene mejor apariencia ahora. prácticamente no queda ningún efecto de aliasing.

Los mismos parámetros que hemos usado son discutidos en la sección acerca de la atmósfera (ver "La
Atmósfera" para más explicaciones).

4.8.5.5.5. Añadiendo turbulencia

La mayor diferencia entre el halo de polvo y la atmósfera descrita en "La Atmósfera" es la posibilidad
de elegir una distribución de partículas no uniforme para el polvo. Esto incluye el hecho de que el halo
es limitado a un objeto contenedor además de los distintos tipos de funciones de densidad y mapeado.

Otra forma interesante de conseguir una distribución irregular es añadir algo de turbulencia al polvo.
Esto se consigue con el identificador turbulence seguido de la cantidad de turbulencia que será
usada, como muestra el siguiente ejemplo (HALO35.POV).
box { -1, 1
pigment { colour rgbt <1, 1, 1, 1> }
halo {
dust
dust_type 1
box_mapping
linear
turbulence 1
colour_map {
[ 0 color rgbt <1, 1, 1, 1.0> ]
[ 1 color rgbt <1, 1, 1, 0.5> ]
PERSISTENCE OF VISION RAYTRACER 119

}
samples 50
aa_level 3
aa_threshold 0.2
jitter 0.1
}
hollow
scale 5
}

Figura 41: Añadir turbulencia al polvo hace que tenga un aspecto

más interesante

La imagen parece más interesante debido a los desplazamientos en la densidad de partículas.

Deberíamos notar que usamos una función de densidad lineal en lugar de la función constante anterior.
Esto es necesario debido a que con una función constante la densidad tiene el mismo valor en todos los
puntos. El añadir turbulencia no tendría ningún efecto debido a que a donde quiera que los puntos sean
movidos el valor de la densidad tendrá el mismo valor. Solo una distribución de densidad no constante
tiene sentido cuando se añade turbulencia.

El hecho de que el valor de turbulencia sea un vector puede ser usado para crear efectos como cascadas
usando un gran valor de turbulencia en una sola dirección (por ejemplo turbulence
<0.2,1,0.2>).

4.8.5.5.6. Usando polvo coloreado

Si queremos crear polvo coloreado podemos hacerlo fácilmente usando un color distinto del blanco en
el mapa de color. En este caso también tenemos que fijar los canales de filtro en el mapa de color a
valores distintos de cero para especificar la cantidad de luz filtrada por el color del polvo.

Usamos un mapa de color para obtener un filtrante polvo rojo por ejemplo:
colour_map {
[ 0 color rgbft <1, 0, 0, 0.5, 1.0> ]
[ 1 color rgbft <1, 0, 0, 0.5, 0.7> ]
}
4. TUTORIAL PARA PRINCIPIANTES 120

4.8.5.6. Dificultades de los halos

Debido a la complejidad del halo y a la poca experimentación que los usuarios han hecho de el todavía
hay un montón de cosas por descubrir.

Algunos de los problemas y dificultades más comunes son descritas a continuación para ayudarnos a
evitarlos.

4.8.5.6.1. Donde son permitidos los halos

Como se mencionó antes, un halo llena completamente el interior de un objeto. Teniendo esto en
cuenta es razonable que el siguiente ejemplo no tenga sentido.
sphere { 0, 1
pigment {
checker
texture {
pigment { color Clear }
halo { ... }
}
texture {
pigment { color Red }
}
}
hollow
}
¿Qué es lo que está mal en este ejemplo? Es simplemente que un halo se usa para describir el interior de
un objeto y que no se puede describir este interior especificando el aspecto de la superficie. Pero esto
fue hecho en el ejemplo anterior. No podemos imaginar que aspecto tendrá el interior de la esfera.
¿Estará completamente ocupada por el halo? ¿Estarán algunas áreas ocupadas por el halo y otras por
aire? ¿Qué aspecto tendrán estas áreas?

No podremos ver las propiedades del interior observando la superficie. Simplemente no es posible.
Esto siempre se debe tener en cuenta.

Si el ejemplo anterior fue pensado para crear una esfera rellenada con un halo y cubierta por una textura
a cuadros que ocultara en parte el halo tendríamos que haber empleado la siguiente sintaxis:
sphere { 0, 1
pigment {
checker
texture {
pigment { color Clear }
}
texture {
pigment { color Red }
}
}
halo { ... }
hollow
}
Un halo siempre se aplica a un objeto de la siguiente forma:
OBJECT {
texture {
pigment { ... }
normal { ... }
finish { ... }
halo { ... }
}
hollow
PERSISTENCE OF VISION RAYTRACER 121

}
No se permite un halo en la declaración de un pigmento, de un mapa de color, de un mapa de
pigmento, de un mapa de material o de cualquier otra cosa. No se nos impide hacerlo pero no
obtendremos los resultados que queremos.

Podemos usar halos con texturas superpuestas siempre que nos aseguremos de que los halos solo están
vinculados a la capa inferior (que por supuesto debe ser transparente para que se pueda ver el halo).

4.8.5.6.2. Superponiendo los objetos contenedores

POV-Ray no es capaz de tratar de forma correcta la superposición de objetos contenedores. Si creamos
dos esferas superpuestas que contengan un halo no obtendremos resultados correctos en la zona de
superposición. El efecto del halo se calcula de forma independiente para cada esfera y después se suman
los resultados.

Si queremos añadir distintos halos tenemos que ponerlos todos en el interior de un solo objeto
contenedor para asegurarnos de que el halo se calcula de forma correcta (ver también "Múltiples
Halos").

También deberíamos observar que cuando tenemos varios objetos contenedores muy próximos unos a
otros pero sin superposición real, son tratados de forma correcta. Si ponemos un objeto contenedor en
frente de otro los halos son trazados correctamente.

4.8.5.6.3. Múltiples halos atenuantes

Actualmente no es posible usar múltiples halos atenuantes con distintos mapas de color. El mapa de
color del último halo será usado para todos los halos en el objeto contenedor.

4.8.5.6.4. Halos y objetos vacíos

Para trazar de forma correcta los efectos del halo tenemos que asegurarnos de que todos los objetos
dentro de los cuales se encuentra la cámara sean vacíos. Esto se consigue añadiendo el identificador
hollow.

4.8.5.6.5. Escalando el contenedor de un halo

Si escalamos el objeto contenedor de un halo deberíamos tener en cuenta que es importante el lugar
donde coloquemos el identificador scale.

Escalar el objeto antes de la declaración del halo solo escalara el objeto contenedor, no el halo. Esto es
útil cuando queremos evitar que la superficie del objeto contenedor sea visible debido al uso de la
turbulencia. Como hemos aprendido en las secciones anteriores, las partículas pueden moverse fuera del
objeto contenedor, donde son invisibles, si se añade turbulencia. Esto solo funciona para el mapeado
esférico y el mapeado de caja debido a que los campos de densidad descritos por los otros mapeados no
tienen dimensiones finitas.

Si se usa el identificador scale después de la declaración del halo, ambos, el halo y el objeto contenedor
son escalados. Esto es útil para escalar el halo según nuestras necesidades.

El halo mantiene su apariencia a pesar de las transformaciones aplicadas al objeto contenedor (después
del halo), es decir, la translucidez, el color y la turbulencia del halo no cambiarán.
4. TUTORIAL PARA PRINCIPIANTES 122

4.8.5.6.6. Eligiendo una tasa de muestreo

Normalmente empezaremos con una baja tasa de muestreo y solo la incrementaremos si aparecen
efectos de aliasing (y no desaparecen usando el super-muestreo y el jittering).

La apariencia del halo es independiente de la tasa de muestreo siempre que se tomen las suficientes
muestras para describir correctamente su forma. Esto significa que una o dos muestras difícilmente
serán suficientes para determinar la apariencia del halo. Según vamos incrementando el número de
muestras el halo se aproximará rápidamente a su apariencia real.

En pocas palabras, el halo no cambiará su apariencia con la tasa de muestreo siempre que tengamos el
suficiente número de muestras y no nos encontremos con los efectos del aliasing.

4.8.5.6.7. Usando turbulencia

Como dijimos en una de las secciones anteriores la turbulencia no tendrá efecto si se usa la función de
densidad constante (identificador constant). No importa cuanto o en que dirección movamos un punto
si la densidad es constante y por lo tanto no depende de la situación del punto. Tenemos el mismo valor
de densidad para todas la localizaciones.

Siempre que añadamos turbulencia a un halo debemos evitar la función de densidad constante.

4.9. Trabajar con texturas especiales

Muchos de los patrones de color que hemos visto hasta ahora en POV-Ray usan una instrucción
color_map para juntar diversos colores. Dependiendo de la lista de colores, podemos cambiar gradual
o bruscamente de un color a otro. De hecho, el mapa de color es una herramienta muy poderosa para
personalizar los diversos patrones de color, aunque requiere un poco de práctica usarla correctamente.
Además, a partir de la versión 3, POV-Ray nos permite unir diversos patrones, normales, acabados, e
incluso texturas completas de la misma forma que mezclamos colores.

Para experimentar con algunas de las excitantes opciones de textura, preparemos una escena básica, a la
que aplicaremos las texturas que diseñemos más adelante. Empecemos llamando a los archivos de
inclusión de colores y texturas predefinidos, y poniendo una cámara y una fuente de luz.
#include "colors.inc"
#include "textures.inc"

camera {
orthographic
up <0, 5, 0>
right <5, 0, 0>
location <0, 0, -25>
look_at <0, 0, 0>
}

light_source { <100, 100, -100> color White }

4.9.1. Trabajar con mapas de pigmentos

Empecemos con algo sencillo. No debemos confundir el mapa de colores con el mapa de
pigmentaciones, ya que el mapa de colores sólo admite colores como entradas, mientras que en el mapa
de pigmentos podemos usar como elementos a mezclar pigmentos completos. Probemos a colorear un
plano con un mapa de pigmentos. En el próximo ejemplo, vamos a declarar cada uno de los pigmentos
PERSISTENCE OF VISION RAYTRACER 123

que utilicemos. No es estrictamente necesario hacerlo (podemos colocar la descripción completa en

cada entrada del mapa), aunque habitualmente es más cómodo de leer.
// cuadrados Blancos y Negros... es un clásico.
#declare Pigment1 = pigment {
checker color Black color White
scale .1
}

// un efecto de “anillos psicodélicos”

#declare Pigment2 = pigment {
wood
color_map {
[ 0.0 Red ]
[ 0.3 Yellow ]
[ 0.6 Green ]
[ 1.0 Blue ]
}
}

plane { -z, 0
pigment {
gradient x
pigment_map {
[ 0.0 Pigment1 ]
[ 0.5 Pigment2 ]
[ 1.0 Pigment1 ]
}
}
}
Vale, lo que hemos hecho es sencillo y probablemente fácil de entender si hemos trabajado
anteriormente con mapas de colores. Hemos colocado un mapa de pigmentos donde suele ir un mapa
de colores, y hemos situado nuestros pigmentos predeclarados como entradas del mapa. Cuando vemos
la imagen, observamos un patrón a bandas de cuadrados negros y de anillos concéntricos, de forma que
las transiciones entre un patrón y otro son suaves, mezclándose ambos patrones en el centro de los
cambios. También podemos hacer transiciones bruscas, retocando algo el mapa de pigmentos.
pigment_map {
[ 0.0 Pigment1 ]
[ 0.5 Pigment1 ]
[ 0.5 Pigment2 ]
[ 1.0 Pigment2 ]
}

4.9.2. Trabajar con mapas de normales

Para nuestro ejemplo próximo, reemplazaremos el plano anterior por este:
plane { -z, 0
pigment { White }
normal {
gradient x
normal_map {
[ 0.0 bumps 1 scale .1]
[ 1.0 ripples 1 scale .1]
}
}
}
Hemos elegido un color sólido para que se vean más claramente los bultos. Además, observamos que
nuestro mapa mezcla suavemente bultos y ondas, para luego saltar bruscamente (por ser un gradiente) al
comienzo de nuevo. De esta manera, podemos ver qué sucede tanto cuando cambiamos bruscamente el
patrón como cuando lo cambiamos lentamente.
4. TUTORIAL PARA PRINCIPIANTES 124

La sintaxis de la instrucción es la que podíamos esperar. Hemos cambiado el tipo de mapa, poniéndolo
esta vez en el bloque de normal, y hemos colocado como parámetros tipos de normal. Recordemos que
en POV-Ray 3, todos los patrones que funcionan como colores funcionan como normales, y viceversa,
así que podemos cambiar de madera a granito, por ejemplo. Deberíamos investigar un poco esto, para
entender el aspecto que pueden tener estos patrones como normales.

Tras ver lo interesante que puede ser mezclar dos patrones en las transiciones, quizá queramos construir
una textura en la que dos patrones se mezclen completamente. Esto es posible usando la función
“average”. Volveremos a esto más adelante.

4.9.3. Trabajar con mapas de textura

Ahora que hemos mezclado colores, patrones de pigmentación y normales, probablemente pensemos ¿y
los acabados? ¿Y las texturas completas? Ambos pueden fundirse en un solo apartado, ya que, aunque
no hay un mapa de acabados propiamente dicho, puede usarse mapas de textura para obtenerlo,
colocando idénticos bloques de normal y pigmento en varias texturas. Pondremos un ejemplo. Hemos
eliminado las declaraciones de pigmentos que utilizamos antes, y añadido lo siguiente:
#declare Texture1 = texture {
pigment { Grey }
finish { reflection 1 }
}

#declare Texture2 = texture {

pigment { Grey }
finish { reflection 0 }
}

cylinder { <-2, 5, -2>, <-2, -5, -2>, 1

pigment { Blue }
}

plane { -z, 0
rotate y * 30
texture {
gradient y
texture_map {
[ 0.0 Texture1 ]
[ 0.4 Texture1 ]
[ 0.6 Texture2 ]
[ 1.0 Texture2 ]
}
scale 2
}
}
¿Qué hemos hecho? El plano de fondo alterna verticalmente entre dos texturas, idénticas excepto en su
acabado. Cuando lo convertimos en una imagen, el cilindro se refleja en unas zonas del plano y en otras
no. Con pequeñas adaptaciones, podemos usar esta idea con cualquier patrón, mezclando cualquier tipo
de acabado que se nos ocurra. Podemos dar a diferentes partes de un objeto diferentes acabados o
diferentes texturas completas.

Una pregunta: si existe un mapa de texturas, ¿para qué necesitamos un mapa de pigmentos, o de
normales? Sencillo: velocidad de cálculo. Si usamos un mapa de texturas, para cada punto afectado,
POV-Ray hace los cálculos correspondientes a todas las texturas, después realiza un cálculo (media
ponderada) entre los resultados que promedia el valor que corresponde al punto. Usar un mapa de
pigmentos (o de normales) reduce el número de cálculos, ya que algunas partes de la textura se calculan
una sola vez. Como regla, usaremos preferentemente mapas de normales o pigmentos, dejando los de
texturas para cuando lo que queramos sea imposible hacerlo de otra forma.
PERSISTENCE OF VISION RAYTRACER 125

4.9.4. Trabajar con listas de texturas

Si hemos leído la parte del tutorial dedicada a pigmentos, sabremos que hay tres patrones de color
llamados de lista de colores, ya que usan, en lugar de los mapas de colores, una sencilla lista con dos o
tres colores inmediatamente después de la palabra clave. Sus nombres son ajedrezado, hexágonos y
ladrillo, nuevo en la versión 3 de POV-Ray.

Por supuesto, esto también funciona con pigmentos completos, normales, e incluso texturas enteras,
igual que los otros patrones anteriormente citados. La única diferencia es que escribimos los datos tras
el patrón (como con los colores individuales), en lugar de preparar un mapa de la forma anterior.
Pongamos un ejemplo. Borramos el plano y los pigmentos declarados de nuestro último ejemplo, y
escribimos lo siguiente:
#declare Pigment1 = pigment {
hexagon
color Yellow color Green color Grey
scale .1
}

#declare Pigment2 = pigment {

checker
color Red color Blue
scale .1
}

#declare Pigment3 = pigment {

brick
color White color Black
rotate -90*x
scale .1
}

box { -5, 5
pigment {
hexagon
pigment {Pigment1}
pigment {Pigment2}
pigment {Pigment3}
rotate 90*x
}
}
Empezamos por declarar un ejemplo de cada uno de los patrones como pigmentos individuales.
Después, usamos el patrón hexagonal como una lista de pigmentos, usando los pigmentos predefinidos
en esta lista, en lugar de colores individuales. Hay dos instrucciones de girado en este ejemplo, ya que
los ladrillos se alinean en dirección z (para cubrir una pared, por defecto), mientras que los hexágonos lo
hacen en dirección y (cubriendo un suelo), mientras que nosotros queremos que todos queden frente a
la dirección z, que es hacia donde mira la cámara.

Por supuesto, en POV-Ray 3, todo lo que vale para pigmentos, vale para normales o texturas enteras. A
continuación vemos algunos ejemplos de su uso.
normal {
brick
normal {granite .1}
normal {bumps 1 scale .1}
}
o...
texture {
checker
texture {Gold_Metal}
4. TUTORIAL PARA PRINCIPIANTES 126

texture {Silver_Metal}
}

4.9.5. ¿Y las baldosas?

En versiones anteriores de POV-Ray, existía una textura especial llamada baldosa (tiles). Ahora
podemos substituirla por un patrón ajedrezado (como hemos visto anteriormente), así que ha quedado
obsoleta debido a la flexibilidad de la nueva sintaxis. POV-Ray 3.0 aún comprende la instrucción para
mantener la compatibilidad con imágenes preparadas para versiones anteriores, aunque deberíamos
acostumbrarnos a usar los patrones de listas de texturas.

4.9.6. Función promedio

Las cosas se ponen interesantes. Hemos visto cómo los pigmentos y las normales se transforman
gradualmente cuando las colocamos en mapas de normales, pigmentos o texturas. Pero ¿y si queremos
que nuestra textura sea una mezcla de dos en todo el objeto? Ahora disponemos de una función nueva,
llamada promedio (average) que nos lo permite. Esta función trabaja con pigmentos, normales y
texturas, aunque su sintaxis es ligeramente distinta de los patrones estudiados antes. Si no estamos
advertidos, el cambio nos podría confundir. Probamos en nuestro archivo, borrando todos los objetos y
usando los siguientes.
plane { -z, 0
pigment { White }
normal {
average
normal_map {
[ gradient x ]
[ gradient y ]
}
}
}
Lo que hemos hecho es bastante claro de por sí, tan pronto como lo vemos convertido en un dibujo.
Hemos combinado un gradiente horizontal con uno vertical, creando unos gradientes cruzados.
Realmente, este efecto es una mezcla suave de las normales anteriores. ¿Cuál es el cambio en la sintaxis?

Podemos ver cómo ha cambiado la declaración del mapa de normales. El valor decimal que precedía
cada entrada del mapa ha desaparecido. Este número indicaba en qué punto se iniciaba la mezcla entre
uno y otro, y ahora la mezcla se realiza en todo el objeto. De hecho, el promedio no usa esos valores
como esperamos, si no como pesos para las mezclas, e incluirlos puede dar lugar a resultados
imprevistos.

4.9.7. Trabajar con texturas superpuestas

Con los abundantes colores, patrones y opciones para crear texturas complejas de POV-Ray, fácilmente
podemos crear texturas apropiadas para nuestras creaciones. Sin embargo, tarde o temprano nos
veremos obligados a usar la posibilidad que aquí se trata. Por ejemplo, imagina una madera barnizada
sobre la que alguien ha manchado con un poco de pintura amarilla, dejando unas manchas irregulares a
través de las cuales puede verse la madera.

¿Y bien? Es difícil crear una textura que reúna todas esas condiciones. Quizá el lector esté pensando en
pegar una imagen simulando este efecto, pero aún queda una solución: superponer varias texturas.

Sólo tenemos que especificar una serie de varias texturas, una tras otra, asociadas al mismo objeto. Se le
aplicarán como capas de pintura, una tras otra, en el orden en que aparezcan.
PERSISTENCE OF VISION RAYTRACER 127

Es importante que recordemos asignar un grado de transparencia (filtro o transmitancia) a parte de las
texturas que situemos en las capas superiores, ya que en caso contrario las inferiores no servirán para
nada. No recibiremos ningún mensaje de error, técnicamente es legal, sencillamente no tiene sentido. Es
como pasarse horas pintando una imagen elaborada en un muro, para después darle una capa de látex
blanco encima, ocultándola totalmente.

Diseñemos un objeto muy simple con texturas superpuestas y observemos cómo funciona. Creamos un
archivo llamado LAYTEX.POV y escribimos:
#include "colors.inc"
#include "textures.inc"

camera {
location <0, 5, -30>
look_at <0, 0, 0>
}

light_source { <-20, 30, -50> color White }

plane { y, 0 pigment { checker color Green color Yellow } }

background { rgb <.7, .7, 1> }

box { <-10, 0, -10>, <10, 10, 10>

texture {
Silver_Metal // un objeto metálico...
normal { // ... algo abollado
dents 2
scale 1.5
}
} // (fin de la textura base)

texture { // ... tiene alguna manchas de óxido ...

pigment {
granite
color_map {
[0.0 rgb <.2, 0, 0> ]
[0.2 color Brown ]
[0.2 rgbt <1, 1, 1, 1> ]
[1.0 rgbt <1, 1, 1, 1> ]
}
frequency 16
}
} // (fin de la textura de manchas de óxido)

texture { // ... y algunas manchas negras

pigment {
bozo
color_map {
[0.0 color Black ]
[0.2 color rgbt <0, 0, 0, .5> ]
[0.4 color rgbt <.5, .5, .5, .5> ]
[0.5 color rgbt <1, 1, 1, 1> ]
[1.0 color rgbt <1, 1, 1, 1> ]
}
scale 3
}
} // (fin de la textura de las manchas negras)

} // (fin de la caja)
Bueno. Esto se complica, así que para hacerlo más sencillo de entender, hemos incluido comentarios
explicando lo que hace cada parte, y dónde acaba. Para empezar, sólo creamos una caja sobre un suelo
ajedrezado típico, y dimos al cielo de fondo un tono de azul liso. Y después...
4. TUTORIAL PARA PRINCIPIANTES 128

Para empezar, dimos a la caja la textura Silver_Metal, declarada en TEXTURES.INC (si quieres nota,
mira en el archivo indicado y comprueba que esta textura figura ahí). Para dar impresión de desgaste,
hemos añadido un patrón de normal abollado (dents). Esto produce la sensación de que nuestra
misteriosa caja metálica ha sido golpeada.

Las pequeñas manchas de óxido no son mas que un patrón granito que varía de rojo oscuro a marrón y
después pasa de golpe a ser totalmente transparente, siendo así la mayor parte del mapa de color. Vale,
probablemente habríamos conseguido un patrón de manchas más realista usando mapas de pigmentos,
pero eso corresponde a otra sección del manual, así que no lo pensemos por ahora.

Por último, hemos añadido otra textura al bloque. La distribución llamada bozo varía desde centros
oscuros a gris semi-transparente y después se vuelve totalmente transparente durante la mitad del mapa
de colores. Da aspecto de manchas oscuras (quizá producidas por fuego) que están adheridas a la
superficie de la caja (por encima de las manchas de óxido). El resultado final es un misterioso bloque
metálico ciertamente maltratado, de una forma en la que una sola textura no habría podido nunca.

4.9.7.1. Declarar texturas superpuestas

En el caso de que queramos usar un conjunto de texturas superpuestas en varios objetos de nuestra
escena, es perfectamente legal declarar una textura así. No la tendremos que repetir cada vez, aunque el
formato general debe parecerse a lo siguiente:
#declare Abused_Metal =
texture { /* aquí va la textura base... */ }
texture { /* y aquí las manchas de óxido... */ }
texture { /* y, por supuesto, aquí las manchas negras. */ }
POV-Ray no tiene ningún problema en reconocer dónde termina la declaración, ya que las texturas se
escriben una tras otra sin objetos ni directivas en medio. Las texturas superpuestas declaradas
continuarán hasta que encuentre algo que no sea una textura, de forma que podemos apilar un número
indeterminado de ellas.

Una última aclaración sobre las texturas: si utilizamos texturas superpuestas, declaradas o no, debemos
olvidarnos de las abreviaturas para texturas (escribir sólo el pigmento, o sólo el acabado...), ya que este
método no se extiende a este tipo de texturas. Podemos apilar texturas completas, no trozos de textura.
Lo siguiente:
#declare Bad_Texture =
texture { /* insert your base texture here... */ }
pigment { Red filter .5 }
normal { bumps 1 }
no funcionará. El pigmento y la normal no son parte definida de una textura, Podemos escribirlos así si
no hubiese una textura base, pero así generará un error.

4.9.7.2. Otro ejemplo de texturas superpuestas

Para explicar con mayor detalle cómo funcionan las texturas superpuestas, se describe otro ejemplo en
detalle. Creamos un mantel para una escena de comida en el campo. Un mantel a cuadros blancos y
rojos sólo resulta demasiado nuevo, demasiado plano, como un trozo de suelo, se usan texturas
superpuestas para manchar la tela.

Creamos una escena que contiene cuatro cajas. La primera de ellas tendrá la textura base a cuadros rojos
y blancos, que usaremos de punto de partida, la segunda añade una capa que ensucia la tela de forma
realista, la tercera añade algo de vino a la tela, y la cuarta coloca unas pocas arrugas (no otra textura
superpuesta, aunque debemos fijarnos qué cambios en la textura provocan este efecto en el resultado).
PERSISTENCE OF VISION RAYTRACER 129

Empezamos situando una cámara, luces, y la primera caja. En este momento, la textura no es
superpuesta, claro. Observa el archivo LAYERED1.POV.
#include "colors.inc"

camera {
location <0, 0, -6>
look_at <0, 0, 0>
}

light_source { <-20, 30, -100> color White }

light_source { <10, 30, -10> color White }
light_source { <0, 30, 10> color White }

#declare PLAIN_TEXTURE =
// cuadros blancos y rojos
texture {
pigment {
checker
color rgb<1.000, 0.000, 0.000>
color rgb<1.000, 1.000, 1.000>
scale <0.2500, 0.2500, 0.2500>
}
}

// caja roja y blanca a cuadros

box { <-1, -1, -1>, <1, 1, 1>

texture {
PLAIN_TEXTURE
}
translate <-1.5, 1.2, 0>
}
No hay nada especial en esta escena ¿no? Usaremos nuevas texturas para hacerla más interesante.

Primero añadiremos una capa con dos grises distintos, parcialmente transparentes. Los distribuiremos
en cuadrícula, de la misma forma que antes, aunque usaremos algo de turbulencia para hacer más
realista el oscurecimiento. Añadimos la siguiente caja a la escena previa y reconstruimos la imagen.
#declare FADED_TEXTURE =
// cuadrados rojos y blancos
texture {
pigment {
checker
color rgb<0.920, 0.000, 0.000>
color rgb<1.000, 1.000, 1.000>
scale <0.2500, 0.2500, 0.2500>
}
}
// grises para oscurecer el rojo y blanco
texture {
pigment {
checker
color rgbf<0.632, 0.612, 0.688, 0.698>
color rgbf<0.420, 0.459, 0.520, 0.953>
turbulence 0.500
scale <0.2500, 0.2500, 0.2500>
}
}

// caja con cuadros oscurecida

box { <-1, -1, -1>, <1, 1, 1>

texture {
FADED_TEXTURE
}
4. TUTORIAL PARA PRINCIPIANTES 130

translate <1.5, 1.2, 0>

}
Aunque pensemos que es una sutil diferencia, los cuadros rojos y blancos ya no parecen tan nuevos.

Como hay una botella de vino en la escena, pensamos que sería un toque interesante añadir una o dos
manchas. Este efecto puede lograrse situando una burbuja muy plana en la tela, aunque lograríamos el
efecto del vino derramado, no de la mancha producida. Es el momento de añadir otra capa.

De nuevo, añadimos una caja y reconstruimos.

#declare STAINED_TEXTURE =
// cuadros rojos y blancos
texture {
pigment {
checker
color rgb<0.920, 0.000, 0.000>
color rgb<1.000, 1.000, 1.000>
scale <0.2500, 0.2500, 0.2500>
}
}
// grises
texture {
pigment {
checker
color rgbf<0.634, 0.612, 0.688, 0.698>
color rgbf<0.421, 0.463, 0.518, 0.953>
turbulence 0.500
scale <0.2500, 0.2500, 0.2500>
}
}
// mancha de vino
texture {
pigment {
spotted
color_map {
[ 0.000 color rgb<0.483, 0.165, 0.165> ]
[ 0.329 color rgbf<1.000, 1.000, 1.000, 1.000> ]
[ 0.734 color rgbf<1.000, 1.000, 1.000, 1.000> ]

[ 1.000 color rgb<0.483, 0.165, 0.165> ]

}
turbulence 0.500
frequency 1.500
}
}

// caja sucia

box { <-1, -1, -1>, <1, 1, 1>

texture {
STAINED_TEXTURE
}
translate <-1.5, -1.2, 0>
}
Ahora disponemos de un mantel con personalidad.

Queremos añadir otro toque, en forma de algunas arrugas en el mantel. Aunque esto no significa añadir
una capa nueva, debemos tener en cuenta que hay que hacerlo sobre la última capa, ya que no tiene
ningún efecto modificar la normal de las capas inferiores (aunque las superiores sean totalmente
transparentes).

Añadimos esta caja final y reconstruimos.

PERSISTENCE OF VISION RAYTRACER 131

#declare WRINKLED_TEXTURE =
// cuadros rojos y blancos
texture {
pigment {
checker
color rgb<0.920, 0.000, 0.000>
color rgb<1.000, 1.000, 1.000>
scale <0.2500, 0.2500, 0.2500>
}
}
// grises para oscurecer
texture {
pigment {
checker
color rgbf<0.632, 0.612, 0.688, 0.698>
color rgbf<0.420, 0.459, 0.520, 0.953>
turbulence 0.500
scale <0.2500, 0.2500, 0.2500>
}
}
// manchas de vino
texture {
pigment {
spotted
color_map {
[ 0.000 color rgb<0.483, 0.165, 0.165> ]
[ 0.329 color rgbf<1.000, 1.000, 1.000, 1.000> ]
[ 0.734 color rgbf<1.000, 1.000, 1.000, 1.000> ]
[ 1.000 color rgb<0.483, 0.165, 0.165> ]
}
turbulence 0.500
frequency 1.500
}
normal {
wrinkles 5.0000
}
}

// caja arrugada

box { <-1, -1, -1>, <1, 1, 1>

texture {
WRINKLED_TEXTURE
}
translate <1.5, -1.2, 0>
}
Puede que este no sea el mantel ideal para ir al campo, pero si comparamos la última caja con la
primera, veremos cuánta profundidad, dimensión y personalidad es posible crear usando sólo texturas
originales.

Una nota: los comentarios para la normal no son válidos para los acabados. Si una capa tiene reflexión
especular, y la superior no, donde la capa superior sea transparente veremos la reflexión especular.

4.9.8. Cuando todo falla: mapas de materiales

Tenemos a nuestra disposición algunas herramientas para dar textura a los objetos que son bonitas y
poderosas, pero ¿qué sucede si queremos disponer de la variedad de las texturas naturales? Bueno,
como hay mapas de imágenes para pigmentos, y mapas de bultos para definir las normales, las texturas
completas pueden combinarse siguiendo los colores de un mapa de bits, que se denomina mapa de
materiales.
4. TUTORIAL PARA PRINCIPIANTES 132

Como en los otros casos, necesitamos un archivo que contenga la imagen original que será utilizada por
POV-Ray para decidir el tipo de textura que aplicará a cada punto, y especificar qué textura va asociada
a cada uno de los índices de la paleta de la imagen. Para construir dicha imagen, necesitamos que el
programa de dibujo nos deje elegir los colores por su índice (el color es irrelevante, sólo importa el
índice que va a ocupar en la paleta). Si tenemos el paquete completo que viene con POV-Ray,
tendremos entre los ficheros de inclusión una imagen llamada POVMAP.GIF, que sólo usa los cuatro
primeros colores de la paleta para dibujar un cuadro con las palabras “Persistence of Vision” dentro.
Esta imagen servirá de muestra en nuestro próximo ejemplo. Usando de nuevo nuestra cámara y luz de
siempre, y los ficheros de inclusión más típicos, completamos el fichero con el siguiente objeto:
plane { -z, 0
texture {
material_map {
gif "povmap.gif"
interpolate 2
once
texture { PinkAlabaster } // borde interno
texture { pigment { DMFDarkOak } } // borde externo
texture { Gold_Metal } // letras
texture { Chrome_Metal } // el panel
}
translate <-0.5, -0.5, 0>
scale 5
}
}
La posición de las luces y la ausencia de fondo puede que no dejen que la imagen tenga demasiada
brillantez, pero podremos ver cómo funciona este proceso. Las texturas son situadas sencillamente
según los colores de la imagen. Al usar la palabra clave “once” (para no repetir la imagen en la textura) y
trasladar y escalar la imagen, la vemos al completo delante de nuestra cámara.

Por supuesto, esto sólo funciona con imágenes con paleta, como las GIF y algunos tipos de PNG. Sin
embargo, sí pueden usarse imágenes sin paletas para construir algunos efectos. Veamos cómo usar
POV-Ray para producir imágenes de este tipo para él mismo.

Para empezar, si usamos una imagen sin paleta, POV-Ray sólo hace caso a los ocho bits del color rojo
para determinar qué textura usa. Necesitamos controlar perfectamente el color que van a tener los
píxeles de nuestra imagen, cosa que podemos lograr si

1. Usamos una instrucción rgb para precisar los colores

2. No usamos luces, y aplicamos un ambiente de 1 para garantizar que el color resultado no va a

variar.

¿Confundido? Bien, pongamos un ejemplo. Generaremos un mapa de bits muy similar a POVMAP.GIF,
excepto que será en formato TGA. Le vamos a dar color verde y azul, pero esto es sólo para que
nosotros, las personas, podamos distinguir cómodamente los colores, ya que no podemos apreciar
variaciones de rojo de 1/255 unidades. Sin esas variaciones, la imagen aparecería negra a nuestros ojos,
de forma que podríamos usar POV-Ray para enviar mensajes secretos, aunque no es ese el uso que le
queremos dar. Queremos ver qué aspecto va a tener nuestra imagen.

Reconstruiremos el código siguiente, llamando al resultado POVMAP.TGA

camera {
orthographic
up <0, 5, 0>
right <5, 0, 0>
location <0, 0, -25>
look_at <0, 0, 0>
PERSISTENCE OF VISION RAYTRACER 133

plane { -z, 0
pigment { rgb <1/255, 0, 0.5> }
finish { ambient 1 }
}

box { <-2.3, -1.8, -0.2>, <2.3, 1.8, -0.2>

pigment { rgb <0/255, 0, 1> }
finish { ambient 1 }
}

box { <-1.95, -1.3, -0.4>, <1.95, 1.3, -0.3>

pigment { rgb <2/255, 0.5, 0.5> }
finish { ambient 1 }
}

text { ttf "crystal.ttf", "The vision", 0.1, 0

scale <0.7, 1, 1>
translate <-1.8, 0.25, -0.5>
pigment { rgb <3/255, 1, 1> }
finish { ambient 1 }
}

text { ttf "crystal.ttf", "Persists!", 0.1, 0

scale <0.7, 1, 1>
translate <-1.5, -1, -0.5>
pigment { rgb <3/255, 1, 1> }
finish { ambient 1 }
}
Todo lo que tenemos que hacer ahora es modificar nuestro ejemplo anterior de forma que situemos
TGA en lugar de GIF, en el tipo de imagen y en su nombre. Comprobaremos al reconstruirlo que el
resultado es muy similar, sólo que no tenemos que usar un programa externo para crear la imagen:
¡POV-Ray lo hace todo!

4.9.9. Limitaciones de las texturas especiales

Hay un par de limitaciones a las texturas especiales que hemos estudiado (las que tienen que ver con
mapas de bits). En primer lugar, si hemos usado la textura por defecto para todos los elementos de
nuestra escena, no podrá estar compuesta de ninguna de las características mencionadas. Es un mal
menor, ya que podemos declarar la textura y asignarla individualmente a todos los objetos. No nos
impide realmente hacer nada.

La otra limitación es más grave, aunque también se puede esquivar. Al trabajar con texturas
superpuestas, hemos visto que podíamos apilar una sobre otra indefinidamente (siempre y cuando
hubiese transparencia en las superiores). Esta técnica tan útil tiene, sin embargo, problemas cuando se
usa como base las texturas especiales que mencionábamos. ¡Aunque hay una solución!

Por ejemplo, supongamos que tenemos una textura llamada “Speckled_Metal”, que produce una
superficie metálica plateada, y ponemos pequeñas manchas de óxido sobre ella. Supongamos que
entonces , para más realismo, decidimos poner manchas de óxido más realistas sobre la superficie. Uno
de los métodos es crear un mapa de texturas con transparencias para usar como capa superior. Sin
embargo, obtendremos un mensaje de error si lo intentamos. La solución que se propone es hacer
nuestra textura parte del mapa de texturas empleados, de la forma siguiente:
// Declaramos un pigmento que
// usaremos en las manchas de óxido
#declare Rusty = pigment {
granite
color_map {
4. TUTORIAL PARA PRINCIPIANTES 134

[ 0 rgb <0.2, 0, 0> ]

[ 1 Brown ]
}
frequency 20
}

// Aquí se aplica
// Observa que nuestra textura original
// "Speckled_Metal" ahora es parte del mapa
#declare Rust_Patches = texture {
bozo
texture_map {
[ 0.0 pigment {Rusty} ]
[ 0.75 Speckled_Metal ]
[ 1.0 Speckled_Metal ]
}
}
Y el efecto es el mismo que si hubiésemos superpuesto las manchas de óxido en la superficie pulida.

Usando los patrones, pigmentos, normales, acabados, capas y texturas especiales no hay nada
prácticamente que no podamos crear como textura. ¡Una casi infinita variedad de posibilidades nos
esperan!

4.10. Usando los efectos atmosféricos

POV-Ray ofrece una variedad de efectos atmosféricos, es decir, características que afectan al ambiente
de una escena.

Es fácil asignar un color simple o un complicado diseño a una esfera celeste virtual (sky_sphere).
Puedes crear cualquier cosa, desde un azul y despejado cielo de verano hasta uno densamente nublado y
tormentoso. Incluso un cielo estrellado puede ser creado fácilmente.

Puedes usar distintos tipos de nieblas para crear escenas brumosas. Múltiples capas de niebla de
distintos colores pueden dar un toque siniestro a tu escena.

Un efecto mucho más realista se consigue usando una atmósfera, una niebla constante que interactúa
con la luz proveniente de las fuentes. Los rayos de luz se tornan visibles y los objetos proyectan
sombras sobre la niebla.

4.10.1. Background
La característica background se usa para asignar un color a todos los rayos que no incidan sobre
ningún objeto. Se usa de la siguiente forma.
camera {
location <0, 0, -10>
look_at <0, 0, 0>
}

background { color rgb <0.2, 0.2, 0.3> }

sphere { 0, 1
pigment { color rgb <0.8, 0.5, 0.2> }
}
El color asignado al fondo será visible al usar una esfera celeste solo si queda algo de translucidez
después de que las capas de pigmento de esta sean procesadas.
PERSISTENCE OF VISION RAYTRACER 135

4.10.2. La esfera celeste

La esfera celeste (sky_sphere) puede ser usada para crear, de una forma fácil, cielos nublados, cielos
nocturnos con estrellas o cualquier clase de cielo que se te ocurra.

En los siguientes ejemplos empezaremos con una esfera celeste muy simple que se irá volviendo cada
vez más y más compleja según vayamos añadiendo nuevas características.

4.10.2.1. Creando el cielo con un gradiente de colores

Junto con la esfera monocolor que puede ser creada con la característica background, la esfera celeste
más simple es un gradiente de colores.

Podemos advertir que el color del cielo varía según el ángulo con la normal al plano de superficie. Si
miras directamente hacia arriba el cielo tendrá el color de un azul más profundo que en el horizonte.

Queremos modelar este efecto usando una esfera celeste como se muestra en la siguiente escena
(SKYSPH1.POV).
#include "colors.inc"

camera {
location <0, 1, -4>
look_at <0, 2, 0>
angle 80
}

light_source { <10, 10, -10> White }

sphere { 2*y, 1
pigment { color rgb <1, 1, 1> }
finish { ambient 0.2 diffuse 0 reflection 0.6 }
}

sky_sphere {
pigment {
gradient y
color_map {
[0 color Red]
[1 color Blue]
}
scale 2
translate -1
}
}
La parte interesante es la declaración de la esfera celeste. Contiene un pigmento que describe la
apariencia de la esfera. Queremos crear un gradiente de colores a lo largo del ángulo de visión medido
contra la normal al plano de superficie. Ya que el vector director será usado para calcular los colores del
pigmento tenemos que usar el gradiente y.

Las transformaciones de translación y escalado se usan para distribuir los puntos derivados del vector
director a un rango adecuado. Sin estas transformaciones el diseño sería repetido dos veces sobre la
esfera celeste. El escalado se usa para evitar la repetición y la sentencia translate -1 para mover el
color correspondiente al índice 0 al fondo de la esfera (al punto que verías si miraras directamente hacia
abajo).
4. TUTORIAL PARA PRINCIPIANTES 136

Después de estas transformaciones la entrada de color en la posición 0 del mapa de color estará en el
fondo de la esfera, es decir, por debajo de nosotros y el color en la posición 1 estará en lo más alto, es
decir, por encima de nosotros.

Los colores para el resto de las posiciones son interpolados entre estos dos colores tal como puedes ver
en la imagen resultante.

Figura 42: Una esfera celeste con un gradiente simple

Si quieres que uno de los colores empiece a partir de un ángulo específico primero tienes que convertir
el ángulo a un índice del mapa de color. Esto se hace usando la fórmula

1 − Cos(angulo)
indice _ mapa _ color =
2

donde el ángulo se mide contra la normal (en el sentido negativo) al plano de superficie. Podríamos
decir que es la normal que apunta al centro de la tierra. Un ángulo de 0 grados describe el punto justo
debajo de nosotros, mientras que un ángulo de 180 representaría el cenit.

En POV-Ray debes primero convertir el valor en grados a radianes como se muestra en el siguiente
ejemplo.
sky_sphere {
pigment {
gradient y
color_map {
[(1-cos(radians( 30)))/2 color Red]
[(1-cos(radians(120)))/2 color Blue]
}
scale 2
translate -1
}
}
Esta escena usa un gradiente de colores que empieza con un rojo a los 30 grados y se transforma en
azul a los 120 grados. Por de bajo de 30 grados todo es de color rojo, mientras que por encima de los
120 todo es azul.
PERSISTENCE OF VISION RAYTRACER 137

4.10.2.2. Añadiendo el sol

En el siguiente ejemplo crearemos un cielo con un sol rojo rodeado por un halo del mismo color que se
va fundiendo en un cielo azul oscuro. Haremos esto usando solamente la esfera celeste.

La esfera celeste que usamos es mostrada a continuación. También se ha añadido un plano de suelo
para mayor realismo (SKYSPH2.POV).
sky_sphere {
pigment {
gradient y
color_map {
[0.000 0.002 color rgb <1.0, 0.2, 0.0>
color rgb <1.0, 0.2, 0.0>]
[0.002 0.200 color rgb <0.8, 0.1, 0.0>
color rgb <0.2, 0.2, 0.3>]
}
scale 2
translate -1
}
rotate -135*x
}

plane { y, 0
pigment { color Green }
finish { ambient .3 diffuse .7 }
}
El diseño del gradiente y las transformaciones dentro del pigmento son las mismas que en el ejemplo de
la sección anterior.

El mapa de color consiste de tres colores. Un rojo brillante y ligeramente amarillento es usado para el
sol, un rojo más oscuro para el halo y un azul oscuro para el cielo nocturno. El color del sol tan solo
cubre una pequeña parte de la esfera celeste debido a que no queremos que tenga un tamaño demasiado
grande. El color se usa en los valores 0.000 y 0.002 del mapa de color para obtener un acusado
contraste en el valor 0.002 (no queremos que el sol se funda con el cielo). El rojo más oscuro usado
para el halo se funde con el azul del cielo entre los valores 0.002 y 0.200 del mapa de color. Todos los
valores por encima de 0.200 mostrarán el color azul oscuro del cielo.

La sentencia rotate -135*x se usa para rotar tanto el sol como el cielo a su posición final. Si esta rotación
el sol estaría situado a 0 grados, es decir, por debajo de nosotros.
4. TUTORIAL PARA PRINCIPIANTES 138

Figura 43: Un sol rojo desciende en la noche

Observando la imagen resultante podemos ver los impresionantes efectos que podemos conseguir con
la esfera celeste.

4.10.2.3. Añadiendo algunas nubes

Para mejorar todavía más nuestra imagen queremos añadir algunas nubes añadiendo un segundo
pigmento. Este nuevo pigmento usa el diseño bozo para crear algunas nubes. Ya que se encuentra
situado sobre el otro pigmento necesita que algunos colores del mapa de color sean translúcidos
(observa las entradas de 0.5 a 1.0).
sky_sphere {
pigment {
gradient y
color_map {
[0.000 0.002 color rgb <1.0, 0.2, 0.0>
color rgb <1.0, 0.2, 0.0>]
[0.002 0.200 color rgb <0.8, 0.1, 0.0>
color rgb <0.2, 0.2, 0.3>]
}
scale 2
translate -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 -135*x
}
PERSISTENCE OF VISION RAYTRACER 139

Figura 44: Un cielo nublado con un sol poniente

La esfera celeste tiene un inconveniente como podrás haber notado al observar la imagen final
(SKYSPH3.POV). El sol no emitirá ninguna luz y las nubes no proyectarán ninguna sombra. Si quieres
tener nubes que proyecten sombras tendrás que usar una esfera corriente de gran tamaño con la textura
adecuada y una fuente de luz situada en algún lugar en el exterior de la esfera.

4.10.3. La niebla
Puedes usar la característica fog para añadir niebla de dos tipos distintos a tu escena: niebla constante y
niebla de suelo. La primera tiene una densidad constante en todos los puntos mientras que en la
segunda la densidad decrece según nos movemos hacia arriba.

4.10.3.1. La niebla constante

El tipo más simple de niebla es la niebla constante que tiene la misma densidad en todos los puntos. Se
especifica mediante el identificador distance que describe la densidad y el identificador color que
describe su color.

El valor de distance determina la distancia a la cual el 36.8% del fondo es todavía visible (para una
explicación más detallada sobre como se calcula la niebla leer la sección de referencia "Niebla").

El color de la niebla puede ser usado para crear cualquier cosa desde una niebla de un color blanco
inmaculado hasta un rojo sangre. También puedes usar una niebla negra para simular el efecto de un
limitado rango de visión.

El siguiente ejemplo muestra como añadir niebla a una escena simple (FOG1.POV).
#include "colors.inc"

camera {
location <0, 20, -100>
}

background { colour SkyBlue }

plane { y, -10
pigment {
4. TUTORIAL PARA PRINCIPIANTES 140

checker colour Yellow colour Green

scale 20
}
}

sphere { <0, 25, 0>, 40

pigment { Red }
finish { phong 1.0 phong_size 20 }
}

sphere { <-100, 150, 200>, 20

pigment { Green }
finish { phong 1.0 phong_size 20 }
}

sphere { <100, 25, 100>, 30

pigment { Blue }
finish { phong 1.0 phong_size 20 }
}

light_source { <100, 120, 40> colour White}

fog {
distance 150
colour rgb<0.3, 0.5, 0.2>
}

Figura 45: Una escena brumosa

Las esferas en esta escena se desvanecen, en mayor o en menor medida dependiendo de su distancia, en
la niebla verdosa, al igual que el plano a cuadros.

4.10.3.2. Especificando un mínimo de translucidez

Si quieres asegurarte de que el fondo no se desvanece completamente en la niebla puedes modificar el
canal de transmitancia del color de la niebla a la cantidad de fondo que quieres que sea siempre visible.

Usando un valor de transmitancia de 0.2 como en

fog {
distance 150
colour rgbt<0.3, 0.5, 0.2, 0.2>
}
PERSISTENCE OF VISION RAYTRACER 141

la translucidez de la niebla nunca cae por debajo del 20% como puedes ver en la imagen resultante
(FOG2.POV).

Figura 46: Añadiendo un poco de translucidez te aseguras de que

el fondo no se desvanezca

4.10.3.3. Creando niebla filtrante

La niebla verdosa que hemos usado hasta ahora no filtra la luz que pasa a través de ella. Todo lo que
hace es disminuir la intensidad de la luz. Podemos cambiar esto usando un valor distinto de cero para el
canal de filtro en el color de la niebla (FOG3.POV).
fog {
distance 150
colour rgbf<0.3, 0.5, 0.2, 1.0>
}
El valor de filtro determina la cantidad de luz que es filtrada por la niebla. En nuestro ejemplo el 100%
de la luz que pase a través de la niebla será filtrada por esta. Si hubiéramos usado un valor de 0.7 tan
solo hubiera sido filtrada el 70% de la luz. El 30% restante hubiera pasado sin ser filtrada.
4. TUTORIAL PARA PRINCIPIANTES 142

Figura 47: una niebla filtrante

Te habrás dado cuenta de que no solo disminuye la intensidad de los objetos en la niebla debido al color
de esta, si no que también los colores son influenciados. La esfera roja y especialmente la azul obtienen
un matiz de verde.

4.10.3.4. Añadiendo algo de turbulencia a la niebla

Para hacer que nuestra niebla tenga un aspecto menos monótono y más interesante podemos añadir
algo de turbulencia, haciendo parecer que tiene una densidad no constante (FOG4.POV).
fog {
distance 150
colour rgbf<0.3, 0.5, 0.2, 1.0>
turbulence 0.2
turb_depth 0.3
}
PERSISTENCE OF VISION RAYTRACER 143

Figura 48: Añadiendo un poco de turbulencia hacemos que la

niebla tenga un aspecto más interesante

El identificador turbulence es usado para especificar la cantidad de turbulencia usada mientras que el
valor asociado a turb_depth es usado para mover el punto en el cual es calculado el valor de la
turbulencia a lo largo de la línea de visión. Valores cercanos a cero mueven el punto hacia el observador
mientras que los valores cerca de uno lo mueven hacia el punto de intersección (el valor por defecto es
0.5). Este parámetro puede ser usado para evitar los fallos que puedan aparecer en la niebla debido a la
turbulencia (esto ocurre normalmente en puntos de intersección muy alejados, especialmente si la
intersección no tiene lugar, es decir, ocurre directamente sobre el fondo). Si esto ocurre simplemente
hay que disminuir el valor de turb_depth hasta que el fallo desaparezca.

Deberías tener en cuenta que la densidad de la niebla no cambia. Solo el valor de la atenuación basado
en la distancia es modificado por el valor de la turbulencia en un punto a lo largo de la línea de visión.

4.10.3.5. Usando la niebla de superficie

Un tipo de niebla más flexible e interesante es la niebla de superficie, que es seleccionada mediante el
identificador fog_type. Su apariencia es descrita mediante los identificadores fog_offset y
fog_alt. El identificador fog_offset especifica la altura, es decir, el valor Y por debajo del cual la
niebla tiene un valor constante de uno. El identificador fog_alt determina con que rapidez la
densidad de la niebla se aproxima a cero según nos movemos por el eje Y. A una altura de
fog _ offset + fog _ alt la niebla tendrá una densidad del 25%.

El siguiente ejemplo (FOG5.POV) usa una niebla de suelo que tiene una densidad constante por debajo
de y=25 (el centro de la esfera roja) y disminuye rápidamente para altitudes superiores.
fog {
distance 150
colour rgbf<0.3, 0.5, 0.2, 1.0>
fog_type 2
fog_offset 25
fog_alt 1
}
4. TUTORIAL PARA PRINCIPIANTES 144

Figura 49: La niebla de superficie sólo cubre las partes más bajas
del mundo

4.10.3.6. Usando múltiples capas de niebla

Es posible usar varias capas de niebla escribiendo más de una declaración fog en tu fichero de escena.
Esto es bastante útil si quieres conseguir buenos efectos de turbulencia usando nieblas de suelo. Podrías
ir añadiendo varias capas de niebla de distintos colores para crear una escena de aspecto siniestro, por
ejemplo.

Prueba el siguiente ejemplo (FOG6.POV).

fog {
distance 150
colour rgb<0.3, 0.5, 0.2>
fog_type 2
fog_offset 25
fog_alt 1
turbulence 0.1
turb_depth 0.2
}

fog {
distance 150
colour rgb<0.5, 0.1, 0.1>
fog_type 2
fog_offset 15
fog_alt 4
turbulence 0.2
turb_depth 0.2
}

fog {
distance 150
colour rgb<0.1, 0.1, 0.6>
fog_type 2
fog_offset 10
fog_alt 2
}
PERSISTENCE OF VISION RAYTRACER 145

Figura 50: Se pueden conseguir resultados bastante buenos

usando múltiples capas de niebla

Puedes combinar nieblas de densidad constante, de suelo, nieblas filtrantes y no filtrantes, nieblas
translúcidas, etc.

4.10.3.7. La niebla y los objetos vacíos

Siempre que uses la característica fog y la cámara se encuentre dentro de un objeto no vacío no
obtendrás ningún efecto de niebla. Para una explicación detallada de porque ocurre esto ver "Objetos
Vacíos y Objetos Sólidos"

Para evitar este problema debes hacer que todos esos objetos sean vacíos asegurándote de que la cámara
se encuentra fuera de ellos (usando el identificador inverse) o añadiéndoles el identificador hollow
(que es mucho más fácil).

4.10.4. La atmósfera
Nota importante: la atmósfera es una característica experimental de POV-Ray 3.0. Hay una alta
probabilidad de que el diseño e implementación de estas características cambie en futuras versiones. No
podemos garantizar que las escenas que las usen den los mismos resultados en futuras versiones o que
se mantenga la compatibilidad de la sintaxis del lenguaje.

La atmósfera puede ser usada para modelar la interacción de la luz con las partículas suspendidas en el
aire. Los rayos de luz se volverán visibles y los objetos proyectarán sombras sobre la niebla o el polvo
del aire.

El modelo atmosférico usado en POV-Ray supone una densidad constante de partículas en todos los
puntos excepto en los objetos sólidos. Si quieres crear nieblas o humos con la apariencia de nubes
deberás usar la propiedad halo de las texturas descrita en la sección "Halos".

4.10.4.1. Empezando con una habitación vacía

Queremos crear una escena simple para explicar como funciona el efecto atmósfera y como puedes
obtener buenos resultados.
4. TUTORIAL PARA PRINCIPIANTES 146

Imagina una sencilla habitación con una ventana. La luz entra a través de la ventana y es dispersada por
las partículas de polvo que flotan en el aire. Lo que verías serían unos rayos de luz provenientes de la
ventana reflejandose sobre el suelo.

Queremos modelar esta escena paso a paso. Los ejemplos siguientes empiezan con la habitación, la
ventana y un foco (spotlight) en algún lugar en el exterior de la habitación. De momento no hay
ninguna atmósfera para que podamos verificar si la iluminación es la correcta (ATMOS1.POV).
camera {
location <-10, 8, -19>
look_at <0, 5, 0>
angle 75
}

background { color rgb <0.2, 0.4, 0.8> }

light_source { <0, 19, 0> color rgb 0.5 atmosphere off }

light_source {
<40, 25, 0> color rgb <1, 1, 1>
spotlight
point_at <0, 5, 0>
radius 20
falloff 20
atmospheric_attenuation on
}

union {
difference {
box { <-21, -1, -21>, <21, 21, 21> }
box { <-20, 0, -20>, <20, 20, 20> }
box { <19.9, 5, -3>, <21.1, 15, 3> }
}
box { <20, 5, -0.25>, <21, 15, 0.25> }
box { <20, 9.775, -3>, <21, 10.25, 3> }
pigment { color red 1 green 1 blue 1 }
finish { ambient 0.2 diffuse 0.5 }
}

Figura 51: La sencilla habitación con la que queremos empezar

La fuente de luz puntual se ha usado para iluminar la habitación desde el interior sin ninguna
interacción con la atmósfera. Esto se hace añadiendo atmosphere off. No nos tendremos que
preocupar de esta fuente de luz cuando añadamos la atmósfera más tarde.
PERSISTENCE OF VISION RAYTRACER 147

Hemos añadido el identificador atmospheric_attenuation al foco. Esto significa que la luz

proveniente de este será atenuada por la atmósfera.

El objeto unión es usado para modelar la habitación y la ventana. Ya que usamos la diferencia entre dos
cajas para modelar la habitación (las primeras dos cajas en la declaración difference) no hay
necesidad de usar el identificador hollow. Si estamos dentro de esta habitación, estaremos fuera del
objeto (ver también "Usando Objetos Vacíos y la Atmósfera").

4.10.4.2. Añadiendo polvo a la habitación

El siguiente paso es añadir una atmósfera a la habitación. Esto se consigue con las siguientes líneas
(ATMOS2.POV).
atmosphere {
type 1
samples 10
distance 40
scattering 0.2
}
El identificador type selecciona el tipo de dispersión atmosférica que queremos usar. En este caso
usamos la dispersión isotrópica que dispersa la luz de igual forma en todas las direcciones (ver "La
atmósfera" para más detalles acerca de los diferentes tipos de dispersión).

El identificador samples determina el número de muestras a acumular para calcular el efecto

atmosférico. Por cada rayo se toman una serie de muestras a lo largo de este para determinar si la
muestra está iluminada o no por una fuente de luz. Si la muestra está iluminada, se determina la
cantidad de luz dispersada en la dirección del observador y es añadida a la intensidad total.

Siempre puedes empezar con un número arbitrario de muestras. Si los resultados no te satisfacen,
puedes incrementar la tasa de muestreo para obtener mejores resultados. El problema de elegir una
buena tasa de muestreo es mantener el equilibrio entre una imagen satisfactoria y una rápido trazado.
Una alta tasa de muestreo casi siempre funcionará bien, pero el trazado de la imagen también consumirá
mucho tiempo. He aquí algo con lo que experimentar.

El identificador distance especifica la densidad de la atmósfera. Funciona del mismo modo que el
parámetro distance del efecto niebla (fog).

Por último pero no menos importante, el valor del identificador scattering determinará la cantidad
de luz que es dispersada por las partículas (la luz restante es absorbida). Como verás más tarde este
parámetro es muy útil para ajustar el brillo medio de la atmósfera.
4. TUTORIAL PARA PRINCIPIANTES 148

Figura 52: Después de añadir algo de polvo, los rayos de luz se

tornan visibles

Observando la imagen creada a partir de la escena anterior notarás algunos efectos de aliasing bastante
desagradables conocidos como mach-bands. Son el resultado de una baja tasa de muestreo.

4.10.4.3. Eligiendo una buena tasa de muestreo

Como has visto, una tasa de muestreo demasiado baja causa efectos desagradables. Hay formas de
reducir o incluso eliminar estos problemas.

Una posible solución es incrementar la tasa de muestreo hasta que los efectos desaparezcan y obtengas
una imagen satisfactoria. A pesar de que esto siempre funcionará, es una mala idea debido a que
consume demasiado tiempo. Una mejor aproximación al problema es usar primero las técnicas de
jittering y anti-aliasing. Si esto no funciona, tendrás que incrementar la tasa de muestreo.

La técnica de jittering mueve cada punto una pequeña y aleatoria cantidad sobre la dirección de
muestreo. Esto ayuda a reducir la regularidad resultante del aliasing. Difícilmente habrá algo más
molesto para el ojo humano que los efectos de una baja tasa de muestreo. Es mucho mejor añadir algo
de aleatoriedad a las posiciones de las muestras.

Usa el identificador jitter seguido de la cantidad de jittering que quieres usar. Son recomendables los
valores hasta 0.5.

Deberías tener en cuenta el hecho de que el jittering no puede ocultar totalmente los efectos resultantes
de una tasa de muestreo demasiado baja. En todo caso puede hacerlos menos visibles.

Adicionalmente, un mejor método para reducir los efectos del aliasing es usar el super-muestreo
adaptativo. Este método toma muestras adicionales donde es posible que sean necesarias. Si la
intensidad de dos muestras adyacentes difiere mucho, son tomadas muestras adicionales en un punto
intermedio. Este paso se ejecuta de forma recursiva hasta que es alcanzado un nivel de recursión
específico o la muestra tomada se acerca demasiado a otra adyacente.

Los identificadores aa_level y aa_threshold dan control absoluto sobre el proceso de

super-muestreo. El identificador aa_level determina el nivel máximo de recursión mientras que
PERSISTENCE OF VISION RAYTRACER 149

aa_threshold especifica la diferencia máxima permitida entre dos muestras antes de que el
super-muestreo tenga lugar.

Después de esta parte teórica volvemos de nuevo a nuestra escena de muestra y añadimos los
identificadores apropiados para usar ambas técnicas, jittering y super-muestreo (ATMOS3.POV).
atmosphere {
type 1
samples 50
distance 40
scattering 0.2
aa_level 4
aa_threshold 0.1
jitter 0.2
}
Se eligió un valor muy bajo para threshold para que se efectúe el super-muestreo incluso entre puntos
adyacentes de intensidad muy similar. El nivel máximo de recursión de 4 resultará en un máximo de 15
super-muestreos.

Si observas los resultados que obtienes después de añadir jittering y super-muestreo seguramente no
estarás satisfecho. La única forma de reducir los defectos todavía visibles es incrementar la tasa de
muestreo eligiendo un número mayor de muestras.

Figura 53: Una alta tasa de muestreo nos lleva a una imagen
satisfactoria

Haciendo esto obtendrás un buen resultado sin (casi) ningún defecto. Por otro lado la cantidad de polvo
flotando en esta habitación puede ser un poco exagerada pero solo es un ejemplo y los ejemplos tienden
a ser exagerados.

4.10.4.4. Usando una atmósfera coloreada

Puedes asignar un color a la atmósfera, lo que te da un mayor control sobre su apariencia. El color se
usa para filtrar la luz que pasa a través de él, ya venga de una fuente de luz, rayos reflejados o
refractados o del fondo. La cantidad de luz filtrada por el color de la atmósfera se determina con el
valor de filtro (filter) de este. Un valor de 0 significa que la luz no es influenciada por el color de la
atmósfera, mientras que un valor de 1 significa que toda la luz será filtrada por el color.
4. TUTORIAL PARA PRINCIPIANTES 150

Si, por ejemplo, quieres crear una atmósfera rojiza, puedes añadir la siguiente línea a la declaración de
atmósfera usada en el ejemplo anterior.
color rgbf <1, 0, 0, 0.25>
Usando solamente rgb <1,0,0> no funcionaría debido a que el valor de filtro del color sería cero y
no filtraría la luz, es decir, el color de esta no sería multiplicado por los valores de la componente RGB.

El valor de filtro de 0.25 significa que un 25% de la luz que pasa a través de la atmósfera será filtrada
por el color rojo y el 75% restante pasará sin ser filtrada.

El canal de transmitancia del color de la atmósfera se usa para especificar la translucidez mínima. Por
defecto el canal de transmitancia es cero y por lo tanto no existe tal translucidez mínima. Usando un
valor positivo te permite determinar la cantidad de luz que siempre pasará a través de la atmósfera sin
tener en cuenta su grosor determinado por el identificador distance.

Si usas un color rgbt <0,0,0,0.3> con nuestra habitación de ejemplo, puedes hacer que el fondo
azul sea visible. Hasta ahora estaba oculto debido a la atmósfera.

4.10.4.5. Consejos usando la atmósfera

Es muy difícil obtener resultados satisfactorios cuando usamos el efecto atmósfera. Algunos de los
problemas más comunes serán discutidos en las siguientes secciones para ayudarte a resolverlos (ver
también la sección de “Preguntas Frecuentes” sobre la atmósfera en “Preguntas sobre la atmósfera”).

4.10.4.5.1. Eligiendo los parámetros de distancia y dispersión

El primer paso difícil es elegir unos buenos valores para la distancia (distance) y la dispersión
(scattering). Necesitas poder controlar la visibilidad de los objetos en la escena y los efectos
atmosféricos.

La mejor solución es elegir primero el valor de distance. Este valor determina la visibilidad de los
objetos en la escena sin tener en cuenta la dispersión de la luz. Funciona de igual forma que el valor
distance del efecto niebla (fog).

Ya que la niebla es muy similar a la atmósfera, excepto en lo que se refiere a la iluminación, podemos
usarla en lugar de la atmósfera para elegir un valor para la distancia. Si haces esto con la escena de la
habitación que usamos antes, podrías usar la siguiente declaración de niebla en lugar de la atmósfera
(ATMOS4.POV).
fog {
distance 40
color rgb <0, 0, 0>
}
PERSISTENCE OF VISION RAYTRACER 151

Figura 54: Una niebla de color negro puede ser usada para
obtener un valor de distancia para la atmósfera

Se usa el color negro para simular la atenuación que obtendrías en las partes situadas a la de sombra en
la escena con la atmósfera.

Si quieres usar una atmósfera coloreada tendrás que usar el mismo color para la niebla que el que
quieres usar para la atmósfera, incluyendo los valores del filtro y del canal de transmitancia (ver
"Usando una atmósfera coloreada" y "La Atmósfera" para una explicación del color de la atmósfera).

Si quieres simular la apariencia de esas partes iluminadas por una fuente de luz, puedes usar el color de
la atmósfera en la declaración de la niebla.

Una vez estés satisfecho con el valor de distancia tendrás que elegir una valor de dispersión
(scattering). Este valor te permite adecuar la intensidad de la atmósfera a tus necesidades.
Empezando con un valor de uno deberás aumentarlo si los efectos atmosféricos son difícilmente
visibles. Si no ves nada en las partes iluminadas de la atmósfera, tendrás que decrementar el valor.

Deberías tener en cuenta que quizás tengas que usar valores muy grandes o muy pequeños para obtener
los resultados deseados.

4.10.4.5.2. La atmósfera y las fuentes de luz

Los mejores resultados se obtienen con los focos cónicos y cilíndricos. Crean buenos rayos de luz y son
fáciles de trazar debido a que el muestreo atmosférico solo tiene lugar dentro del cono o del cilindro.

Si quieres añadir una fuente de luz que no interactúe con la atmósfera puedes usar el identificador
atmosphere dentro de la declaración de la fuente de luz (ver "Interacción con la atmósfera").
Simplemente añade atmosphere off.

Por defecto la luz proveniente de cualquier fuente no será disminuida por la atmósfera. De esta manera
los reflejos en tu escena serán normalmente demasiado brillantes. Esto puede ser cambiado con la
declaración
atmospheric_attenuation on.
4. TUTORIAL PARA PRINCIPIANTES 152

4.10.4.5.3. Tipos de dispersión atmosférica

Los diferentes tipos de dispersión listados en "La atmósfera" pueden ser usados para modelar distintos
tipos de partículas. Esto es algo con lo que puedes experimentar.

La dispersión Rayleigh se usa para partículas pequeñas como polvo o humo, mientras que la dispersión
Mie se usa para la niebla.

Si alguna vez has visto la escena del faro en la película Casper sabrás que efecto tiene el tipo de
dispersión. En esta escena el rayo de luz proveniente del faro se torna visible cuando apunta hacia el
observador y se va desvaneciendo según se aleja. Este comportamiento es típico de las minúsculas gotas
de agua que modela la dispersión Mie.

4.10.4.5.4. Incrementando la resolución de la imagen

Debes tener en cuenta que quizás debas incrementar la tasa de muestreo de la atmósfera si incrementas
la resolución de la imagen. De otra manera puede que aparezcan algunos efectos del aliasing que no
eran visibles con una resolución más baja.

4.10.4.5.5. Usando Objetos Vacíos y la Atmósfera

Siempre que uses el efecto atmósfera tendrás que asegurarte de que todos los objetos que deberían ser
rellenados con la atmósfera son declarados vacíos mediante el identificador hollow.

Esto también se mantiene para los objetos infinitos como quadric, quartic, triangle, polygon, etc. Donde
quiera que uses uno de estos objetos deberías añadir el identificador hollow, siempre que no estés
absolutamente seguro de que no lo necesitas. También debes asegurarte de que todos los objetos dentro
de los cuales se encuentra la cámara son declarados vacíos.

Donde quiera que obtengas resultados inesperados deberías revisar los objetos sólidos y declararlos
como vacíos.