1.     Descomprime el archivo en cualquier directorio y verás que aparece el fichero glut.3.7.6+.DevPak, le das doble click y le das click al botón Install para continuar.

2.     Posteriormente el proceso de instalacion solo tomara unos pocos segundos.

3.     Una vez terminada la instalación se nos indica que el proceso ha sido exitoso y le damos click en Finish.

Prueba de la librería

1.     Abre el compilador, vas a Archivo -> Nuevo -> Proyecto y en la pestaña Multimedia seleccionas glut.

2.     Selecciona en donde quieres guardar el archivo del proyecto y se te presentará a continuación un código de ejemplo.

3.     Presiona CTRL+S para guardar el archivo fuente mostrado. Luego presiona CTRL+F9 para compilar el programa, se presentará un cuadro indicandonos que la compilación ha sido exitosa, damos click en Cerrar.

4.     Por último presiona CTRL+F10 para ejecutar el programa, verás una  pantalla con figuras geometricas en 3D, presiona ESC para salir.

Una aclaracion importante para terminar completamente la instalacion es configurarla para esto se debe abrir el compilador ir a Herramientas -> Opciones de Compilador y en el cuadro de titulo "Añadir estos comandos a la linea de comandos del linker" se copia -lglut32 -lglu32 -lopengl32 -lwinmm -lgdi32 -lm y finalmente hacer click en aceptar.

OpenGL es un estándar creado por Silicon Graphics en el año 1992 para el diseño de una librería 2D/3D portable [OPENGL]. Actualmente es una de las tecnologías más empleadas en el diseño de aplicaciones 3D, y su última versión, a la fecha de hoy, es la 1.5, y está en proceso la especificación de la versión 2.0, que incluirá muchas mejoras..
Se divide en tres partes funcionales:

– La librería OpenGL, que proporciona todo lo necesario para acceder a las funciones de dibujado de OpenGL.
– La librería GLU (OpenGL Utility Library), una librería de utilidades que proporciona acceso rápido a algunas de las funciones más comunes de OpenGL, a través de la ejecución de comandos de más bajo nivel, pertenecientes a la librería OpenGL propiamente dicha [REDBOOK].
– GLX (OpenGL Extension to the X Window System) proporciona un acceso a OpenGL para poder interactuar con un sistema de ventanas X Window, y está incluido en la propia implementación de OpenGL (su equivalente en Windows es la librería WGL, externa a la implementación de OpenGL).

Además de estas tres librerías, la librería GLUT (OpenGL Utility Toolkit) proporciona una interfaz independiente de plataforma para crear aplicaciones de ventanas totalmente portables [GLUT].

OpenGL aparece en GNU/Linux, habitualmente bajo la librería Mesa 3D [MESA], una implementación libre de OpenGL. Esta implementación es, de por sí, una implementación totalmente software de la librería OpenGL (excepto para las tarjetas 3dfx Voodoo1, Voodoo2, Voodoo Rush, Voodoo Banshee, Voodoo3, que tienen acceso al hardware a través del driver Mesa/Glide que proporciona Mesa), por lo que sólo es aconsejable utilizarla en el caso de no disponer de ninguna otra implementación de OpenGL. Actualmente (2004) la versión estable de esta librería es la 6.0.1, que implementa el estándar OpenGL 1.5. La utilización más habitual de esta librería, no obstante, se realiza a partir de la librería xlibmesa. Esta librería forma parte del sistema Xfree86, y proporciona acceso a aceleración gráfica por hardware, siempre que la tarjeta gráfica y los drivers instalados lo permitan, a través de DRI (Direct Rendering Infraestructure [DRI]). Este es el modo a través del que podemos acceder a aceleración por hardware para tarjetas de vídeo como 3dfx, Intel, Matrox, ATI... DRI está presente en las implementaciones del servidor Xfree86 a partir de la versión 4 del mismo. Más concretamente, la versión 4.3 de Xfree86 trae consigo la librería xlibmesa 4.0.4, que implementa el estándar OpenGL 1.3. Finalmente, las tarjetas NVIDIA proporcionan su propia implementación de la librería OpenGL, independientemente de la librería Mesa, si bien es cierto que ciertas partes de Mesa (las librerías de utilidades GLU y GLUT) pueden utilizarse junto con la implementación de NVIDIA.

A la hora de desarrollar aplicaciones OpenGL bajo GNU/Linux, se necesita las siguientes herramientas:
– Los binarios de la librería OpenGL, ya sea Mesa (compilado e instalado a partir del código fuente), xlibmesa (incluido con Xfree86 4 y posteriores) o drivers propios.
– Los paquetes de desarrollo de estas librerías (xlibmesa-dev, en el caso de xlibmesa, glutg3-dev... para drivers propios dependerá del fabricante, y para Mesa, si se ha instalado compilando el código fuente, no debería de haber problemas).
– Un compilador del lenguaje en el que se va a programar, por ejemplo en C, para lo que se usa el compilador gcc, y g++ si se utiliza C++.
– Un editor de texto, ya sea en modo consola, o bajo el entorno X Windows.

Manejo de las funciones de OpenGL

En este programa vamos a dibujar un cuerpo en pantalla con sus brazos, piernas, cabeza y torax:

#include <GL/glut.h> // Se bede incluir la libreria glut de OpenGL
#include<windows.h>
#include <unistd.h>
// Medidas del cuerpo
#define BODY_HEIGHT 4.0
#define BODY_WIDTH 2.5
#define BODY_LENGTH 1.0
#define ARM_HEIGHT 3.5
#define ARM_WIDTH 1.0
#define ARM_LENGTH 1.0
#define LEG_HEIGHT 4.5
#define LEG_WIDTH 1.0
#define LEG_LENGTH 1.0
#define HEAD_RADIUS 1.1
void display(void)
{
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
// Activamos el el Z-Buffer
glClearColor(0.0,0.0,0.0,0.0);
glClearDepth(1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Borramos el buffer de color y el Z-Buffer
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0,1.0,1.0,100.0);
// Proyección perspectiva. El ángulo de visualización es de 60
//grados, la razón ancho/alto es 1 (son inguales), la distancia
//mínima es z=1.0, y la distancia máxima es z=100.0
glMatrixMode(GL_MODELVIEW);
glTranslatef(0.0,0.0,-16.0);
// Dibujamos el cuerpo
glTranslatef(0,BODY_HEIGHT/2,0);
glPushMatrix();
glScalef(BODY_WIDTH,BODY_HEIGHT,BODY_LENGTH);
glColor3f(0.0,0.3,0.8);
glutSolidCube(1);
glPopMatrix();
// Dibujamos el brazo derecho
glPushMatrix();
glTranslatef(-(BODY_WIDTH)/2,(BODY_HEIGHT-ARM_HEIGHT)/2,0);
glTranslatef(0,ARM_HEIGHT/2,0);
glRotatef(-30,0,0,1);
glTranslatef(0,-ARM_HEIGHT/2,0);
glPushMatrix();
glScalef(ARM_WIDTH,ARM_HEIGHT,ARM_LENGTH);
glutSolidCube(1);
glPopMatrix();
// ya tenemos el brazo... la mano
glTranslatef(0,-(ARM_HEIGHT+ARM_WIDTH)/2,0);
glColor3f(1,0.6,0.6);
glScalef(ARM_WIDTH,ARM_WIDTH,ARM_LENGTH);
glutSolidCube(1);
glPopMatrix();
// Dibujamos el brazo izquierdo
glColor3f(0.0,0.3,0.8);
glPushMatrix();
glTranslatef((BODY_WIDTH)/2,(BODY_HEIGHT-ARM_HEIGHT)/2,0);
glTranslatef(0,ARM_HEIGHT/2,0);
glRotatef(30,0,0,1);
glTranslatef(0,-ARM_HEIGHT/2,0);
glPushMatrix();
glScalef(ARM_WIDTH,ARM_HEIGHT,ARM_LENGTH);
glutSolidCube(1);
glPopMatrix();
// ya tenemos el brazo... la mano
glTranslatef(0,-(ARM_HEIGHT+ARM_WIDTH)/2,0);
glColor3f(1,0.6,0.6);
glScalef(ARM_WIDTH,ARM_WIDTH,ARM_LENGTH);
glutSolidCube(1);
glPopMatrix();
//Dibujamos la pierna derecha
glColor3f(0.0,0.3,0.8);
glPushMatrix();
glTranslatef(-(BODY_WIDTH-LEG_WIDTH)/2,-
(BODY_HEIGHT+LEG_HEIGHT)/2,0);
glPushMatrix();
glScalef(LEG_WIDTH,LEG_HEIGHT,LEG_LENGTH);
glutSolidCube(1);
glPopMatrix();
// ahora el píe
glTranslatef(0,-(LEG_HEIGHT+LEG_WIDTH)/2,LEG_LENGTH);
glColor3f(0.3,0.4,0.4);
glScalef(LEG_WIDTH,LEG_WIDTH,LEG_LENGTH*2);
glutSolidCube(1);
glPopMatrix();
//Dibujamos la pierna izquierda
glColor3f(0.0,0.3,0.8);
glPushMatrix();
glTranslatef((BODY_WIDTH-LEG_WIDTH)/2,-
(BODY_HEIGHT+LEG_HEIGHT)/2,0);
glPushMatrix();
glScalef(LEG_WIDTH,LEG_HEIGHT,LEG_LENGTH);
glutSolidCube(1);
glPopMatrix();
// ahora el píe
glTranslatef(0,-(LEG_HEIGHT+LEG_WIDTH)/2,LEG_LENGTH);
glColor3f(0.3,0.4,0.4);
glScalef(LEG_WIDTH,LEG_WIDTH,LEG_LENGTH*2);
glutSolidCube(1);
glPopMatrix();
// Dibujamos la cabeza
glColor3f(1,0.6,0.6);
glPushMatrix();
glTranslatef(0,BODY_HEIGHT/2 + HEAD_RADIUS*3/4,0);
glutSolidSphere(HEAD_RADIUS,10,10);
glPopMatrix();
glFlush();
Sleep(3000);
exit(0);
}
int main(int argc, char ** argv)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA | GLUT_DEPTH);
glutInitWindowPosition(20,20);
glutInitWindowSize(500,500);
glutCreateWindow(argv[0]);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}

Funciones Basicas de glut.h

glEnable(opcion) funcion para activar una opcion.
glDisable(opcion) funcion para desactivar una opcion, la opcion a activar o desactivar debe ir dentro del parentesis.
glMatrixMode(GL_MODELVIEW) funcion para cambiar la matriz de visualizacion/modelado.
glMatrixMode(GL_PROJECTION) funcion para cambiar la matriz de proyeccion.
glPushMatrix() guarda una matriz en la cima de la pila.
glPopMatrix() saca y restaura la matriz de la pila.
glLoadIdentity() funcion que carga la matriz identidad como matriz activa.
glBegin(constante) funcion para iniciar el modo de dibujado.
glColor* selecciona el color.
glNormal* selecciona la normal.
glTexCoord* selecciona las coordenadas de textura.
glVertex* funciones de dibujado de vertices.
glTranslate* nos va permitir trasladar un objeto en el espacio.
glRotate* nos va permitir rotar un objeto.
glScale* nos va permitir escalar un objeto.
glMultMatrix multiplica la matriz de transformacion actual por una matriz dada.
glOtro para proyecciones ortograficas.
glScalef(ancho,alto,largo)para modificar los 3 parametros de la figura 3D.
glRotatef(x,y,z,1)para rotar la figura 3D en el espacio.
glutSolidSphere(radio,longitud de los lados,10)figura 3D con estos parametros.
gluLookAt(a,b,c,d,e,f,g,h,i)posiciona la camara ahorrando giros y traslaciones manuales a,b,c es la posicion de la camara en el espacio; d,e,f es la posicion hacia la que se esta mirando; g,h,i un vector que señala a la parte superior de la escena.
glutPostRedisplay() hace que tras la actualización se dibuje el siguiente frame.

Parametros Basicos de glut.h

GL_POINTS se dibujan vertices separados.
GL_LINES cada par de vertices se interpreta como una linea.
GL_POLYGON los vertices describen el contorno de un poligono.
GL_TRIANGLES cada triplete de vertices se interpreta como un triangulo.
GL_QUADS cada cuarteto de vertices se interpreta como un cuadrilatero.
GL_LINE_STRIP lineas conectadas.
GL_LINE_LOOP lineas conectadas con union entre el primer y ultimo vertice.
GL_TRIANGLE_STRIP se dibuja un triangulo y cada nuevo vertice se interpreta con un triangulo entre los dos anteriores vertices y el nuevo.
GL_TRIANGLE_FAN se dibuja triangulos con un vertice comun.
GL_QUAD_STRIP igual que el parametro TRIANGLE_STRIP con cuadrilateros.

Como un ultimo ejemplo de 3D con OpenGL un fractal conocido como "La Alfombra de Sierpinski":

#include<GL/glut.h>
void dibujarCuadro(float tam)
{
glBegin(GL_QUADS);
glVertex3f(-tam/1.7,tam/1.7,0.0);
glVertex3f(-tam/1.7,-tam/1.7,0.0);
glVertex3f(tam/1.7,-tam/1.7,0.0);
glVertex3f(tam/1.7,tam/1.7,0.0);
glEnd();
}
void dibujarCuadroRecursivo(float tam)
{
    if (tam > 0.005)
    {
        //cuadro del medio
        dibujarCuadro(tam);
        //cuadro de arriba
        glPushMatrix();
        glTranslatef(0.0, tam * 2.0, 0.0);
        dibujarCuadroRecursivo(tam / 2.0);
        glPopMatrix();
        //cuadro de abajo
        glPushMatrix();
        glTranslatef(0.0, -tam * 2.0, 0.0);
        dibujarCuadroRecursivo(tam / 2.0);
        glPopMatrix();
        //cuadro de la derecha
        glPushMatrix();
        glTranslatef(tam * 2.0, 0.0, 0.0);
        dibujarCuadroRecursivo(tam / 2.0);
        glPopMatrix();
        //cuadro de la izquierda
        glPushMatrix();
        glTranslatef(-tam * 2.0, 0.0, 0.0);
        dibujarCuadroRecursivo(tam / 2.0);
        glPopMatrix();
        //////////////////////////////////
        //izquierda arriba
        glPushMatrix();
        glTranslatef(-tam * 2.0, tam * 2.0, 0.0);
        dibujarCuadroRecursivo(tam / 2.0);
        glPopMatrix();
        //derecha abajo
        glPushMatrix();
        glTranslatef(tam * 2.0, -tam * 2.0, 0.0);
        dibujarCuadroRecursivo(tam / 2.0);
        glPopMatrix();
        //izquierda abajo
        glPushMatrix();
        glTranslatef(-tam * 2.0, -tam * 2.0, 0.0);
        dibujarCuadroRecursivo(tam / 2.0);
        glPopMatrix();
        //deracha arriba
        glPushMatrix();
        glTranslatef(tam * 2.0, tam * 2.0, 0.0);
        dibujarCuadroRecursivo(tam / 2.0);
        glPopMatrix();
    }
}
void display()
{
glClearColor(0,0,0,0);
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0,1.0,1.0,100.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.0,0.0,-6.0);
glColor3f(1.0,0.0,0.0);
dibujarCuadroRecursivo(1.0);
glFlush();
}
main()
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
glutInitWindowPosition(100,20);
glutInitWindowSize(900,900);
glutCreateWindow("Ventana");
glutDisplayFunc(display);
glutMainLoop();
}

AUTOR: Ing. Juan Pablo Arispe G.