En algunos tutoriales anteriores de OpenGL se han mencionado de manera fragmentaria los conceptos de transformaciones:
- En “Primeros Pasos en OpenGL” se mencionaba de manera general algunos conceptos relacionados con las transformaciones en OpenGL, específicamente la proyección. Es recomendable revisar y entender “Primeros Pasos en OpenGL” antes de aventurarse a leer el presente tutorial.
- En los “Hola Mundo 3d en OpenGL” y “Hola Complicado Mundo OpenGL-win32” se utilizaron algunas transformaciones de proyección y viewport para ajustar la inicialización de la ventana, pero sin entrar mucho en detalle acerca de su funcionamiento.
- Proyección: Trasforman una escena 3d “abstracta”, en una imagen plana que puede ser visualizada en una pantalla.
- Viewport: Ajustan el producto de la proyección a las dimensiones de un rectángulo contenedor (ventana).
- De vista: Que definen y afectan la posición desde la cual se visualizan las escenas tridimensionales.
- Modelado: Sirven para manipular los objetos en la escena, permitiendo trasladarlos, rotarlos y deformarlos (escalarlos).
- Modelo-Vista: Son la combinación de las dos transformaciones anteriores, que desde un punto de vista práctico son semejantes.
Antes de empezar a detallar cada tipo de transformación es bueno tener una idea de las funciones que permiten acceder directamente a las matrices que representan los estados de las transformaciones:
- void glMatrixMode( enum mode ); Permite seleccionar la matriz sobre la cual se realizaran las operaciones, los posibles valores de mode son TEXTURE, MODELVIEW, COLOR o PROJECTION .
- Void glLoadMatrix{fd} (T m[16]); Recibe una matriz de 4×4 que reemplaza la actual seleccionada. El arreglo es ordenado en forma de una matriz que tiene orden Y, a diferencia de las matrices convencionales que tienen orden X, lo que quiere decir que tiene la forma: m = [a1 ,a2 ,a3 ,a4 ,a5 ,a6 ,a7 ,a8 ,a9 ,a10, a11, a12, a13, a14, a15, a16]
es interpretada internamente por OpenGL como: - void glMultMatrix{fd}( T m[16] ); Multiplica la matriz actual por la matriz m[16] y reemplaza la matriz actual con el resultado de la operación.
- void glLoadTransposeMatrix{fd}( T m[16] ); Realiza una función similar a LoadMatrix(), con la diferencia que trabaja sobre una matriz en orden X así:
que es evidentemente la transpuesta de la m que recibe LoadMatrix. - void glMultTransposeMatrix{fd}( T m[16] ); Misma funcionalidad que MultMatrix() , solo que actúa en base al la matriz en orden X, o sea la transpuesta.
- void glLoadIdentity( void ); Remplaza la matriz actual por la matriz identidad de tamaño 4×4.
- void glPushMatrix( void ); Coloca una copia de la matriz actual en la parte superior de la pila correspondiente.
- void glPopMatrix( void ); Saca el elemento superior de la pila, que pasa a reemplazar a la matriz actual.
Hay una última función que es útil en la manipulación de matrices y otros aspectos de OpenGL:
- void glGetFloatv(enum value, float *data); Permite obtener una copia de aquello que se indica en value. Por ejemplo si se pasan como parámetros MODELVIEW_MATRIX y un apuntador a un arreglo de flotantes tamaño 16 se obtiene una copia de dicha matriz a través del arreglo.
Proyección
Como ya se ha visto en tutoriales anteriores, OpenGL maneja 2 tipos de proyección, en perspectiva y ortográfica, donde la primera corresponde a la visión “realista” de la escena, mientras que la segunda es una “plana” que no deforma las dimensiones de los objetos dependiendo de su distancia a la cámara.
Ortográfica: Para ajustar la proyección ortográfica se utiliza el siguiente grupo de funciones:
glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far); gluOrtho2D(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top);
Esta función es simplemente una forma de la anterior, en donde se ha despreciado el valor de Z asignando los valores near = -1 y far = 1, generalmente se utiliza para escenas planas, en las que los objetos carecen de profundidad.
Perspectiva: Existen dos manera de manejar la proyección en perspectiva, a través de de una función gl o mediante la librería glu (una tercera puede ser realizar los cálculos de la matriz “manualmente”. En el primer caso:
glFrustrum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far)
Transformaciones ModelView
Una tarea muy común en la creación de gráficos 2d, 3d y videojuegos es la de mover objetos par crear cierta animación.
void glRotate[fd](GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
Realiza una rotación del espacio coordenado por una medida de (angle) tomados en grados a lo largo del vector determinado por (x,y,z). Es recomendable que (x,y,z) representen un vector normalizado (o sea magnitud(x,y,z) = 1), debido a que si no es así OpenGL intentará normalizarlo. La rotación se lleva siguiendo la regla de la mano derecha, teniendo en cuenta que el vector (x,y,z) apunta con el “pulgar” hacia adentro (hacia uno).
void glTranslate[fd](GLfloat x, GLfloat y, GLfloat z);
Esta función traslada el espacio coordenado en x, y, z unidades sobre sus respectivos ejes coordenados X, Y, Z.
void glScalef(GLfloat x, GLfloat y, GLfloat z);
Cambia la proporción de los objetos respecto a los ejes coordenados, lo que es equivalente a decir que los estira o encoge una cantidad determinada por los parámetros de la función x,y,z.
Una tarea muy común en la creación de gráficos 2d, 3d y videojuegos es la de mover objetos par crear cierta animación.
void glRotate[fd](GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
Realiza una rotación del espacio coordenado por una medida de (angle) tomados en grados a lo largo del vector determinado por (x,y,z). Es recomendable que (x,y,z) representen un vector normalizado (o sea magnitud(x,y,z) = 1), debido a que si no es así OpenGL intentará normalizarlo. La rotación se lleva siguiendo la regla de la mano derecha, teniendo en cuenta que el vector (x,y,z) apunta con el “pulgar” hacia adentro (hacia uno).
void glTranslate[fd](GLfloat x, GLfloat y, GLfloat z);
Esta función traslada el espacio coordenado en x, y, z unidades sobre sus respectivos ejes coordenados X, Y, Z.
void glScalef(GLfloat x, GLfloat y, GLfloat z);
Cambia la proporción de los objetos respecto a los ejes coordenados, lo que es equivalente a decir que los estira o encoge una cantidad determinada por los parámetros de la función x,y,z.
Transformaciones en OpenGL
En el primero se ilustra el uso de la translación y de glPushMatrix() y glPopMatrix(), utilizando las teclas ‘w’,'a’,'s’,'d’ se pueden mover el triángulo seleccionado y con ‘e’ se cambia de triangulo a mover. En el segundo se utiliza ‘w’,'a’,'s’,'d’ para girar el un cubo alrededor de los ejes X y Y transformado, mostrando al mismo tiempo las coordenadas de objeto y de ojo.
En el primero se ilustra el uso de la translación y de glPushMatrix() y glPopMatrix(), utilizando las teclas ‘w’,'a’,'s’,'d’ se pueden mover el triángulo seleccionado y con ‘e’ se cambia de triangulo a mover. En el segundo se utiliza ‘w’,'a’,'s’,'d’ para girar el un cubo alrededor de los ejes X y Y transformado, mostrando al mismo tiempo las coordenadas de objeto y de ojo.
Fundamento Matemático.
La geometría euclídea se desarrolla en los siglos XIX y XX, tras la aparición del concepto de espacio vectorial. Recibe su nombre en honor a Euclides, matemático griego (~300 a.C.) quien estudió los conceptos básicos de la Geometría plana, aunque por supuesto no en un contexto vectorial.
Para generalizar esos conceptos geométricos, observamos el comportamiento de los vectores del plano. En
2 tenemos definido el producto escalar usual ℜ
(a
1,a2) · (b1,b2) = a1 b1 + a2 b2
Es una operación entre dos vectores, cuyo resultado es un escalar (de ahí el nombre "producto escalar").
Definición: Producto escalar en cualquier espacio. Espacio euclídeo.
Cualquier operación en un espacio vectorial que cumpla las anteriores propiedades, diremos que es un producto escalar (aunque no se trate del producto escalar usual).
Llamaremos espacio euclídeo a un espacio vectorial dotado de un producto escalar.
Jerarquia de objetos en OpenGL
Una vez conocida la estructura y comandos básicos de OpenGl y Glut, es hora de
adentrarnos más y aplicar algunas nuevas ideas. Intentaremos crear un modelo que
simule el movimiento de piernas de una persona andando.
Previamente necesitamos haber aprendido como se realizan las transformaciones de modelado y la proyección que serán usadas en la creación de este modelo. Si aun no has leído estos temas te recomendamos lo hagas antes de empezar.
Para explicar la construcción del citado modelo con movimiento de una manera sencilla, en lugar de crearlo completamente, vamos a construir solo una parte que corresponde a la parte baja del tronco (que llamaremos base), las piernas y los pies. Luego animaremos este modelo incompleto. Crearemos con este propósito una función 'caminar'. Cuando este ejemplo este terminado, comprendido y suficientemente trabajado podríamos seguir desarrollando el modelo y hasta hacer un cuerpo completo.
Comenzaremos esta sección describiendo la estructura y los conceptos para crear modelos "jerárquicos".
Conceptos basicos de jerarquía
Imaginemos que queremos construir un coche para realizar una cierta simulación. El coche estará compuesto por el cuerpo, cuatro ruedas con sus respectivos 5 tornillos, y seis ventanas (ventana delantera, ventana trasera y dos ventanas más a cada lado del coche que serán simétricas (ver figura 1). Para este ejemplo, utilizaremos solo el lado derecho del coche (visible en la figura). Por lo tanto usaremos el cuerpo, dos ruedas con sus diez tornillos y dos ventanas laterales. Para no tener que repetir código sería deseable construir el coche de una forma "jerárquica", significa esto que cuando los cinco tornillos estén correctamente colocados en la rueda, estos deberían moverse en concordancia con la misma sin ningún tipo de ayuda exterior. También seria deseable que cuando el cuerpo del coche se mueva, el resto de las partes sigan este movimiento y no permanezcan estáticas. Para realizar esta construcción "jerárquica" comenzaremos por poner el cuerpo de nuestro coche como el elemento principal y a partir de él colocaremos las ventanas y las ruedas con los tornillos enlazados a ellas. Con esta parte jerárquica lo que conseguimos es que cuando el cuerpo del coche se está moviendo, las ventanas y las ruedas se mueven con él de forma coordinada. Y además cuando las ruedas giran los tornillos lo hagan con ella. OpenGl nos permite realizar la construcción "jerárquica" de modelos con las funciones glPushMatrix y glPopMatrix. Si asumimos que con estas funciones podemos crear las partes separadas del coche (tornillos, ruedas, ventanas y cuerpo) entonces la figura 2 nos demuestra la necesidad de la "jerarquía" y el ejemplo 1 el pseudo-código para la realización del mismo.
Ejemplo 1. Pseudo-código que demuestra la "jerarquía" del coche
Previamente necesitamos haber aprendido como se realizan las transformaciones de modelado y la proyección que serán usadas en la creación de este modelo. Si aun no has leído estos temas te recomendamos lo hagas antes de empezar.
Para explicar la construcción del citado modelo con movimiento de una manera sencilla, en lugar de crearlo completamente, vamos a construir solo una parte que corresponde a la parte baja del tronco (que llamaremos base), las piernas y los pies. Luego animaremos este modelo incompleto. Crearemos con este propósito una función 'caminar'. Cuando este ejemplo este terminado, comprendido y suficientemente trabajado podríamos seguir desarrollando el modelo y hasta hacer un cuerpo completo.
Comenzaremos esta sección describiendo la estructura y los conceptos para crear modelos "jerárquicos".
Conceptos basicos de jerarquía
Imaginemos que queremos construir un coche para realizar una cierta simulación. El coche estará compuesto por el cuerpo, cuatro ruedas con sus respectivos 5 tornillos, y seis ventanas (ventana delantera, ventana trasera y dos ventanas más a cada lado del coche que serán simétricas (ver figura 1). Para este ejemplo, utilizaremos solo el lado derecho del coche (visible en la figura). Por lo tanto usaremos el cuerpo, dos ruedas con sus diez tornillos y dos ventanas laterales. Para no tener que repetir código sería deseable construir el coche de una forma "jerárquica", significa esto que cuando los cinco tornillos estén correctamente colocados en la rueda, estos deberían moverse en concordancia con la misma sin ningún tipo de ayuda exterior. También seria deseable que cuando el cuerpo del coche se mueva, el resto de las partes sigan este movimiento y no permanezcan estáticas. Para realizar esta construcción "jerárquica" comenzaremos por poner el cuerpo de nuestro coche como el elemento principal y a partir de él colocaremos las ventanas y las ruedas con los tornillos enlazados a ellas. Con esta parte jerárquica lo que conseguimos es que cuando el cuerpo del coche se está moviendo, las ventanas y las ruedas se mueven con él de forma coordinada. Y además cuando las ruedas giran los tornillos lo hagan con ella. OpenGl nos permite realizar la construcción "jerárquica" de modelos con las funciones glPushMatrix y glPopMatrix. Si asumimos que con estas funciones podemos crear las partes separadas del coche (tornillos, ruedas, ventanas y cuerpo) entonces la figura 2 nos demuestra la necesidad de la "jerarquía" y el ejemplo 1 el pseudo-código para la realización del mismo.
Ejemplo 1. Pseudo-código que demuestra la "jerarquía" del coche
functión dibujar_coche{ glPushMatrix dibujar_cuerpo_coche glPushMatrix ir_posición_ventana_delantera dibujar_ventana_delantera ir_posición_ventana_trasera invertir_ejes dibujar_ventana_trasera invertir_ejes ir_posición_rueda_delantera dibujar_rueda_y_tornillos ir_posición_rueda_trasera dibujar_rueda_y_tornillos glPopMatrix glPopMatrix } functión dibujar_rueda_y_tornillos{ glPushMatrix dibuja_rueda glPushMatrix for counter = 1 up to 5 do { ir_posición_tornillo dibujar_tornillo } glPopMatrix glPopMatrix } |
No hay comentarios:
Publicar un comentario