PDF de programación - 1. Introducción a OPENGL: Dibujando una tortuga con OPENGL

1. INTRODUCCIÓN A OPENGL: DIBUJANDO UNA TORTUGA CON

OPENGL

1.1 ¿QUÉ ES OPENGL?

Qué es OpenGL? OpenGL es una interfaz software de harware gráfico, es decir
define las funciones que se pueden utilizar en una aplicación para acceder a las
prestaciones de un dispositivo gráfico. Es un motor 3D cuyas rutinas están integradas
en tarjetas gráficas 3D. Fue desarrollado por Sillicon Graphics, Inc. (SGI) con el afán
de hacer un estándar de representación en 3D. Es compatible con prácticamente
cualquier plataforma harware asi como con muchos lenguajes de programación (C,
C++, Visual Basic, Visual Fortran, Java).

1.2 ABRIENDO UNA VENTANA CON OPENGL

El objetivo de este primer ejercicio es abrir una ventana con OpenGL. Se
describe como realizar el proceso en Visual C++, para otros entornos el proceso es
similar. Para ello es necesario abrir un nuevo proyecto en Visual C++ del tipo
Console Application. Para poder ejecutar las librerias GLUT de OpenGL es necesario
incluir en los siguientes lugares, si no se encuentran ya, los ficheros que se indican (se
pueden obtener en el web de la asignatura en:

http://www.tecnun.es/asignaturas/grafcomp/openGL/files/):
- glut32.dll se debe situar en windows\system(32)
- glut32.lib se debe situar en DevStudio\Vc\lib
- glut.h se debe situar en DevStudio\Vc\include\gl
También es necesario incluir las librerías opengl32.lib, glu32.lib y glut32.lib en
la lista de librerías del proyecto, en el caso de Visual C++ se accede en Project >
Settings > Link > Object/Library Modules.

Se añade un fichero de tipo texto y nombre tecnunLogo.c, mediante File > New

/Text File.

En esta práctica se va a trabajar en un único archivo con extensión llamado

tecnunlogo.c cuyo código es el siguiente:

#include <GL/glut.h>

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

glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutInitWindowSize(512, 512);
glutInitWindowPosition(20, 20);
glutCreateWindow("tecnunLogo");

glutDisplayFunc(display);

glutMainLoop();
return 0;
}

Para poder utilizar las librerías OpenGL y GL Utility Toolkit (GLUT) es

necesario incluir el archivo glut.h como se muestra en la primera línea de código.

En la función main(), glutInit() es la función que inicializa la librería GLUT y
negocia con el sistema de ventanas la apertura de una nueva ventana. Sus parámetros
deben ser los mismos que los de la función main() sin modificar. A continuación,
glutInitDisplayMode() define el modo en el que se debe dibujar la ventana. Sus
parámetros, como en muchas de las funciones OpenGL, se definen con flags o
máscaras de bits. En este caso, GLUT_RGB indica el tipo de modelo de color con el
que se dibujará (Red-Green-Blue), GLUT_DEPTH indica que se debe incluir un
buffer de profundidad y GLUT_DOUBLE que se debe utilizar un doble buffer.

Antes de crear una ventana, es necesario definir sus propiedades. Con la función
glutInitWindowSize() se define el tamaño de la ventana en píxeles (anchura y altura)
y con la función glutInitWindowPosition(), la distancia horizontal y vertical con
respecto de la esquina superior izquierda del monitor donde la ventana deberá
aparecer. Finalmente, con la función glutCreateWindow() se crea propiamente la
ventana, y el string que se pasa como argumento, es utilizado como nombre de la
nueva ventana.

Ahora que la ventana ha sido creada, es necesario mostrarla. Para ello la función
main llama a la función glutDisplayFunc(). Esta función es la más importante de las
funciones callback. Gracias a la definición de las funciones callback, GLUT hace
posible una dinámica de programación de aplicaciones OpenGL. Una función
callback será llamada por GLUT para hacer alguna operación especifica cada vez que
se produzca un evento. En este caso, glutDisplayFunc(display), define que la función
display que es pasada como argumento sea ejecutada cada vez que GLUT determine
que la ventana debe ser dibujada (la primera vez que se muestra la ventana) o
redibujada (cuando se maximiza, cuando se superponen varias ventanas, etc).

La ultima función que es llamada en el main es glutMainLoop(). Esta función
se encarga de pasar el control del flujo del programa a la GLUT, de manera que cada
vez que ocurra un “evento” sean llamadas las funciones definidas como callbacks
hasta que el la ventana se cierre.

La función display(), definida como función callback para dibujar o redubujar
la ventana cada vez que sea necesario, esta también contenida en el archivo
tecnunlogo.c. Como todas las funciones callback que serán utilizadas, display() es del
tipo void. Como este ejercicio es bastante simple y no se va a dibujar ninguna figura
en la ventana, el contenido de la función es bastante sencillo. En ella solo se van a
definir las funciones que siempre deben aparecer en cualquier función display
callback.

void display(void) {
glClearColor(1.0, 1.0, 1.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glutSwapBuffers();
}

La función display() se debe incluir antes de la función main() para que no se

produzca un error al compilar cuando se utiliza en la función main().

La función glClearColor() establece el color de fono de la ventana, que es con
el que se “borra” la ventana. A continuación se llama, antes de dibujar cualquier cosa,
a la función glClear(). Esta función se encarga de borrar el fondo de la ventana.

Acepta como argumento el buffer específico que se desea borrar, en este caso el
GL_COLOR_BUFFER_BIT y el GL_DEPTH_BUFFER_BIT.

La función glSwapBuffers() se encarga
de intercambiar el buffer posterior con el
buffer anterior y es necesaria porque se ha
definido que se trabaja con doble buffer.
Cuando se dibuja cualquier figura, esta es
dibujada en el buffer posterior (el que está
atrás) y cuando el dibujo está terminado los
dos buffers se intercambian.

El resultado de ejecutar este proyecto es

el que se muestra en la figura 1:

1.3 DIBUJANDO UN TOROIDE EN LA
VENTANA

Figura 1

Ventana inicial

El objetivo de este ejercicio es dibujar, en la ventana del ejercicio anterior, un
toroide con un cubo inscrito en su interior. Para ello será necesario incluir algunas
operaciones más en la función display():

void display(void) {
glClearColor(1.0, 1.0, 1.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(1.0,0.0,0.0);
glutWireTorus(0.25,0.75, 28, 28);
glColor3f(0.0,0.0,1.0) ;
glutWireCube(.60) ;
glutSwapBuffers();
}

En este ejemplo serán introducidas tres nuevas funciones GL (una función
OpenGL y dos funciones GLUT). La función OpenGL glColor3f() establece el color
actual con el que se va a dibujar una figura. El color será el mismo hasta que se
cambie el ‘estado’ de esta variable con la función glColor3f nuevamente. Esto es lo
que se quiere decir cuando se habla de OpenGL como una maquina de estados. Todas
las funciones de OpenGL comienzan con el prefijo “gl” y en muchas (como es el caso
de glColor3f) aparece un sufijo compuesto por un número y una letra. El número
simboliza el numero de parámetros que se debe pasar a la función y la letra, el tipo de
estos parámetros. En este caso, se deben pasar 3 parámetros de tipo float. Al estar
trabajando en un modelo de color de tipo RGB (Red-Green-Blue), cada uno de estos
parámetros representa el valor de cada color respectivamente.

La función GLUT glutWireTorus(0.25, 0.75, 28, 28) dibuja un toroide de
frame de hilos cuyo radio interno es el double 0,25; radio externo el double 0,75; el
primer entero 28 representa el numero de lados que se puede observar en cada sección
radial y el segundo entero 28 el numero de divisiones radiales del toroide.

La función GLUT glutWireCube(0.60) dibuja un cubo cuyo tamaño queda

determinado por su único parámetro de valor float.
El resultado es el que se muestra en la figura:
Dibujar los ejes del sistema de coordenadas de la ventana
utlilizando los colores rojo, verde y azul (RGB) para los ejes x, y, z
correspondientemente.

Dibujar en la ventana las
diferentes primitivas de GLUT (se
pueden encontrar en el tutorial de
OpenGL en el web de la
asignatura).

1.4 DEFINIENDO EL ÁREA DE PROYECCION
INICIAL

Una vez que se ha dibujado un objeto
en la ventana es necesario definir el área de
proyección inicial que se desea de la figura
en la ventana. Para ello se debe manipular el
área de proyección por medio de la función
callback glutReshapeFunc(). Esta función callback especifica cuál función será
llamada cada vez que la ventana sea redimensionada o movida, pero también es
utilizada para definir inicialmente el área de proyección de la figura en la ventana.

Ventana con toroide y cubo

Figura 2

Muchas de las funciones que OpenGL pone a disposición para definir la
proyección están basadas en matrices de transformación que, aplicadas sobre el
sistema de coordenadas de la ventana, definen el punto desde donde será observada la
figura. Estas matrices y sus transformaciones se explicarán con más detenimiento en
el siguiente capitulo.

Antes de explicar el código de este ejercicio es conveniente recordar la
disposición del sistema de coordenadas de OpenGL, en el que el eje vertical es el Y y
el eje de visión por defecto es el Z.



Y+

Y+

Z+

X+

X+

Z+

Observador

Figura 3

Sistema de Coordenadas de OpenGL

La función glutReshapeFunc(reshape) debe ser incluida en el código de la

función main():
glutReshapeFunc(reshape);

A continuación se define la funcion reshape():

void reshape(int width, int height) {
glViewport(0, 0, widt