• Nivel: basico
  
  
  -o-
  
  
  
  POV-Ray
  
  Tutorial Nº1
  
  
  
  Jerarquías
  
  (nivel Básico)
  
  
  
  -o-
  
  
  
  Capítulo 1
  
  A papá...
  
  
  
  En nuestro anterior Tutorial, el primero de esta serie, aprendimos los conceptos básicos de POV-Ray, llámese la cámara, las luces y lo primordial en cuanto a Declaraciones se refiere; pero para ello utilizamos una miserable columna compuesta por tres patéticos cilindros.
  
  
  
  ¡Pues bien, ya es hora de aprender sobre la marcha!
  
  
  
  A partir de ahora, aprenderemos mientras diseñamos cosas más interesantes que una pobre colección de columnas. Así que basta de introducciones y adelante con la acción.
  
  
  
  En este Tutorial comenzaremos a estudiar los conceptos de Jerarquías en POV-Ray. Una Jerarquía funciona de manera similar a los objetos Padres e Hijos, pero con una "vuelta de POV". Así, si un objeto Padre tiene una modificación (una Traslación, una Rotación, etc), todos sus Hijos sufrirán el mismo efecto.
  
  
  
  El mejor ejemplo de jerarquías Padre-Hijo lo tenemos al alcance de la mano. De hecho, todo nuestro brazo (todo nuestro CUERPO, pero con el brazo bastará) es un complejo sistema de Padres e Hijos: los dedos se mueven sin afectar a la mano, pero la mano no puede moverse sin mover todos los dedos en la misma dirección. Luego, la mano se conecta con el antebrazo, y el antebrazo con el brazo.
  
  
  
  Pero no empezaremos con algo tan complejo como eso. Las jerarquías pueden estudiarse mucho mejor con un ejemplo muy sencillo y bastante ameno, el cual se detalla a continuación...
  
  
  
  -o-
  
  
  
  Capítulo 2
  
  Mambrú se fue a la guerra... y se llevó POV-Ray
  
  
  
  ¡Todo el mundo a las trincheras! Estamos metidos en medio de una sugestiva guerra virtual, pero nuestras tropas no cuentan con suficientes edificaciones de defensa. ¡Eso no puede ser! ¿Así está la cosa? Pues si esto es una guerra virtual, nuestras defensas serán generadas por computadora. ¡Vamos, al ataque!
  
  
  
  La misión, pues, es diseñar algún sistema de defensa para nuestros cuarteles. ¿Alambradas eléctricas? Tal vez en otro Tutorial. ¿Campos minados? Lindo, pero no se verían bien al caso.
  
  
  
  ¿Torretas con cañones? ... ... ... ¡Sí, eso es! ¡Vamos a diseñar unas lindas torretas con todo y cañón!
  
  
  
  Bien, ya tenemos la idea general, pero, ¿dónde entran las jerarquías? Ah, pues en el movimiento del cañón. Nuestra torreta constará de una "cúpula" que podrá rotar 360 grados. La cúpula tendrá un cañón que girará junto con ella, pero que además podrá variar su ángulo de disparo.
  
  
  
  Ahora sí. Tenemos la idea y el diseño básico... ¡Vamos a codificar!
  
  
  
  -o-
  
  
  
  Capítulo 3
  
  Comprensión de Piezas
  
  
  
  Antes de empezar a tipear nuestra torreta, será bueno diferenciar sus Piezas. Yo considero una "Pieza" a un elemento individual de un objeto. Es decir, un objeto que puede separarse, como el casco de un motociclista, o el propio motociclista de su moto.
  
  
  
  Nuestra torreta contará con tres Piezas: una BASE en la que se apoyará la cúpula; la CÚPULA con un corte para el cañón; y, por supuesto, el CAÑÓN.
  
  
  
  Lo que vamos a hacer es Declarar cada una de estas Piezas, y luego las "ensamblaremos" para formar nuestro pequeño juguete. Ahora sí, manos a la obra.
  
  
  
  -o-
  
  
  
  Capítulo 4
  
  La cúpula
  
  
  
  Comenzaremos por abrir el archivo BASE.POV que generamos en el Tutorial anterior e inmediatamente lo guardaremos como TUTORIAL_01.POV.
  
  
  
  Bien, ahora vamos a empezar la construcción de nuestra torreta de defensa, y para ello vamos a diseñar la cúpula de la misma. La cúpula está formada por una simple esfera y un simple cilindro, pero aquí usaremos la función Difference para realizar un "corte" en el objeto resultante. Este corte servirá para asomar el cañón y delimitar visualmente sus posibilidades de movimiento.
  
  
  
  Aquí tienen el código del diseño de la cúpula o coraza:
  
  
  
difference {



//Primer objeto del bloque Difference (objeto a cortar)

merge {

sphere { <0,0,0>, 3 }

cylinder { <0,0,0>, <0,-2,0>, 3 }

}



//Segundo objeto del bloque Difference (objeto de corte)

merge {

box { <1, 0, 0>, <-1, 4, -4> }

sphere { <0,0,0>, 1 }

cylinder { <0,0,0>, <0,4,0>, 1 }

cylinder {

<0,0,0>,

<0,4,0>,

1



rotate x*-90

}

}



//Damos color y retoques...

pigment { rgb <0, 0.75, 0> }

finish { phong 0.5 }



//Elevamos todo 2 UPV en el eje Y...

translate y*2

}

  
  
  Guarden y rendericen. Podemos ver la coraza de nuestra torreta con un "tajo" en su superficie. Antes de continuar, deseo dar una breve explicación del bloque Difference:
  
  
  
  Ya habíamos visto el bloque Union, que permite agrupar una serie de objetos individuales en su interior. Bueno, los bloques Merge y Difference funcionan de igual manera, salvo que estos dos poseen propiedades especiales.
  
  
  
  Los bloques Merge trabajan de forma idéntica a los Union, pero con la diferencia de que en un bloque Merge, todos los "trozos superpuestos" de dos o más objetos serán eliminados. Es decir, si superpongo la mitad de una esfera dentro de un cubo, ese "objeto superpuesto" será eliminado, obteniendo así un objeto compuesto que no será ni una esfera ni un cubo. Aunque a primera vista no se aprecian diferencias entre Merge y Union, sí se apreciarán cuando hagan que sus objetos compuestos sean transparentes, ya que entonces se verán todas las areas superpuestas, cosa que no ocurre con los bloques Merge.
  
  
  
  En los bloques Difference tendremos que poner al menos dos objetos. El primer objeto será el "objeto a cortar", y todos los objetos que pongamos a continuación le irán restando pedazos al primero. Eso es lo que hicimos aquí: observen que el primer objeto es muy simple; una esfera con un cilindro. Sin embargo, el objeto de corte se superpone de forma tal que, gracias al bloque Difference, produce un corte en la coraza de nuestra torreta.
  
  
  
  Hagan la prueba de cambiar "difference" por "merge" y rendericen de nuevo. ¿Ya ven a qué me refiero? ;-)
  
  
  
  Vuelvan a poner "difference" en lugar de "merge" para continuar.
  
  
  
  -o-
  
  
  
  Capítulo 5
  
  El cañón
  
  
  
  Antes de empezar con nuestro cañón, vamos a determinar la coraza como una Pieza independiente. Solamente deben agregar la siguiente línea, justo sobre la apertura del bloque Difference:
  
  
  
#declare Coraza =
  
  
  
  Guarden y rendericen. ¿Qué pasó? Pues que nuestra coraza ha pasado a ser un objeto declarado, y por lo tanto no aparecerá hasta que no le llamemos. ;-)
  
  
  
  Ahora sí, vamos a diseñar nuestro cañón. Éste contará con una serie de cilindros y nada más. Habrá un cilindro principal que funcionará como "eje" de rotación, y de éste saldrá el cañón en sí. Aquí está el código, el cual deben copiar DEBAJO de la declaración de la coraza:
  
  
  
union {

//Llamamos al objeto Coraza...

object { Coraza }



difference {



//Este es el cañón "en bruto"...

merge {

cylinder { <0,-1,0>, <0,1,0>, 2.5 rotate z*90}



cylinder { <0,0,0>, <0,5,0>, 0.75}

cylinder { <0,0,0>, <0,2,0>, 1 translate y*5}

}



//Este cilindro hace el "corte" del cañón (el agujero)...

cylinder { <0,0,0>, <0,7.1,0>, 0.5}



rotate x*0 //Este Rotate hace inclinar el cañón...



//Elevamos todo 2 UPV en el eje Y...

translate y*2



//Damos color y retoques al cañón...

pigment { rgb <0.75, 1, 0> }

finish { phong 0.5 }

}

}

  
  
  Guarden y rendericen. Como ven, nuestra torreta ya tiene algo con qué disparar, pero en esa posición no podemos verlo bien. Vamos a hacer una mínima modificación en el código anterior: cambien el valor de Rotate de inclinación del cañón a -30, guarden y rendericen. ¡Eh, hemos cambiado la posición de ataque!
  
  
  
  Esa rotación hace que el cañón se incline. Tenemos un rango de inclinación que va desde el 0 hasta el -90. Si le damos valores superiores a 0 ó inferiores a -90, veremos que nuestro cañón se superpone con la coraza, lo cual es totalmente ilógico. Por lo tanto debemos recordar no pasarnos de dicho rango de valores.
  
  
  
  Prueben algunos valores de rotación antes de continuar. Es divertido. :-P
  
  
  
  -o-
  
  
  
  Capítulo 6
  
  La base
  
  
  
  La base de nuestra torreta es la cosa más sencilla del mundo, pero tiene la finalidad de que nos dará un nuevo eje de giro. Pero antes, vamos a declarar nuestro cañón. Añadan el siguiente código justo encima de la definición del cañón (el bloque Union principal del mismo):
  
  
  
#declare Canion =
  
  
  
  Guarden y rendericen, y ya no hay nada en pantalla. Pues bien, vamos a colocar la base, que es un código tan simple que hasta da vergûenza. Si no me creen, miren lo que hay que copiar justo debajo de la declaración del cañón:
  
  
  
union {



//Llamamos al Cañón (que a su vez llama a la Coraza)...

object {

Canion



rotate y*0 //Este Rotate hace girar el Cañón junto con la Coraza...



translate y*1

}



//Colocamos la base... ¡un miserable CONO!

cone {

<0, 1, 0>, 3.25,

<0, 0, 0>, 4



pigment { rgb <0, 0.5, 0> }

finish { phong 0.5 }

}

}

  
  
  Guarden y rendericen. Eso que ven ahí es nuestra torreta ya terminada. Sí, de verdad, está lista, pero... ¿cómo hacemos que gire? Pues modificando el valor del Rotate en el bloque Object de esta última sección de código. Cambien el valor a 45 y observen la diferencia.
  
  
  
  Para poder apreciar una mejor diferencia, el cañón debería estar levemente inclinado, y no en la posición cero inicial. Aquí nos damos cuenta que modificar valores de Rotate puede resultar muy frustrante, y eso que nosotros apenas estamos lidiando con dos. ¡Imagínense para objetos más complejos! Por ese motivo, lo que vamos a hacer es ordenar un poco las cosas.
  
  
  
  Vamos a aprender a usar Variables. ;-)
  
  
  
  -o-
  
  
  
  Capítulo 7
  
  Vamos a organizarnos, ¿tsí?
  
  
  
  Las Variables pueden resultar muy útiles a la hora de organizar trabajos complejos. Si las usamos bien nos evitarán tener que recorrer todo el extenso código de un objeto monumentalmente articulado. Podemos simplemente reemplazar valores por variables y controlarlas a todas desde una posición cómoda.
  
  
  
  En nuestra torreta tenemos dos valores que definen el movimiento de las Piezas: el valor de inclinación del cañón (de 0 a -90) y el valor de giro del cañón y la coraza (de 0 a 360). Por lo tanto, vamos a declarar dos variables para controlar estos movimientos.
  
  
  
  Justo antes de la declaración de la Coraza (supuestamente la primer Pieza del archivo) copiaremos lo siguiente:
  
  
  
#declare a_canion = 0;

#declare a_cupula = 0;
  
  
  
  Como ven, las variables se declaran de la misma forma que las Piezas, es decir, con una sentencia Declare. Noten, eso sí, que este tipo de declaración terminan sí o sí con punto y coma.
  
  
  
  Con esto hemos declarado dos variables, pero no las hemos usado en nuestra torreta. Remediaremos eso de inmediato. Dirijámonos a la declaración del cañón, donde reemplazaremos la línea de Rotate de esta forma:
  
  
  
rotate x*a_canion
  
  
  
  Luego iremos a la declaración de la base, donde reemplazaremos el Rotate del conjunto cañón-coraza por esta línea:
  
  
  
rotate y*a_cupula
  
  
  
  Guarden y rendericen. Como verán, el cañón aparece apuntando hacia arriba y la coraza nos apunta a nosotros. Ahora ya no debemos movernos a lo largo del código para cambiar valores, sino que los tenemos en la parte de arriba, todos juntos. Hagan la prueba de cambiar los valores de las variables a_canion y a_cupula y rendericen para ver los resultados. ¿Se dan cuenta cómo facilita las cosas?
  
  
  
  -o-
  
  
  
  Capítulo 8
  
  Advertencias y consejos
  
  
  
  Con esto damos con culminado el Tutorial 01 de Jerarquías (nivel Básico), aunque primero les dejaré algunos consejos al respecto.
  
  
  
  Como apreciamos en este Tutorial, el funcionamiento de una Jerarquía procede del movimiento independiente o dependiente de las diferentes piezas de un objeto. Así, nuestra torreta tiene dos piezas móviles: un cañón que puede apuntar hacia arriba y hacia abajo, pero que se ve afectado por el movimiento giratorio de la coraza, que puede girar independientemente de lo que apunte el cañón. Algo así como el dedo de una mano, para hacerlo más entendible.
  
  
  
  Nustro cañón, hay que decirlo, presenta fallas. La más obvia de ellas es la falta de limitación en el ángulo de inclinación del cañón, ya que si así lo deseamos podríamos darle a la variable a_canion valores superiores a 0 ó inferiores a -90 (hagan la prueba y vean qué raro se ve). Es posible PROGRAMAR nuestro cañón para que no acepte valores fuera de un rango establecido, pero por el momento nos contentaremos con esto que hemos logrado.
  
  
  
  Hemos aprendido un poco acerca de las jerarquías, pero en el siguiente Tutorial daremos un paso al frente y generaremos un objeto de piezas Padre-Hijo mucho más complejo, así que... ¡hasta la próxima!
  
  
  
  EJERCICIO: No me podía ir sin darles algo con qué entretenerse. ;-) El ejercicio de hoy es de creatividad. Yo diseñé una torreta con 90 grados de tolerancia de inclinación y un sólo cañón. ¿Pueden ustedes crear sus propias torretas? Pueden incluir más cañones o cualquier otra cosa que se les ocurra, pero sólo debe permitir dos movimientos: el de inclinación (cañón) y el de giro (coraza + cañón).
  
  
  
  Es más; si se animan a hacer algo, me gustaría ver los resultados. Pueden intentar dejar sus imágenes en este thread del foro Gamesario. (link)
  
  
  
  
  
  
  ¡Mucha suerte!
  
  
  
  -o-
  
  
  
  Fin del Tutorial Nº1
  
  
  
  -o-
  | Enviado por: Megawacky_Max - El día: 11/1/06 - 09:28:15 |

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)