GUIA DE BASICO DE OPENGL

1 Introduccion general
OpenGL esta definido como "Una interfaz de software para equipo fsico de grficos",
son grficos de 3D y bibliotecas de modelado, que son de forma porttil y muy rpida.
Con OpenGL se puede crear grficos de 3D elegantes y muy atractivos al igual que
animaciones de tipo realidad virtual, con la calidad visual de un trazador de
animaciones. La ventaja ms grande para usar OpenGL es el uso de instrucciones, estas
instrucciones son muy amigables para un principiante. OpenGL se ha desarrollado muy
rpidamente, ya que otros distribuidores y diseadores de grficos han aportado su
experiencia y propiedad intelectual para desarrollar proyectos para observar el
funcionamiento de OpenGL.
OpenGL no es un lenguaje de programacin en C C++. Mas bien es una herramienta
que en trminos de tecnologa de programacin se llama API (application program
interface). Es un conjunto de libreras de ejecucin escritos en lenguaje C, que lo
proporciona de una forma precompilada y ms sencilla.
Cuando un programa esta escrito en OpenGL, se hace uso de llamadas de una de las
funciones de OpenGL, la puesta de funcionamiento de un sistemas operativo (por
ejemplo el sistema operativo Windows de Microsoft ) efecta las funciones de
representacin grfica de 3D y de presentaciones en realidad virtual, la cual usted ve los
resultados en su ventana al realizar una aplicacin.
Los pasos para poner sus herramientas de compilador y vincularse a las bibliotecas de
OpenGL correctas, se desvan de herramienta a herramienta y de plataforma a
plataforma. Todo depende de algunas instrucciones graduales para Windows, Macintosh
y Linux.
En este caso nosotros utilizaremos el sistemas operativo Windows XP de Microsoft, sea
cual se la versin, se mencionara el funcionamiento de algunas bibliotecas, la biblioteca
de enlaces dinmicos de opengl32.dll, ubicado en el directorio de sistema de
Windows. Sobre la mayora de las plataformas, la biblioteca de OpenGL es acompaada
por la biblioteca de servicio pblico de OpenGL (GLU), que sobre el Windows est el
glu32.dll, tambin ubicado en el directorio de sistema. GLU incluye funciones ms
complejas programadas mediante el GL por ejemplo: definir un cilindro o un disco con
un solo comando, tambin contiene funciones para trabajar con "splines" y operaciones
con matrices. Otros comandos de GLU permiten crear conos, tazas de t y muchos ms.
Hay algunos prototipos para todas funciones de OpenGL, los tipos y las macros son
contenidos (por la convencin) en el archivo de encabezamiento gl.h. Si su programa
usa las funciones de biblioteca glu32.dll entonces se requiere el archivo de
encabezamiento glu.h. Estos archivos estn generalmente ubicados en un directorio
especial en su ruta de inclusin. Por ejemplo, las siguientes instrucciones muestran las
formas tpicas de encabezamientos iniciales para un programa comn de Windows que
usa OpenGL:

#include<windows.h>

#include<gl/gl.h>

#include<gl/glu.h>

2 Importacin de los ejemplos de OpenGL de libros de

texto al Visual Studio
Los pasos principales para importar un ejemplo son:

I. Ubicacin de ficheros y libreras

1. ubicar archivos de cabecera
2. ubicar archivos estticas
3. ubicar archivos dinmicos
II. utilizacin de un proyecto de OpenGL trabajando con
VisualStudio
III. adaptar el cdigo fuente del ejemplo.
las cuales se mencionaran mas delante cada una de ellas.
Se puede trabajar con OpenGL utilizando cualquier plataforma, ya que las libreras
existen dentro de Windows y en Linux .
GL y GLU: ya mencionadas en capitulo anterior. Es importante subrayar que esas
libreras son independientes de una plataforma.
GLUT: Esta librera nos sirve para que haya una comunicacin entre el programa base
de OpenGL y el sistemas operativo Windows. Permite utilizar funciones para el
tratamiento de ventanas, teclado y ratn.

I. Ubicacin de ficheros y libreras

Para el uso de OpenGL se mencionara en como utilizar bsicamente una aplicacin de
OpenGL, se dividen en dos Partes. La 1 Parte es una serie de pasos en buscar descargas
y/o instalar las bibliotecas de funciones gl, glu y glut de OpenGL. La 2 Parte es la
seccin de pasos de cmo adaptar un programa escrito en openGL para ambiente de
desarrollo Visual Studio.
1. Parte Hay dos pasos muy sencillos que son necesarios las cuales son indispensables:
Paso I.-

En Visual Studio ya se encuentran integrados los ficheros de Cabecera, las bibliotecas

dinmicas y las bibliotecas estticas esto es para el uso de OpenGL. Para actualizar o
integrar los ficheros y las bibliotecas en caso de que no existan dichos archivos en
Visual Studio. De la red hay que descargas los Ficheros de cabecera, Bibliotecas
dinmicas y Bibliotecas estticas necesarias. La direcciones (vigentes a la fecha de
escritura del instructivo actual) que se sugieren son las siguientes:
http://www.opengl.org/resources/libraries/glut/glut_downloads.php
http://www.xmission.com/~nate/glut.html
y descargar el archivo que tiene el nombre siguiente: glut-3.7.6-bin.zip (117 KB)
Paso II.- En este paso se mencionaran en donde se encuentran comnmente los ficheros
y las libreras
Los ficheros y las bibliotecas ya forman parte y automtica del visual Studio al igual del
sistema de Windows. Pero en caso de que no se encuentre en el directorio de sistema
Windows, por medio del Internet se descarga para su instalacin respectiva de los
ficheros, a continuacin se dan unos ejemplos de las rutas para la instalacin de las
libreras y ficheros.
1. ubicar archivos de cabecera.
Las libreras de funciones donde se genera las imgenes a partir de modelos 3D y
ms otras libreras auxiliares. Ficheros de cabecera: gl.h, glut.h y glu.h copiarlos y
pegarlos en las extensiones de:
. . . \Microsoft Visual Studio 8\VC\PlatformSDK\include\gl
Nota: La manera de sustituir el simbolo "..." en esa ruta para completarla depende de
donde y en que unidad se haya instalado el Visual Studio. Por ejemplo puede ser en la
unidad C: o D: o F o algn otro esto lo define el usuario.

2. ubicar archivos estticos.

Para las bibliotecas estticas copiar los archivos opengl32.lib, glu32.lib y glut.lib y
pegarlos en:
... \Microsoft Visual Studio 8\VC\PlatformSDK\lib
(Ver la Nota anterior respecto la sustitucin del smbolo "...")

3. ubicar archivos dinmicos.

Para las Bibliotecas dinmicas: opengl32.dll, glu32.dll, glut32.dll, copiar y pegar
en:
...WINDOWS \ system32
Ya mentado posteriormente, para estar en la carpeta de system32 depende de la
unidad de disco donde se haya instalado Windows XP, Windows 98 o algn otro, como
por ejemplo: C: \WINDOWS \ system32.
2. BLOQUE

Uso ilustrativo bsico de Visual Studio 2005 para

aplicaciones de OpenGL

Paso A.- En el men de Inicio se ejecuta y se abre la aplicacin de Microsoft Visual

Studio 2005, en la Figura 1 aparece la ventana que se muestra en la imagen cuando se
ejecuta por primera vez Microsoft Visual Studio 2005.

Figura 1

Paso B.- Para empezar a usar por primera vez Microsoft Visual Studio y se quiera
realizar un pequeo proyecto, primero se hace lo siguiente, se da clic en el men de File
y se sigue el siguiente paso.

File Project como se ve en la Figura 2

Figura 2

Paso C.- Una vez hecho esto, aparece el siguiente recuadro como en la Figura 3.

Figura 3
Cuando aparezca este recuadro hay que dar las especificaciones;

<Enter_name>: sustituir con el nombre que uno desee darle.

Location: se le da la direccin en donde tiene que guardar dicho documento.

Paso D.- Enseguida se realiza lo siguiente, hay que identificar a Win32 Console
Application, como se muestra en la Figura 4

Figura 4
Ya hecho esto se le da click en OK.
Paso E: En las figura 5 se muestra esta figura, solo se le da clic en Next.

Figura 5

En la Figura 6 mostrada se respeta las asignaturas de da de forma automtica, no se

modifica nada, se dejan as como estn y se le da click en Finish.
Figura 6

Ya realizado lo anterior, ya esta listo pasa crear su programa de openGL. En la figura se

muestra la ventana de aplicacin en la que se deber utilizar para las instrucciones
correspondientes para su aplicacin de OpenGLcomo en la Figura 7.

Figura 7

Se tienen que visualizar en su parte derecha que hayan generado los archivos como en la
Figura
8

Figura 8
Paso F: El siguiente paso es para haya reconocimiento de las libreras y aplicaciones
que necesita para el programa de openGl y no haya surgimiento de muchos errores.
Conforme a la figura 9 hay que realizar lo siguiente secuencia.

Site

File
Add
Existing
Web

Figura 9

Despus hay que ir a la direccin de donde se encuentra las extensiones .h

Figura 10
Cuanto aparezca la imagen como ya mostrada anteriormente en la figura 10, hay que
hacer lo siguiente, en:
File System:
(unidad donde este instalada Windows, tpica en C: \Archivos de Programa
Microsoft Visual Studio 8 \VC \ PlatformSDK \ Include \ gl
por ultimo hay que hacer click en la extensin de gl
Como se muestra en la figura 11, 12 y 13

Figura 11

Figura 13

Figura 13

Un click en abrir ( Open ) y que ah se encuentran las directivas de extensin *.h, que
son gl.h, glu.h, glut.h, glaux.h, estos son primordiales para los programas de openGL,
en la ventana del lado izquierda deben de aparecer las directivas mencionadas
anteriormente,
esto
es
donde
esta
nombrada:
Solution
"NombreDeSuProyecto.cpp"(2 projects), semejante a la figura 14.

Figura 14.

Una vez realizado estos pasos se presentara un ejemplo para que se tenga idea de que es
OpenGL y observar cuales son las aplicaciones que se realizan.

II. Utilizacin de un proyecto de OpenGL trabajando con Visual Studio

Como primer ejemplo se proporciona un programa que se muestra a continuacin,
copiar su programa y pegarlo en el programa "NombreDeSuProyecto.cpp"
creado automticamente por el Wizard de los proyectos, cuyo nombre fue introducido
por usuario en el Paso C. El programa debe situarse debajo de #include ``stdafx.h
esto se visualiza en la figura 14.
En la figura 14 se puede ver que esta marcado de color azul lo que se tiene
automticamente en el programa "NombreDeSuProyecto.cpp", esto antes de realizar
cambios.

Figura 15

Ejemplo 1: Un programa que requiere adaptacin

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <stdlib.h>
static GLfloat spin = 0.0;
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glPushMatrix();
glRotatef(spin, 0.0, 0.0, 1.0);
glColor3f(1.0, 1.0, 1.0);
glRectf(-25.0, -25.0, 25.0, 25.0);
glPopMatrix();
glutSwapBuffers();
}
void spinDisplay(void)
{
spin = spin + 2.0;
if (spin > 360.0)
spin = spin - 360.0;
glutPostRedisplay();
}
void reshape(int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-50.0, 50.0, -50.0, 50.0, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
void mouse(int button, int state, int x, int y)
{
switch (button) {
case GLUT_LEFT_BUTTON:
if (state == GLUT_DOWN)
glutIdleFunc(spinDisplay);
break;
case GLUT_MIDDLE_BUTTON:
if (state == GLUT_DOWN)
glutIdleFunc(NULL);
break;
default:
break;
}
}
/*
* Request double buffer display mode.
* Register mouse input callback functions
*/
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize (250, 250);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutMainLoop();
return 0;
}

III.- adaptar el cdigo fuente del ejemplo

Hay dos opciones para adaptar el cdigo fuente del Ejemplo 1 al programa
"NombreDeSuProyecto.cpp".
La primera opcin es una adaptacin del fragmento de NombreDeSuProyecto.cpp,
que debe hacer en:
int _tmain(int argc, _TCHAR* argv[])
{
return 0;
}

En ella incluye los siguientes pasos:

Primero lo que ha que hacer es copiar la ultima parte del programa que esta a partir de: int
main(int argc, char** argv), y pegarlo antes de return 0;. Quedando de la siguiente
manera:
//Prueba 1.ccp : Defines the entry point for the console application.
//
#include
#include
#include
#include

<GL/gl.h>
<GL/glu.h>
<GL/glut.h>
<stdlib.h>

static GLfloat spin = 0.0;

void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glPushMatrix();
glRotatef(spin, 0.0, 0.0, 1.0);
glColor3f(1.0, 1.0, 1.0);
glRectf(-25.0, -25.0, 25.0, 25.0);
glPopMatrix();
glutSwapBuffers();
}
void spinDisplay(void)
{
spin = spin + 2.0;
if (spin > 360.0)
spin = spin - 360.0;
glutPostRedisplay();
}
void reshape(int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-50.0, 50.0, -50.0, 50.0, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
void mouse(int button, int state, int x, int y)

{
switch (button) {
case GLUT_LEFT_BUTTON:
if (state == GLUT_DOWN)
glutIdleFunc(spinDisplay);
break;
case GLUT_MIDDLE_BUTTON:
if (state == GLUT_DOWN)
glutIdleFunc(NULL);
break;
default:
break;
}
}
/*
* Request double buffer display mode.
* Register mouse input callback functions
*/
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize (250, 250);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutMainLoop();
return 0;
}

int _tmain(int argc, _TCHAR* argv[])

{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize (250, 250);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutMainLoop();
return 0;
}

La parte que esta de color rojo se deben de poner diagonales al inicio de cada lnea de
instrucciones para que estos se muestren en forma de texto. Y las instrucciones que estn de
color azul hay que realizarles algunos cambios, como son los siguientes dos lneas de
instrucciones:

glutInit(&argc, argv);

cambiarlo por

glutInit(&argc,(char **)argv);

Hay que observar que solo se le agrega (char **).

glutCreateWindow (argv[0]);

cambiarlo por

glutCreateWindow ((char *)argv[0]);

Para este otro solo se le agrega (char *).

Mostrndose la figura 16 la forma que debe observarse al final de programa en la ventana
de aplicacin.

Figura 16

La segunda opcion es que en que el programa tambien puede funcionar sin hacer ningun
cambio que se menciono anteriormente, sin quitar o agregar otra cosa, dejarlo en su
forma original, se hace mencion de estos cambios ya que despues seran de utilidad ante
otros programas.
Otro cambio basico que se tiene que realizar al programa, que es fundamental,
independientemente que opcion de utilize, en las primeras tres lineas de intrucciones,
como se muestran a continuacion, copiar y cortar:
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

Estas instrucciones hay que

archivo stdafx.h, esto se
la parte izquierda debajo de
tiene por nombre Header
visualiza en la figura

pagarlos en
encuentran en
la carpeta que
Files, como se

Darle doble click

Al realizar todos los pasos dados, ya esta preparado para ejecutar el programa, para
ejecutarlo primero hay que compilar. Por lo tanto hay que hacer la siguiente secuencia:
Buil Buil Solution una vez que se haya mostrado que no hay errores y que
haya compilado el programa, se ejecuta el programa con:
Debug Start Debugging
Con esto ya se muestra la ejecucin del programa.

A continuacin se proporcionan dos programas ms de aplicacin para OpenGL

siguiendo los procedimientos anteriores.

Programa_2: Planetary System: planet.c

//Defines the entry point for the console application.
#include "stdafx.h"
static int year = 0, day = 0;
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}
void display(void)

{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 1.0, 1.0);
glPushMatrix();
glutWireSphere(1.0, 20, 16); /* draw sun */
glRotatef ((GLfloat) year, 0.0, 1.0, 0.0);
glTranslatef (2.0, 0.0, 0.0);
glRotatef ((GLfloat) day, 0.0, 1.0, 0.0);
glutWireSphere(0.2, 10, 8); /* draw smaller planet */
glPopMatrix();
glutSwapBuffers();
}
void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluPerspective(60.0, (GLfloat) w/(GLfloat) h, 1.0, 20.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
}
void keyboard (unsigned char key, int x, int y)
{
switch (key) {
case 'd':
day = (day + 10) % 360;
glutPostRedisplay();
break;
case 'D':
day = (day - 10) % 360;
glutPostRedisplay();
break;
case 'y':
year = (year + 5) % 360;
glutPostRedisplay();
break;
case 'Y':
year = (year - 5) % 360;
glutPostRedisplay();
break;
default:
break;
}
}
//int main(int argc, char** argv)
//{
//glutInit(&argc, argv);
//glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);
//glutInitWindowSize (500, 500);
//glutInitWindowPosition (100, 100);
//glutCreateWindow (argv[0]);
//init ();
//glutDisplayFunc(display);
//glutReshapeFunc(reshape);
//glutKeyboardFunc(keyboard);
//glutMainLoop();
//return 0;
//}

int _tmain(int argc, _TCHAR* argv[])

{
glutInit(&argc, (char **)argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize (550, 550);
glutInitWindowPosition (100, 100);
glutCreateWindow ((char *)argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
//glutMouseFunc(mouse);
glutMainLoop();
return 0;
}

En el archivo stdafx.h debe de visualizarse de esta forma:

// stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently, but
// are changed infrequently
//

#pragma once
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows
headers
#include <stdio.h>
#include <tchar.h>
// TODO: reference additional headers your program requires here
#include <stdlib.h>
//#include <GL/gl.h>
//#include <GL/glu.h>
#include <GL/glut.h>
Si no se encuentra de esta forma realize los cambios correspondientes.

Programa_3: Drawing a Lit Sphere: light.c

void init(void)
{
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_shininess[] = { 50.0 };
GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
glClearColor (0.0, 0.0, 0.0, 1.0);
glShadeModel (GL_SMOOTH);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
}

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glutSolidSphere (1.0, 20, 16);
glFlush ();
}
void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity();
if (w <= h)
glOrtho (-1.5, 1.5, -1.5*(GLfloat)h/(GLfloat)w,
1.5*(GLfloat)h/(GLfloat)w, -10.0, 10.0);
else
glOrtho (-1.5*(GLfloat)w/(GLfloat)h,
1.5*(GLfloat)w/(GLfloat)h, -1.5, 1.5, -10.0, 10.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize (500, 500);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

el archivo stdafx.h debe de visualizarse de esta forma:

// stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently, but
// are changed infrequently
//
#pragma once
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows
headers
#include <stdio.h>
#include <tchar.h>
// TODO: reference additional headers your program requires here
//#include <GL/gl.h>
//#include <GL/glu.h>
#include <GL/glut.h>