Una vez instalado, nos disponemos a descargar la librería GLUT para Win32 desde la página de Nate Robins o directamente desde este enlace. Al descomprimir el zip descargado nos encontramos con 4 ficheros y un readme.

Ficheros de la librería GLUT para Win32

A continuación abrimos Visual C++ para empezar a configurarlo para incluir la librería. Primero vamos a Herramientas/Opciones….

Vamos a Herramientas/Opciones... para empezar a configurar.

En la ventana que se nos abre, seleccionamos en el árbol de la izquierda Proyectos y soluciones/Directorios de VC++.

Seleccionamos Proyectos y soluciones/Directorios de VC++.

En el desplegable de la esquina superior derecha seleccionamos “Archivos de inclusión“.

En el desplegable seleccionamos "Archivos de inclusión".

Hacemos clic sobre el icono de la carpeta para añadir un nuevo archivo de inclusión que podemos elegir haciendo clic en el botón con los tres puntos suspensivos. Ahí seleccionamos la carpeta de los archivos de glut (glut-3.7.6-bin).

Elegimos la carpeta glut-3.7.6-bin.

En esta misma ventana seleccionamos ahora “Archivos de biblioteca” mediante el mismo procedimiento incluyendo también la carpeta de la librería.

Realizamos el mismo procedimiento para archivos de biblioteca.

Elegimos la carpeta glut-3.7.6-bin.

Ahora debemos copiar la DLL que se incluye en el paquete de la librería en algún lugar en el que Windows la localice, por ejemplo, en C:\WINDOWS\system32.

Copiamos la glut32.dll en C:WINDOWSsystem32.

Ahora ya podemos crear un nuevo proyecto vacío mediante el menú Archivo/Nuevo/Proyecto.

Creamos un proyecto mediante el menú Archivo/Nuevo/Proyecto.

Elegimos en General, la opción de Proyecto vacío y establecemos un nombre para el proyecto, en este caso “Segmentation Fault”.

Elegimos Proyecto vacío y le damos un nombre.

A continuación, añadimos un fichero en el que incluir el código fuente haciendo clic derecho sobre Archivos de código fuente/Agregar/Nuevo Elemento….

Añadimos un nuevo fichero.

Le damos un nombre al fichero, por ejemplo, main.cpp.

Le damos un nombre al fichero.

En el nuevo fichero podemos incluir una ligera variante del código que propuse en el anterior post que os detallo a continuación:

#ifdef WIN32
#include <windows.h>
#endif

//include GLUT
#include <glut.h>

//set the macros for the window size
#define SIZEX 500
#define SIZEY 500

//initializing stuff
void init(void)
{
   glDisable( GL_DEPTH_TEST ); //triangles have two sides
   glDisable( GL_CULL_FACE ); //triangles have two sides
}

//Render one frame
void render(void)
{
   //Clear the window and the depth buffer
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

   //Render the triangle
   glBegin(GL_TRIANGLES);
   glColor3f(1.0f, 0.0f, 0.0f ); //change vertex color
   glVertex2d( -0.5f, -0.5f );

   glColor3f(0.0f, 1.0f, 0.0f ); //change vertex color
   glVertex2d( 0.5f, -0.5f );

   glColor3f(0.0f, 0.0f, 1.0f ); //change vertex color
   glVertex2d( 0.0f, 0.5f );
   glEnd();

   //Swap front and back buffer
   glutSwapBuffers();
}

int main(int argc, char **argv)
{
   //init all OpenGL stuff
   glutInit(&argc, argv); //init GLUT
   glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE ); //init framebuffer properties
   glutInitWindowSize(SIZEX, SIZEY); //init window dimensions
   glutCreateWindow("Segmentation Fault");  //create window

   //now that we have the window we can set the opengl state
   init();

   //set the callbacks
   glutDisplayFunc(render);  //render a frame
   glutIdleFunc(render);       //what to do when nothing happens

   //start the GLUT mainloop (this function will be executed in a loop)
   glutMainLoop();

   return 0;
}

El resultado debería ser, al igual que en la anterior entrega, un triángulo colorido.

Resultado final.

Os recuerdo, como siempre, que tenemos los comentarios para las dudas y problemas que os surjan. Salu2!

Fuentes

Javi Agenjo – http://www.tecn.upf.edu/~jagenjo/

En primer lugar debemos arrancar el entorno de desarrollo Xcode, por ejemplo desde la carpeta de Aplicaciones, y nos disponemos a crear un nuevo proyecto vacío haciendo clic en File/New Project y posteriormente, en la ventana emergente, Empty Project.

Creamos un nuevo proyecto en Xcode.

Seleccionamos proyecto vacío.

Luego debemos indicar un nombre para el proyecto. Para el ejemplo utilizaremos el nombre de “SegmentationFault”.

Damos nombre al proyecto.

Y ya tenemos el proyecto vacío creado. Ahora debemos empezar a configurarlo para que funcione con OpenGL y GLUT. Primero crearemos un nuevo Target, mediante Project/New Target o con el botón derecho encima de Targets y Add/New Target.

Añadimos un nuevo Target al proyecto.

Seleccionamos el tipo del Target como Cocoa Application y especificamos un nombre, por ejemplo, GLUT.

Seleccionamos Cocoa App como tipo de Target.

Especificamos un nombre para el Target.

A continuación se nos muestran las configuraciones por defecto del Target, de las cuales sólo deberemos modificar la entrada de GCC_PREFIX_HEADER para poner el campo en blanco. Recomiendo que utilicéis el buscador para encontrar la opción entre todas las existentes.

Configuración por defecto del nuevo Target.

Búsqueda de la entrada GCC_PREFIX_HEADER.

Eliminamos la información del campo Value.

Ahora debemos añadir a nuestro Target, los Frameworks de OpenGL y GLUT incluidos en la libraría del Sistema Operativo. Para ello clic derecho sobre el Target creado y seleccionamos Add/Existing Frameworks…

Añadimos los Frameworks de OpenGL y GLUT.

Nos aparecerá una ventana en la que deberemos seleccionar los Frameworks GLUT.framework y OpenGL.framework alojados en la carpeta /Sistema/Librería/Frameworks de nuestro disco duro. Podemos seleccionar ambos manteniendo pulsada la tecla cmd mientras clicamos.

Seleccionamos los frameworks GLUT y OpenGL de /System/Library/Framewoks.

En la ventana emergente que aparece después de seleccionarlos no modificamos nada y simplemente clicamos sobre Add.

Continuamos el proceso con las opciones por defecto pulsando Add.

Ahora ya tenemos configurado nuestro proyecto para que trabaje con las librerías OpenGL y GLUT. A continuación creamos un nuevo fichero de código fuente al proyecto para comprovar que todo funciona correctamente.

Añadimos nuevo fichero de código fuente.

Seleccionamos nuevo fichero vacío en el proyecto y especificamos un nombre, por ejemplo, main.cpp.

Seleccionamos nuevo fichero vacío.

Especificamos un nombre, p.e. main.cpp.

En el nuevo fichero podemos poner el código que os muestro a continuación que, si todo el proceso ha ido correctamente, debe renderizar un triángulo en pantalla.

//include GLUT
#include <GLUT/glut.h>;

//set the macros for the window size
#define SIZEX 500
#define SIZEY 500

//initializing stuff
void init(void)
{
   glDisable( GL_DEPTH_TEST ); //triangles have two sides
   glDisable( GL_CULL_FACE ); //triangles have two sides
}

//Render one frame
void render(void)
{
   //Clear the window and the depth buffer
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

   //Render the triangle
   glBegin(GL_TRIANGLES);
   glColor3f(1.0f, 0.0f, 0.0f ); //change vertex color
   glVertex2d( -0.5f, -0.5f );

   glColor3f(0.0f, 1.0f, 0.0f ); //change vertex color
   glVertex2d( 0.5f, -0.5f );

   glColor3f(0.0f, 0.0f, 1.0f ); //change vertex color
   glVertex2d( 0.0f, 0.5f );
   glEnd();

   //Swap front and back buffer
   glutSwapBuffers();
}

int main(int argc, char **argv)
{
   //init all OpenGL stuff
   glutInit(&amp;argc, argv); //init GLUT
   glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE ); //init framebuffer properties
   glutInitWindowSize(SIZEX, SIZEY); //init window dimensions
   glutCreateWindow("Segmentation Fault");	//create window

   //now that we have the window we can set the opengl state
   init();

   //set the callbacks
   glutDisplayFunc(render);  //render a frame
   glutIdleFunc(render);	     //what to do when nothing happens

   //start the GLUT mainloop (this function will be executed in a loop)
   glutMainLoop();

   return 0;
}

Y el resultado debe ser este:

Triángulo resultante del código del ejemplo.

Como siempre os digo, ante cualquier duda sabed que no cobramos por comentar. Salu2!

Fuentes

OneSadCookie – http://blog.onesadcookie.com/2007/12/xcodeglut-tutorial.html

Javi Agenjo – http://www.tecn.upf.edu/~jagenjo/