Matrices
Las matemáticas que
hay tras las transformaciones se simplifican gracias a las matrices. Cada una
de las transformaciones puede conseguirse multiplicando una matriz que contenga
los vértices por una matriz que describa la transformación. Por tanto todas las
transformaciones ejecutables con ogl pueden describirse como la multiplicación
de dos o más matrices.
El canal de transformaciones
Para poder llevar a
cabo todas las transformaciones de, deben modificarse dos matrices: la matriz
del Modelador y la matriz de Proyección. OpenGL proporciona muchas funciones de
alto nivel que hacen muy sencillo la construcción de matrices para
transformaciones. Éstas se aplican sobre la matriz que
este activa en ese instante. Para activar una de las dos matrices utilizamos la
función glMatrixMode. Hay dos parámetros posibles:
glMatrixMode(GL_PROJECTION);
Activa la matriz de proyección, y
glMatrixMode(GL_MODELVIEW);
Activa la del modelador. Es necesario especificar con que
matriz se trabaja, para poder aplicar las transformaciones necesarias en función
de lo que se desee hacer.
El camino que va desde los datos “en bruto”
de los vértices hasta las coordenadas en pantalla sigue el siguiente
camino: Primero, el vértice se convierte en una matriz 1x4 en la que los tres
primeros valores son las coordenadas x, y, z. El cuarto número (llamado parámetro
w) es un factor de escala, que no se va a usar de momento, usando el valor 1.0.
Entonces se multiplica el vértice por la matriz del modelador, para obtener las
coordenadas oculares. Éstas se multiplican por la matriz de proyección
para conseguir las coordenadas de trabajo. Con esto se eliminan todos los datos
que están fuera del volumen de proyección. Estas coordenadas de trabajo
se dividen por el parámetro w del vértice, para hacer el escalado relativo.
Finalmente, las coordenadas resultantes se mapean en un plano 2D mediante la transformación
de la vista.
La matriz del modelador
La matriz del modelador es una matriz 4x4 que representa el
sistema de coordenadas transformado que se está usando para colocar y orientar
los objetos. Si se multiplica la matriz del vértice (de tamaño 1x4) por ésta se
obtiene otra matriz 1x4 con los vértices transformados sobre ese sistema de
coordenadas.
OpenGL proporciona funciones de alto nivel para conseguir
matrices de translación, rotación y escalado, y además la multiplican por la
matriz activa en ese instante, de manera que no hay que preocuparse por ello en
absoluto.
Traslación
Imaginemos que se quiere dibujar un cubo con la función de
la librería GLUT glutSolidCube, que lleva como parámetro el lado del cubo. Si
se escribe el siguiente código:
glutSolidCube(5);
Se obtiene un cubo centrado en el origen (0,0,0) y con el
lado de la arista 5. Ahora se quiere mover 10 unidades hacia la derecha (es
decir, 10 unidades en el sentido positivo del eje de las x). Para ello se tendría
que construir una matriz de transformación y multiplicarla por la matriz del
modelador. Ogl nos ofrece la función glTranslate, que crea la matriz de transformación
y la multiplica por la matriz que está activa en ese instante (en este caso debería
ser la del modelador, GL_MODELVIEW). Entonces el código quedaría de la
siguiente manera:
glTranslatef(10.0f, 0.0f, 0.0f);
glutSolidCube(5);
La “f” añadida a la función indica que se usarán
flotantes. Los parámetros de glTranslate son las unidades a desplazar en el eje
x, y y z, respectivamente. Pueden ser valores negativos, para trasladar
en el sentido contrario.
Rotación
Para rotar, tenemos también una función de alto nivel que
construye la matriz de transformación y la multiplica por la matriz activa, glRotate.
Lleva como parámetros el ángulo a rotar (en grados, sentido horario), y después
x, y y z del vector sobre el cual se quiere rotar el objeto. Una rotación
simple, sobre el eje y, de 10° sería:
glRotatef(10, 0.0f, 1.0f, 0.0f);
Escalado
Una transformación de escala incrementa el tamaño de nuestro
objeto expandiendo todos los vértices a lo largo de los tres ejes por los factores
especificados. La función glScale lleva como parámetros la escala en x, y y z,
respectivamente. El valor 1.0f es la referencia de la escala, de tal forma que:
glScalef(1.0f, 1.0f, 1.0f);
No modificaría el objeto en absoluto. Un valor de 2.0f sería
el doble, y 0.5f sería la mitad. Por ejemplo, para ensanchar un objeto a lo
largo de su eje z, de tal forma que quedase cuatro veces más “alargado” en este eje, sería:
glScalef(1.0f, 1.0f, 4.0f);
La matriz identidad
El “problema” del uso de estas funciones
surge cuando se tiene más de un objeto en la escena. Estas funciones
tienen efectos acumulativos. Es decir, si se quiere preparar una escena como la
de la ilustración:
Con una esfera (de radio 3) centrada en (0, 10, 0) y otra
centrada en (10, 0, 0), y se escribe el siguiente código (que es incorrecto):
glTranslatef(0.0f,
10.0f, 0.0f);
glutSolidSphere(3.0f,
8, 8);
glTranslate(10.0f,
0.0f, 0.0f);
glutSolidsphere(3.0f,
8, 8);
En este código, se dibuja primero una esfera en (0, 10, 0)
como se quiere. Pero después, se está multiplicando la matriz del modelador
(que ya estaba transformada para dibujar la primera esfera) por otra matriz de transformación
que desplaza 10 unidades hacia la derecha. Por ello la segunda matriz se dibujaría,
en (10, 10 ,0), y no en (10, 0, 0), como se pretendía.
Para solventar este problema se debe reiniciar la matriz del
modelador a un estado conocido, en este caso, centrada en el origen de nuestro
sistema de coordenadas oculares. Para ello se carga en la matriz del modelador
la matriz identidad (una matriz 4x4 llena de ceros excepto en la diagonal, que
contiene unos). Esto se consigue gracias a la función glLoadIdentity, que no
lleva parámetros. Simplemente carga la matriz identidad en la matriz activa en
ese instante. El código correcto para el ejemplo anterior quedaría de la
siguiente manera:
glTranslatef(0.0f,
10.0f, 0.0f);
glutSolidSphere(3.0f,
8, 8);
glLoadIdentity();
glTranslate(10.0f,
0.0f, 0.0f);
glutSolidsphere(3.0f, 8, 8);
La matriz de proyección
La matriz de proyección especifica el tamaño y la forma del
volumen de visualización. El volumen de visualización es aquel cuyo contenido
es el que se representa en pantalla. Está delimitado por una serie de planos de
trabajo. De estos planos, los más importantes son los planos de corte, que son
los que nos acotan el volumen de visualización por delante y por detrás. En el
plano más cercano a la cámara (znear) es donde se proyecta la escena para luego
pasarla a la pantalla. Todo lo que está más adelante del plano de corte más
alejado de la cámara (zfar) no se representa.
Proyecciones ortográficas
Una proyección ortográfica es cuadrada en todas sus caras.
Esto produce una proyección paralela, útil para aplicaciones de tipo CAD o
dibujos arquitectónicos, o también para tomar medidas, ya que las dimensiones
de lo que representan no se ven alteradas por la proyección.
Una aproximación menos técnica pero más comprensible de esta
proyección es imaginar que se tiene un objeto fabricado con un material
deformable, y se aplasta literalmente como una pared. Se obtendría el mismo
objeto, pero plano, liso. Pues eso es lo que se vería por pantalla.
Para definir la matriz de proyección ortográfica y
multiplicarla por la matriz activa (que debería ser en ese momento la de proyección,
GL_PROJECTION), se utiliza la función glOrtho, que se define de la siguiente
forma:
glOrtho(limiteIzquierdo, limiteDerecho, limiteAbajo,
limiteArriba, znear, zfar)
Siendo todos flotantes. Los valores de znear y zfar no son
las posiciones de esos planos en el espacio 3D. Representan la distancia desde
el centro de proyección, con valor positivo hacia delante y negativo hacia atrás.
Con esto simplemente se acota lo que será¡
el volumen de visualización (un cubo).
Por ejemplo, la ilustración es un render de un coche con proyección
ortográfica, visto desde delante.
El código utilizado
para esta proyección ha sido:
glOrtho(-0.5f,
0.5f, -0.5f, 0.5f, 0.01f, 20.0f);
Proyecciones perspectivas
Una proyección en perspectiva reduce y estira los objetos más
alejados del observador. Es importante saber que las medidas de la proyección
de un objeto no tienen por qué coincidir con las del objeto real, ya que han
sido deformadas.
El volumen de visualización creado por una perspectiva se
llama frustum. Un frustum es una sección piramidal, vista desde la parte
afilada hasta la base.
Se puede definir esta proyección utilizando la función glFrustum.
Pero existe otra función de la librería GLU llamada gluPerspective que hace el
proceso más sencillo. Se define de la siguiente forma:
Void gluPerspective(angulo, aspecto, znear, zfar);
Los parámetros de gluPerspective son flotantes y definen las
características mostradas en la ilustración, el ángulo para el campo de visión
en sentido vertical, el aspecto que es la relación entre la altura (h) y la
anchura (w) y las distancias znear y zfar de los planos que acotan el fustrum
al observador. Los valores de znear y zfar no son las posiciones de esos planos
en el espacio 3D, representan la distancia desde el centro de proyección, con
valor positivo hacia delante y negativo hacia atrás.
La ilustración muestra la escena del coche de la sección
anterior, esta vez con una proyección en perspectiva:
El código utilizado para definir la proyección ha sido:
gluPerspective(45.0f,(GLfloat)(width/height),0.01f,100.0f);
Se usan 45° de ángulo, la relación entre el ancho y alto de
la pantalla (width y height son el ancho y alto actual de la ventana) y las
distancias a los planos de corte znear y zfar son 0.01 y 100 respectivamente.
