OpenGL desde 0. Capitulo 5: Cámaras

Capítulo perteneciente al tutorial de opengl desde cero

Hola a todos,

Ya sabemos crear objetos 3D, y también sabemos moverlos, rotarlos,escalarlos e iluminarlos. Pero.... como los vemos? Cual es el proceso que se encarga de poner esos objetos en nuestra pantalla?

La respuesta es la cámara. La cámara no es más que una forma de decirle a OpenGL como queremos que renderice la escena.

Hay un concepto previo a la cámara que tengo que explicar que es el cambio de tipo de matrices (es un tema que he ido dejando caer en otros capítulos pero que no he profundizado).

En OpenGL tenemos tres tipos de matrices:

GL_PROJECTION: Matriz de proyección. Es que nos permite escoger como va a ser nuestra cámara.
GL_MODELVIEW: Matriz de visión de modelo. La que hemos usado hasta ahora, es la que nos permite decir como queremos que se vea el modelo. (traslaciones,rotaciones,etc...)
GL_TEXTURE: Matriz de texturizado. Por ahora lo dejamos para cuando toquemos texturas. Con que sepáis que existe, suficiente por ahora.

Para escoger en que tipo de matriz queremos trabajar tenemos que usar la función glMatrixmode(tipo).

Una vez tenemos seleccionado la matriz de proyección tenemos que seleccionar que tipo de cámara queremos.

Ortogonal (o paralela):  Es una cámara que no tiene perspectiva (si nos alejásemos 2 metros para atrás veríamos lo mismo.) En 3D no tiene mucha utilidad pero en 2D es básica. Para más ejemplos podéis mirar el pakengine.
A nivel de código se selecciona esta cámara mediante la siguiente instrucción:
glOrtho (left,right,bottom,top,near,far);

Perspectiva: Es aquella en que los objetos más alejados aparecen más pequeños y por lo tanto da una mayor sensación de realismo. Es la más usada en 3D.
Para que el código pida usar esta cámara se ha poner:
glFrustum(left,right,bottom,top,near,far);

Siendo los parámetros que reciben ambas funciones las dimensiones de la caja donde se realiza el renderizado (es decir, todo lo que entre en la caja se renderizará y el resto no se tendrá en cuenta)

De todas maneras, estas dos funciones no son demasiado claras. Con esto quiero decir que si bien es sencillo entender los parámetros es complicado darle un significado físico a estos. Para ello aparecieron dos funciones nuevas que solucionaban bastante la vida:
- gluPerspective(fovy,aspect,near,far) siendo fovy el field of view (angulo de abertura vertical de la cámara) y aspect la relación entre el ancho y el alto de la pantalla.
- gluLookAt (eyex,eyey,eyez, centerx,centery,centerz, upx,upy,upz) siendo eye las coordenadas de nuestro punto de vista, center las coordenadas del punto al que estamos mirando y up es un vector que nos define hacia donde está nuestra verticalidad (para poder hacer giros de cámara).

Y hasta aquí el tema de hoy. No obstante volveremos a trabajar sobre esto por que la mayoría de lo que he explicado hoy ya está deprecated en las últimas versiones de OpenGL :) , así que tendremos que darle otro enfoque. Por ahora, esto ya os servirá.

Espero que os haya gustado y hayáis aprendido.

Nos vemos

OpenGL desde 0. Capitulo 3: Transformaciones del espacio

Capítulo perteneciente al tutorial de opengl desde cero

Hola a todos,

Si estáis siguiendo este tutorial ya sabéis (más o menos) como se representan objetos 3D, pero...como los movemos , rotamos o escalamos??

OpenGL provee de transformaciones del espacio que nos permiten modificar nuestros modelos 3D en función de nuestras necesidades.

Las 3 funciones principales que nos permiten realizar estas operaciones son:

glTranslatef(x,y,z): Esta función hace que todo lo que pintemos a partir de la llamada de esta función lo haga desplazado hacía las coordenadas x,y,z

glScalef(x,y,z): Esta función escala (modifica el tamaño) de todo lo que se pinte a partir de la llamada a esta función.

glRotatef(angle, x, y ,z): Esta función se encarga de rotar toda la escena alrededor del vector x,y,z en el angulo que le digamos.

Junto con estas tres funciones considero necesario también hablar de dos funciones más que nos serán muy útiles:

glPushMatrix(): Esta función apila (guarda) la matriz de transformación tal y como la tenemos.

glPopMatrix(): Esta función nos pone como matriz de transformación actual la última que hayamos guardado mediante glPushMatrix() (y la quita de la pila)

Estas dos funciones son extremadamente útiles para realizar transformaciones de solo un objeto , dejando el resto de objetos como estaban. Por ejemplo:

glPushMatrix();

glTranslatef(1.0f,1.0f, -5.0f);

glBegin(GL_POINTS);
glVertex3f(1.0f, 2.0f, 3.0f);
glEnd();

glPopMatrix();

Al finalizar este trozo de código la operación glTranslatef solo habrá resultado efectiva para el pintado del punto, pero no para el resto de objetos que podamos pintar en pantalla.


Un tema importante que tenéis que recordar es que las operaciones de transformación del espacio en el fondo aplican matrices de transformación a la matriz actual de trabajo y que por lo tanto, el ORDEN DE LOS FACTORES ALTERA EL PRODUCTO. Es decir, no es lo mismo rotar y mover que mover y rotar. Mi consejo es que vayáis probando y veáis como funciona, no hay mejor manera de aprender que ir experimentando.

Otro tema importante (ya para finalizar), es que si os fijáis  todo lo que se ha explicado en este capítulo nos puede servir para montar nuestra primera cámara. Con esto quiero decir que si bien no he explicado nada de cámaras supongo que ya intuis que una cámara es un "ente" que permite posicionarnos en la escena para verla desde un punto de vista u otro. Lo gracioso de las transformaciones del espacio es que tanto podemos mover la cámara, como podemos mover todo el mundo 3D que afectos prácticos para nosotros va a ser lo mismo (el renderizado haciéndolo de una manera u otro no va a variar)

Ya sin más os dejo tranquilos.

Espero que os haya gustado y hayáis aprendido

Nos vemos