Guía OpenGL: Introducción y Configuración en Visual Studio

GUIA DE BASICO DE OPENGL
1 Introduccion general
OpenGL esta definido como "Una interfaz de software para equipo físico de gráficos",
son gráficos de 3D y bibliotecas de modelado, que son de forma portátil y muy rápida.
Con OpenGL se puede crear gráficos 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 más grande para usar OpenGL es el uso de instrucciones, estas
instrucciones son muy amigables para un principiante. OpenGL se ha desarrollado muy
rápidamente, ya que otros distribuidores y diseñadores de gráficos han aportado su
experiencia y propiedad intelectual para desarrollar proyectos para observar el
funcionamiento de OpenGL.
OpenGL no es un lenguaje de programación en C ó C++. Mas bien es una herramienta
que en términos de tecnología de programación se llama API (application program
interface). Es un conjunto de librerías de ejecución escritos en lenguaje C, que lo
proporciona de una forma precompilada y más 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 ) efectúa las funciones de
representación gráfica de 3D y de presentaciones en realidad virtual, la cual usted ve los
resultados en su ventana al realizar una aplicación.
Los pasos para poner sus herramientas de compilador y vincularse a las bibliotecas de
OpenGL correctas, se desvían 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 versión, se mencionara el funcionamiento de algunas bibliotecas, la biblioteca
de enlaces dinámicos de opengl32.dll, ubicado en el directorio de sistema de
Windows. Sobre la mayoría de las plataformas, la biblioteca de OpenGL es acompañada
por la biblioteca de servicio público de OpenGL (GLU), que sobre el Windows está el
glu32.dll, también ubicado en el directorio de sistema. GLU incluye funciones más
complejas programadas mediante el GL por ejemplo: definir un cilindro o un disco con
un solo comando, también contiene funciones para trabajar con "splines" y operaciones
con matrices. Otros comandos de GLU permiten crear conos, tazas de té y muchos más.
Hay algunos prototipos para todas funciones de OpenGL, los tipos y las macros son
contenidos (por la convención) 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 están generalmente ubicados en un directorio
especial en su ruta de inclusión. Por ejemplo, las siguientes instrucciones muestran las
formas típicas de encabezamientos iniciales para un programa común de Windows que
usa OpenGL:
#include<windows.h>
ó #include<gl/gl.h>
ó
#include<gl/glu.h>
2 Importación de los ejemplos de OpenGL de libros de
texto al Visual Studio
Los pasos principales para importar un ejemplo son:
I. Ubicación de ficheros y librerías
1. ubicar archivos de cabecera
2. ubicar archivos estáticas
3. ubicar archivos dinámicos
II. utilización de un proyecto de OpenGL trabajando con
VisualStudio
III. adaptar el código fuente del ejemplo.
las cuales se mencionaran mas delante cada una de ellas.
Se puede trabajar con OpenGL utilizando cualquier plataforma, ya que las librerías
existen dentro de Windows y en Linux .
GL y GLU: ya mencionadas en capitulo anterior. Es importante subrayar que esas
librerías son independientes de una plataforma.
GLUT: Esta librería nos sirve para que haya una comunicación entre el programa base
de OpenGL y el sistemas operativo Windows. Permite utilizar funciones para el
tratamiento de ventanas, teclado y ratón.
I. Ubicación de ficheros y librerías
Para el uso de OpenGL se mencionara en como utilizar básicamente una aplicación 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
sección de pasos de cómo 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
dinámicas y las bibliotecas estáticas 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
dinámicas y Bibliotecas estáticas 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 comúnmente los ficheros
y las librerías
Los ficheros y las bibliotecas ya forman parte y automática 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 instalación respectiva de los
ficheros, a continuación se dan unos ejemplos de las rutas para la instalación de las
librerías y ficheros.
1. ubicar archivos de cabecera.
▬ Las librerías de funciones donde se genera las imágenes a partir de modelos 3D y
más otras librerías 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 algún otro esto lo define el usuario.
2. ubicar archivos estáticos.
▬ Para las bibliotecas estáticas 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 sustitución del símbolo "...")
3. ubicar archivos dinámicos.
▬ Para las Bibliotecas dinámicas: 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 algún otro, como
por ejemplo: C: \WINDOWS \ system32.
2º. BLOQUE
Uso ilustrativo básico de Visual Studio 2005 para
aplicaciones de OpenGL
Paso A.- En el menú de Inicio se ejecuta y se abre la aplicación 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 pequeño 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 dirección 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 automática, no se
modifica nada, se dejan así como están 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 aplicación en la que se deberá utilizar para las instrucciones
correspondientes para su aplicación 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 librerías 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.
File → Add
→ Existing Web Site…
Figura 9
Después hay que ir a la dirección 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, típica en C: \Archivos de Programa
Microsoft Visual Studio 8 \VC \ PlatformSDK \ Include \ gl
por ultimo hay que hacer click en la extensión 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 extensión *.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. Utilización de un proyecto de OpenGL trabajando con Visual Studio
Como primer ejemplo se proporciona un programa que se muestra a continuación,
copiar su programa y pegarlo en el programa "NombreDeSuProyecto.cpp" creado
automáticamente 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
automáticamente en el programa "NombreDeSuProyecto.cpp", esto antes de realizar
cambios.
Figura 15
Ejemplo 1: Un programa que requiere adaptación
#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 código fuente del ejemplo
Hay dos opciones para adaptar el código fuente del Ejemplo 1 al programa
"NombreDeSuProyecto.cpp".
La primera opción es una adaptación 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 línea de
instrucciones para que estos se muestren en forma de texto. Y las instrucciones que están de
color azul hay que realizarles algunos cambios, como son los siguientes dos líneas 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 *).
Mostrándose la figura 16 la forma que debe observarse al final de programa en la ventana
de aplicación.
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 pagarlos en archivo stdafx.h, esto se encuentran en la parte
izquierda debajo de la carpeta que tiene por nombre Header Files, como se visualiza en
la figura
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 ejecución del programa.
A continuación se proporcionan dos programas más de aplicación 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>