OpenGL Lección 01 - Inicializar una Ventana con Glut

Vamos a comenzar con nuestro primer ejemplo sencillo con OpenGL y glut. Lo que vamos a hacer es crear una ventana con glut, inicializar unas variables de OpenGL y dibujar una objeto en pantalla. Este código lo probado en Windows y Linux sin modificar código principal lo único que cambia son los include de las librerías. (Esta es la primera revisión, asi que esta sujeta a correciones, sobre todo gramática :p). Abajo dejo un enlace para descarar el ejemplo completo. 

Supongo que usted tiene alguna idea básica de álgebra. 

Por comodidad trabajare en entorno linux, asi que los include serán:

   #include "GL/gl.h"
   #include "GL/glu.h"
   #include "GL/glut.h"

Mientras que para Windows como explique anteriormente solo bastara con usar:

   #include "glut.h"

Bueno comencemos con este sencillo ejemplo, voy a pegar el código completo y luego abajo iré explicando mas detalladamente.

  #include "GL/gl.h"

  #include "GL/glu.h"

  #include "GL/glut.h"

  void iniciar(){

glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

  }

  void dibuja(){

glClear(GL_COLOR_BUFFER_BIT);

glLoadIdentity();

glTranslatef(0.0f, 0.0f, -10.0f);

glutWireTeapot(3.0f);

glutSwapBuffers();

 }

 void redimensionar(GLint ancho, GLint alto){

glViewport(0, 0, ancho, alto);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluPerspective(45.0f, (GLfloat)ancho/(GLfloat)alto, 0.1f, 100.0f);

glMatrixMode(GL_MODELVIEW);

}

int main(int argc, char **argv){

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);

glutInitWindowSize(320,240);

glutInitWindowPosition(120,120);

glutCreateWindow("leccion_01 OpenGL");

iniciar();

glutDisplayFunc(dibuja);

glutReshapeFunc(redimensionar);

glutMainLoop();

return 0;

}

Lo primero en que nos fijaremos sera en la funcion main() , notaras que la funciones de "glut" comienza con su propio nombre. Lo primero es pasar los argumentos que usa glutInit() para inicializarlo(duh!).

 glutInit(&argc, argv);

glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);

glutInitWindowSize(320,240);

glutInitWindowPosition(120,120);

glutCreateWindow("leccion_01 OpenGL");

iniciar();

glutDisplayFunc(dibuja);

glutReshapeFunc(redimensionar);

glutMainLoop();

Con glutInitDisplayMode() lo que hacemos es pasar los parametros que utilizaremos, GL_RGBA se encarga de manejar los colores: rojo(R), verde(G), azul(B) y el valor alfa(A) que es el que se maneja las transparencias y junto con ellas iniciamos el doble buffer de glut que se encarga de dibujar en segundo plano la imagen que aparecerá para parpadeo de imagenes mientras se dibujan.

Las dos siguientes lineas establecen el tamaño de la venta y la posición donde aparece nuestra ventana. 

Entonces aparece la función iniciar(), aquí es donde empezaremos a establecer todos lo parametros iniciales de OpenGL que deseamos. En ella puedes ver la función glClearColor(), se encarga establecer el color de fondo con que la pantalla sera limpiada (color negro), como ven le pasamos cuatro parámetros que son los colores RGBA y que van de entre 0.0 a 1.0.

void iniciar(){
  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
}

Regresando al main la siguente función que sigue es glutDisplayFunc(), se encarga de dibujar en pantalla la imagen y para ello tiene un puntero que tiene que llamar a la funcione que lo hara, en este caso dibuja().

Regresamos nuevamente arriba a dibuja(). Aquí es donde empezamos a redenrizar nuestra escena. Primero limpiamos el buffer con el color que le indicamos anteriormente y después cargamos la matriz identidad que lo único que haces es ubicarnos en el centro del nuestro de nuestro mapa de coordenadas. Ahora si dibujamos algo es posible que no lo veamos o que estemos dentro de nuestro objeto que dibujemos, es por ello que hay que alejarlo un poco de nosotros para verlo mejor, trasladamos nuestros coordenadas por el eje z con glTranslatef(0.0f, 0.0f, -10.0f), y dibujamos nuestro objeto. 

void dibuja(){

glClear(GL_COLOR_BUFFER_BIT);

glLoadIdentity();

glTranslatef(0.0f, 0.0f, -10.0f);

glutWireTeapot(3.0f);

glutSwapBuffers();

}

GLUT incluye una tetera y otros modelos como ejemplos para comenzar rápido, así que bastara con solo llamar glutWireTeapot(3.0f), el valor que tiene indica el tamaño que deseamos por ultimo solo queda llamar a glutSwapBuffers() que es el que se encarga de volcar el doble buffer que llamamos previamente.

Regresamos nuevamente al main para ver la que la función glutReshapeFunc() llama a redimencionar. Lo que glutReshapeFunc() es llamada cuando la ventana sufre cambios en su apecto o sea redimencionar parar ello tiene dos parámetros.

La función de redimencionar(), se encarga de que cuando nuestra ventana sea modifica esta mantenga el aspecto de la figura que dibuja. Los dos parámetros que tiene son los que le pasa glutReshapeFunc().

void redimensionar(GLint ancho, GLint alto){
glViewport(0, 0, ancho, alto);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f, (GLfloat)ancho/(GLfloat)alto, 0.1f, 100.0f);
glMatrixMode(GL_MODELVIEW);
}

Ahora hay que establecer el tamaño y la posición de la venta donde esta se proyectara con glViewPort, Luego hay que cargar las matrices de proyección para calcular la posición del objeto en el espacio, restablecemos la matriz identidad y establecemos la vista que deseamos, en este caso en perspectiva.

       gluPerspective(45.0f, (GLfloat)ancho/(GLfloat)alto, 0.1f, 100.0f);

El primer parámetro estable el angulo de apertura como si fuera una camara, el segundo estable la relación de aspecto entre el ancho/alto, veran que hacemos un "cast" con (GLfloat) para calcular el aspecto en caso de que este no se un valor entero, los dos últimos dos parámetros establencen la cercanía y la distancia del eje Z que podemos visualizar, todo aquello que queda fuera de este rango no sera dibujado.

Al final llamamos al modelo vista que se en carga de dibujar en dos dimensiones la imagen calculada en la proyección.

La ultima vez que regresamos al main es para llamar a glutMainLoop() que lo unico que hacer es mantener un ciclo para la funciones hasta que salgamos.

   glutMainLoop();
   return 0;

}

Si acaso queremos dibujar ortograficamente bastaría con cambiar  

   gluPerspective(45.0f, (GLfloat)ancho/(GLfloat)alto, 0.1f, 100.0f);

por:

   glOrtho((GLfloat)-ancho, (GLfloat)ancho, (GLfloat)-alto, (GLfloat)alto, -10.0, 10.0);

Los valores serian estos:

glOrtho(izquierda, derecha, arriba, abajo, cerca, lejos); 

Ahora bien al hacer esto es posible que veamos a nuestro objeto muy pequeño, el caso es que glOrtho tomo los valores 1.0 como si estos fueran iguales a un pixel, aunque no siempre es el caso. Es por ello que hay que dibujar nuestra tetera mas grande o en todo caso disminuir los valores de glOrtho.

Para compilar en linux con gcc desde consola escribir:

g++ leccion_01.cpp -lglut -lGL -lGLU -o leccion_01

Donde:

g++: Es el compilador a usar para archivos archivos.cpp y gcc para archivos.c

leccion_01.cpp: Es el archivo a compilar.

-lGL -lGLU -lglut: Son las librerias a utilizar para poder compilar.

-o leccion_01: Es el nombre del archivo ejecutable.

Descargar el Código Fuente: Leccion_01