• Nivel: basico
  -o-
  
  POV-Ray
  Tutorial Nº0
  
  Reusabilidad
  
  -o-
  
  Capítulo 1
  Luz, Cámara y Objetos
  
  En este primer Tutorial vamos a estudiar el concepto de Reusabilidad de objetos dentro de un mismo archivo POV. Pero antes de dedicarnos de lleno a esto vamos a ver un poco el tema de las luces y la cámara.
  
  Toda escena en POV-Ray debe tener al menos tres elementos básicos: Luz, Cámara y Objetos. Veamos un esquema muy básico para entender esto:
  
  Abran un nuevo archivo POV, luego copien y peguen el siguiente fragmento de código:
  
  

  //---------------------------------------// // DISEÑO DE ESCENA: CÁMARA, LUZ Y PLANO // //---------------------------------------// camera { location <0, 10, -15> look_at <0, 0, 15> } light_source { <0, 100, -100> //Colocamos luz arriba y hacia atrás rgb 1.75 //Color RGB puesto a 1.75 (blanco brillante) parallel //Indicamos que es LUZ PARALELA point_at <0, 0, 0> //Indicamos a dónde apunta la fuente de luz paralela } plane { y, 0 pigment { checker rgb 1, rgb 0.75 } }

  
  
  Luego guarden el archivo como BASE.POV. A partir de este momento, BASE.POV será nuestro archivo base para muchos de los siguientes tutoriales. Pero bien, hagamos la prueba de renderizar esta escena. ¿Qué ha ocurrido? Vemos un plano cuadiculado infinito, eso es lo que vemos.
  
  El código que copiamos arriba es una combinación de Luz (luz paralela, similar a la del sol, proveniente desde atrás), Cámara (cámara en posición (X=0; Y=10; Z=-15) y apuntando a (X=0; Y=0; Z=15)) y un Objeto (un plano perpendicular al eje Y). El plano será nuestro "suelo" en nuestros Tutoriales, y su textura de cuadriculado nos vendrá muy bien para tomar medidas y referencias, pues cada cuadrado tiene 1x1 Unidades POV de tamaño.
  
  Las Unidades POV son los valores de tamaño que tomarán nuestros Objetos. Por ejemplo, vemos que la Cámara se ubica a 15 Unidades POV (UPV desde ahora para referirnos a Unidad POV) respecto al "suelo" (siendo el "suelo" el valor 0 UPV del eje Y).
  
  Cuando un POV-Maníaco (es una buena terminología, de verdad) intenta representar en POV-Ray un objeto del mundo Real o de su propia invención, un tema muy importante es la escala adoptada en el mismo. Muchas veces se toma el UPV como unidad de centímetro, por lo que 100 UPV = 1 Metro. Si queremos representar cosas muy grandes, sin embargo (tal es el caso de un edificio o una enorme nave espacial), esa escala nos demandará valores enormes, por lo que muchos terminarán aceptando que 1 UPV = 1 Metro (por lo tanto, 1 cm sería 0.01 UPV).
  
  El gran problema con las escalas en POV-Ray se presentará cuando queramos incluir objetos de archivos ajenos al nuestro. Supongamos que nosotros diseñamos una habitación vacía y queremos usar los muebles diseñados por otro usuarios y que se encuentran en un archivo INC ajeno (los archivos INC, o de Inclusión, se usan para "compartir objetos" entre escenas POV y, por qué no, entre otros usuarios). Cuando pasemos ese hermoso armario del archivo MUEBLES.INC a nuestra CASA.POV podríamos llevarnos la sorpresa de que el armario es diez veces más pequeño que la habitación a la que lo asignamos. Esto se debe enteramente a un conflicto de escalas entre usuarios.
  
  Lo mejor que se puede hacer, especialmente en archivos INC (los cuales no los trataremos hasta dentro de varios Tutoriales más), es informarle al usuario sobre la escala adoptada en los objetos de ese archivos, así él sabrá con qué se mete y cómo utilizarlos correctamente.
  
  -o-
  
  Capítulo 2
  Te Declaro... Columna
  
  Ahora sí, vamos a dedicarnos al primer Tutorial. Abran el archivo BASE.POV que creamos recientemente y guárdenlo bajo el nombre TUTORIAL_00.POV. Vamos a trabajar en este archivo.
  
  Este "Tutorial Cero" se referirá a una de las herramientas más útiles de POV-Ray: la Declaración de objetos. La sintáxis se escribirá de la siguiente manera:
  
  

  #declare (nombre_ojeto) = (código_objeto)

  
  
  La sentencia Declare guarda en memoria un fragmento de código, el cual es invocado a escena en el momento en que lo llamamos. Esto resulta tremedamente útil a la hora de colocar objetos idénticos en una misma escena. En lugar de copiar y pegar un extenso código para cada silla alrededor de una mesa (por ejemplo), podemos simplemente diseñar una sola silla y Declararla, y luego invocarla repetidamente con un mínimo de código añadido.
  
  Cabe mencionar que la sentencia Declare también sirve para definir Variables para nuestro código. Este tema no lo trataremos aquí, ya que por el momento no tendremos necesidad de trabajar con Variables. En futuros Tutoriales, sin embargo, usaremos Variables a cada rato.
  
  Bien, en nuestro Tutorial Cero, pues, vamos a declarar algo mediante la sentencia Declare, y posteriormente lo colocaremos repetidamente en la escena. Haremos una columna, algo sencillo y fácil de apreciar.
  
  Copien y peguen el siguiente código al final del archivo TUTORIAL_00.POV...
  
  

  #declare Columna = union { //INICIO del bloque union //Base de la columna cylinder { <0.0, 0.0, 0.0>, //Inicio del cilindro <0.0, 0.5, 0.0>, //fin del cilindro 2 //Radio del cilindro } //Cuerpo de la columna cylinder { <0.0, 0.0, 0.0>, //Inicio del cilindro <0.0, 3.0, 0.0>, //fin del cilindro 1.5 //Radio del cilindro //Ahora le indicamos que eleve esta pieza en su lugar translate y*0.5 //<--- Altura de la base } //Tope de la columna cylinder { <0.0, 0.0, 0.0>, //Inicio del cilindro <0.0, 0.5, 0.0>, //fin del cilindro 2 //Radio del cilindro //Ahora le indicamos que eleve esta pieza hasta el tope translate y*3.5 //<--- Altura de la base + Altura del cuerpo } //Eso es todo. No agregamos nada de color (ver más adelante) } //FINAL del bloque union

  
  
  El código parece complejo, pero en realidad está colmado de comentarios para facilitar su comprensión. Aquí utilizamos un bloque Union para agrupar tres cilindros, uno encima del otro, para que asemejen una columna de 4 UPV de altura en total (dos cilindros de 0.5 UPV en cada extremo y un "cuerpo" de 3 UPV).
  
  Ahora hemos declarado nuestra columna. Guarden el archivo y rendericen.
  
  ¿¿Dónde está la columna??
  
  ¡Pero claro, si ni siquiera la invocamos en escena! Vamos, entonces, a llamar a nuestra columna. Para ellos usaremos el bloque Object como se verá a continuación:
  
  

  object { Columna }

  
  
  Copien y pequen ese sencillo código justo después de la declaración de la columna. Guarden y rendericen la escena. ¡Ah, allí está la columna! Ahora hagamos una pausa para analizar la imagen obtenida...
  
  Cuando invocamos un objeto declarado devemos recordar que POV-Ray es Caps-Sensitive. Es decir, diferenciará mayúsculas de minúsculas. Muchas veces pueden ocurrir errores de sintaxis basados únicamente en escribir "casa" en lugar de "Casa". Mucho ojo a este dato, pues es el error más común (y a veces exasperante) de la vida diaria del POV-Maníaco promedio.
  
  Ahora veamos la columna obtenida. Es enteramente negra. El negro más absoluto. No hay luz que pueda sacarle un brillo. Esta columna mas bien parece un hueco en el Universo POV. Si revisamos el código de la declaración de la columna, veremos que, al final del mismo, hay una llamada de atención respecto al color asignado. ¡No hay color asignado! Por defecto, POV-Ray le da el valor Nulo, que es el que vemos en escena.
  
  Ahora veremos que el bloque Object puede ser manipulado a gusto. Exactamente debajo del pequeño código de nuestra columna negra, colocaremos el siguiente nuevo código:
  
  

  object { Columna pigment { rgb <0, 1, 0> //Color verde (Red = 0, Green = 1, Blue = 0) } translate x*-5 //Movemos esta columna 5 Unidades POV a la izquierda. }

  
  
  Guarden y rendericen. Ahora hay una columna verde a la izquierda de la pantalla.
  
  Analicemos esta última porción de código. Hemos vuelto a invocar a nuestra columna, pero ahora le hemos añadido dos atributos. El primero es el atributo de color (Pigment, o "pigmento"), el cuál lo hemos seteado a VERDE en la combinación RGB de colores. Por eso el color de la columna.
  
  El segundo atributo es el de posición. Por defecto, nuestra columna está diseñada para ubicarse en el punto exacto en que está la columna negra. Para la columna verde añadimos una sentencia de Traslación ("Translate"). Hemos movido la columna verde 5 UPV a la izquierda o, lo que es más preciso, en la dirección negativa del eje X.
  
  Pero, ¿desde dónde? Pues desde el punto originario de la columna. Es decir, desde la columna negra.
  
  Es muy importante tener siempre en claro desde dónde se mueven los objetos en POV-Ray. Cuando se Declaran objetos es altamente recomendable que éstos se ubiquen lo más próximos al Centro del Universo POV como sea posible, es decir, al punto X=0 Y=0 Z=0. De esta forma será más fácil trabajar con ellos al momento de invocarlos a escena.
  
  Pero bien, no sólo color y posición horizontal pueden tener nuestras columnas invocadas. Copien y peguen el siguiente fragmento de código, al final de nuestro archivo:
  
  

  /* Colocamos una columna a la derecha y le agregamos color rojo. También le cambiamos la escala. */ object { Columna pigment { rgb <1, 0, 0> //Color rojo (Red = 1, Green = 0, Blue = 0) } scale <1, 0.5, 1> //"Reescalamos" la columna. Los números indican la proporción, siendo 1 la //proporción original. El valor de esala Y es de 0.5, o sea que la columna roja //va a verse achatada a la mitad. //NOTA: "scale" y "rotate" se hacen siempre antes de "translate", ya que ambos //usan los ejes del Universo POV para modificar el objeto (o sea, trabajan con el //centro del Universo) translate x*5 //Movemos esta columna 5 Unidades POV a la derecha. } /* Colocamos una columna a la derecha y arriba de la roja, y le agregamos color amarillo. También le cambiamos la escala y le damos una terminación "normal" de granito. */ object { Columna pigment { rgb <1, 1, 0> //Color amarillo (Red = 1, Green = 1, Blue = 0) } normal { //"Normal" le da al objeto una terminación/textura a elegir. granite 1 //Elegimos la textura "granite" de POV-Ray y le damos una profundidad scale 2 //Reescalamos el "normal" por dos en todas las direcciones (igual a <2, 2, 2>) } scale <1, 0.5, 1> //"Reescalamos" la columna. Los números indican la proporción, siendo 1 la //proporción original. El valor de esala Y es de 0.5, o sea que la columna roja //va a verse achatada a la mitad. //NOTA: "scale" y "rotate" se hacen siempre antes de "translate", ya que ambos //usan los ejes del Universo POV para modificar el objeto (o sea, trabajan con el //centro del Universo) translate <5, 2, 0> //Movemos esta columna 5 Unidades POV a la derecha y 2 Unidades arriba. } /* Colocamos una columna a la izquierda y arriba de la verde, y le agregamos color violeta. También le damos una textura "checker". */ object { Columna pigment { checker rgb < 1, 0, 1>, //Color violeta (Red = 1, Green = 0, Blue = 1) rgb <0.5, 0, 0.5>, //Color violeta oscuro (Red = 0.5, Green = 0, Blue = 0.5) } translate <-5, 4, 0> //Movemos esta columna 5 Unidades POV a la izquierda y 4 Unidades arriba. }

  
  
  Guarden y rendericen la escena final de este Tutorial. Ahora pueden ver una colección de columnas de muchos colores e incluso con texturas. Al par de la derecha se las ha re-escalado en el eje Y, también.
  
  Recurden que todas estas columnas surgen de una sola, la original, la columna negra del centro. A partir de ese punto, y añadiendo atributos a los grupos Object, es posible modificar muchos aspectos de nuestros objetos Declarados.
  
  -o-
  
  Capítulo 3
  Algunos datos a considerar
  
  Ahora los dejo a ustedes para "jugar" con nuestra columna declarada. Intenten invocar las suyas, modificando sus atributos de color, posición, etc. La mejor forma de aprender es practicar, y aquí tienen la oportunidad de hacerlo.
  
  Una cosa que quiero agregar: eso de cambiar el color de un objeto declarado al momento de invocarlo es una técnica interesante, pero tiene un detallito: si ya se definió colores o texturas al momento de la Declaración, cualquier color o textura que agreguemos al momento de la invocación será texto inútil, ya que siempre prevalece el primer código.
  
  SIN EMBARGO, hay un truquito interesante: al momento de la Declaración podemos, por ejemplo, darle pigmentación a los dos cilindros extremos de la columna, pero no al "cuerpo". Entonces, al momento de invocar, los cilindros de los extremos permanecerán con los colores ya asignados, pero el cuerpo obedecerá a los bloques de pigmento o textura que se añadan.
  
  Esta técnica puede ser muy útil más adelante. Traten de no olvidarla.
  
  EJERCICIO: Y ahora les dejo un trabajito, así practican. Usando únicamente nuestra columna declarada, y por medio de bloques Object, tienen que construir una PIRÁMIDE de columnas. Intenten una con tres columnas de base, y vean cuánto más la pueden ampliar. ;-)
  
  
  -o-
  
  Fin del Tutorial Nº0
  
  
  
  
  
  -o- | Enviado por: Megawacky_Max - El día: 16/11/05 - 19:20:31 |

Los tutoriales publicados en esta seccion son creados por miembros del staff de DiseñAr y esta prohibida su reproduccion completa o parcial, a menos que se cite al autor y la fuente (DiseñAr)