Configurar OpenGL y GLUT en Windows (Visual Studio)

Configurar OpenGL y GLUT en Visual Studio de Windows es también muy sencillo.

1. Aunque OpenGL viene con todas las versiones de Windows, GLUT hace falta descargarlo. Esto se puede hacer desde la web de Nate Robins (glut-3.7.6-bin.zip).
2. Después de descomprimirlo borramos los ficheros glut.def y README-win32.txt.
3. Copiamos la dll glut32.dll en %WinDir%\System32 (C:\Windows\System32 por ejemplo).
4. También copiamos la librería glut32.lib en el subdirectorio lib de VC (C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\lib en Windows 7/Vista o  C:\Program Files\Microsoft Visual Studio 9.0\VC\lib en Windows XP por ejemplo).
5. Después crear el subdirectorio gl en el directorio include de VC y copiar allí el fichero de cabecera glut32.h (C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\include\gl o C:\Program Files\Microsoft Visual Studio 9.0\VC\include\gl).

El siguiente video muestra los pasos anteriormente explicados:

Desde el código referenciaremos las librerías mediante:

#include <windows.h>
#include <gl/glut.h>

Cuando compilemos un programa que use la librería GLUT y stdlib.h (de VC nuevo como Visual Studio 2008) aparecerá el siguiente error:

error C2381: 'exit' : nueva definición; __declspec(noreturn) es diferente

Esto es debido a que algunas definiciones de stdlib.h han sido actualizadas. Para solucionarlo basta con modificar la línea 146 de glut.h:

extern _CRTIMP void __cdecl exit(int);

por:

extern _CRTIMP __declspec(noreturn) void __cdecl exit(int);


Así no aparecerán errores aunque sí algunas advertencias.

Con esto ya estaría configurado el entorno para desarrollar en Windows!

Configurar OpenGL y GLUT en Mac (XCode)

Configurar OpenGL y GLUT en Mac es muy sencillo :-) solo debemos seguir los siguientes pasos:

Vamos a utilizar las librerías de OpenGL de C++ (que viene intergradas con el OS) así que no usaremos Cocoa ni Objetive-C. El IDE que utilizaremos será XCode. Así que manos a la obra...

1. Iniciamos XCode y creamos un nuevo proyecto como Mac Os X >> Aplicacion con el template de "Command line tool" y de tipo C++ stdc++.
2. Desde el menú Project >> Add to project... buscamos las librerías de OpenGL y GLUT que se encuentran en /Sistema/Libreria/Frameworks/ y son OpenGL.framework y GLUT.framework respectivamente.

Con estos sencillos pasos ya tendríamos el entorno preparado para empezar a desarrollar, así de fácil!

Os dejo este video explicando los pasos anteriores.

Para más información visitar la página de desarrollador de Apple.

OpenGL basics: el comienzo de todo (II)

El modelo de ejecución de OpenGL es Cliente-Servidor. Una aplicación (el cliente) manda comandos que son interpretados y procesados por OpenGL (el servidor local o remoto). Este servidor puede tener varios contextos (Gl contexts).

A continuación vamos a ver como trabaja el servidor de OpenGL y como este proceso es realizado por una pipeline gráfica o máquina de estados.

Pipeline en OpenGL

En este diagrama se puede ver el pipeline. Los comandos entrarían por la izquierda.

1. En primer lugar en vez de lanzar todos los comandos por el pipeline se pueden acumular en el display list para procesarlos más tarde y de manera transaccional.
2. La fase del evaluator permite la evaluación de curvas y superficies. Esto permite crear superficies solo usando puntos de control.
3. Durante la fase per-vetex operations and primitive assembly, OpenGL procesa todas las primitivas que son transformadas y alumbradas. Además las primitivas son “clipeadas” por el viewport (esto no es mas que la geometría que quede oculta será filtrada y no se enviará a renderizar).
4. La rasterización es el proceso que permite mostrar gráficos con formas 3D en la pantalla.
5. Después de todo esto en la última fase per-fragment operations que se realizan las últimas operaciones en los datos antes de ser enviados al “frame buffer”. Estas operaciones incluyen actualizaciones condicionales del “frame buffer” basadas en valores para realizar z-buffering, blending o enmascaramiento entre otras operaciones lógicas sobre pixels.

En este punto conviene remarcar que los comandos aplicados sobre el “frame buffer” son controlados por el sistema de ventanas que es el que asigna los recursos del “frame buffer”. No hay comandos de OpenGL para configurar el “frame buffer”. Esta configuración se realiza fuera de OpenGL, de hecho la propia inicialización de OpenGL se realiza cuando el sistema de ventanas asigna una ventana para que OpenGL pueda renderizar. Existe una extensión de OpenGL llamada GLX, que proporciona una interfaz para comunicarse con las X. Yo personalmente utilizo GLUT que permite crear callbacks para manejar ventanas y los eventos de input del usuario (esto lo veremos más adelante).

* Por último, comentar que los datos de entrada pueden venir en forma de pixeles en vez de vértices, como por ejemplo una imagen para mapear una textura, se saltan la primera fase del procesado. El resultado en este caso es guardado en la “memory texture” para usarse en la fase de la rasterización, o rasterizarse y los fragmentos resultantes mezclarse en el “frame buffer” si son generados desde datos geométricos.  

OpenGL basics: el comienzo de todo (I)

Por mi experiencia, muchos programadores de gráficos utilizan las APIs gráficas como si fueran una “caja negra”.
Esto es bueno en un primer momento porque obtienes unos buenos resultados de una manera rápida pero tiene la contrapartida de que cuando se quiere profundizar en el uso de estas librerías no se tiene la base necesaria para ello. Además de que es posible que surjan errores fácilmente evitables.

Después de esta charla de “abuelo cebolleta” :-) pasemos a lo interesante.

OpenGL es una API que permite abstraerse del hardware de gráficos. Una aplicación que use OpenGL por una parte pintará primitivas, por otra seteará diversos comandos.

• Las primitivas son definidas como un conjunto de uno o mas vértices. Los datos (coordenadas, colores, normales, coord. de texturas,...) están asociados a los vértices.
• Los comandos son procesados en el orden en que son mandados además es muy importante el hecho de que OpenGL no pintará una primitiva hasta que reciba todos los comandos asociados. Veremos más adelante como estos comandos alterarán la sencilla máquina de estados por la que está formada OpenGL :-).