OpenGL Renderizado1 Básico con C++
-
Upload
gladys-pardo -
Category
Documents
-
view
420 -
download
19
Transcript of OpenGL Renderizado1 Básico con C++
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
1/185
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
2/185
OpenGLRenderizadoBsicoconC++
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
3/185
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
4/185
OpenGLRenderizado Bsico con C++
Primera Edicin
Diciembre 2011
Karina I. Batista A.
Angel A. Gonzlez P.
Mayoli M.Gonzlez
Guadalupe del C. Prez De La R.
Jos Luis Prez P.
Jos Carlos Rangel O.
Rosmely R. Rodriguez R.
Juan Antonio Santana G.
Universidad Tecnolgica de Panam
Santiago, Veraguas
2011
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
5/185
Este Libro se elabor como proyecto nal en la Asignatura Com-putacin Grca II, la cual fue impartida por la Profesora Milka de Gra-cia, en el II Semestre 2011.
Realizado por los estudiantes de Ingeniera de Sistemas y Com-putacin de IV ao del Centro Regional de Veraguas. Est dirigido es-peccamente a los estudiantes del curso de Computacin Grca II y
a cualquier persona interesada en entrar al mundo de la programacincon OpenGL. Basado en el contenido de la Asignatura cuyo cdigo es8465, del plan de Estudio de la carrera Licenciatura en Ingeniera deSistemas y Computacin (2007).
Sigue el esquema y la separacin de los temas segn el libroComputacin Grca: Manejo de Grcos con OpenGL, desarrollado
por el Dr. Euclides Samaniego Gonzlez
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
6/185
A Jos Manuel Diaz Zaid (q.e.p.d), amigo y
compaero.
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
7/185
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
8/185
vii
ContenidoPrefacio xii
Introduccin a Visual C++ 2010 con OpenGL 1
1. Introduccin a Visual C++ con OpenGL 2
1.1 Qu es OpenGL? 2
1.2 Cmo funciona OpenGL? 2
1.3 Libreras relacionadas con OpenGL 3
1.4 Bibliotecas y Encabezados 3
1.5 Sintaxis de una orden OpenGL 4
1.6 Estudio de las partes de una orden OpenGL 4
1.7 Tipos de datos de una orden OpenGL 5
1.8 Estructura de un programa OpenGL 5
1.8.1 Manejo de ventanas. 6
1.8.2 Funciones de visualizacin. 6
1.8.3 Ejecucin del programa. 7
1.8.4 Gestin de eventos. 7
1.8.5 Gestion de ventos en segundo plano. 7
1.8.6 Funciones de primitivas. 7
1.9 Microsoft Visual 2010 C++ y las Libreras Gracas de OpenGL 91.9.1 Instalacin de las libreras Gracas de Open GL. 9
1.9.2 Pasos para iniciar un proyecto con Visual C++ y libreras de OpenGL 9
1.9.2.1 Nuevo Proyecto 9
1.9.2.2 Aplicacin de consola 10
1.9.2.3 Seleccin de Proyecto Vacio 11
1.9.2.4 Aadir Archivo de cdigo fuente C++ 12
1.9.2.5 Compilacin, vinculacin y ejecucin de proyectos 14
1.10 Recomendaciones para crear un proyecto con Visual C++ y OpenGL 14
1.11 Entorno de programacin de OpenGL 15
1.11.1 Inclusin tpica de encabezamiento inicial. 15
1.11.2 El cuerpo del programa de una aplicacin en OpenGL 15
1.11.3 Modo de presentacin de la Ventana OpenGL 16
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
9/185
viii
1.11.4 Creacin de la ventana Open en pantalla 16
1.11.5 Establecer la devolucin de llamada que dibuja el contenido de la ventana.
16
1.11.6 Congurando el estado a interpretacin. 16
1.11.7 Bucle a la espera de eventos. 16
1.11.8 Llamadas de grcos OpenGL 17
1.11.9 Limpiando el bfer de color, borra todos los pixeles. 17
1.11.10 Limpiando la cola y los bufers de comando OpenGL 18
Referencias 18
Taller N 1 18
Taller N 2 19
Taller N 3 20Ejercicio N 1 21
Conceptos Fundamentales de OpenGL 23
2. Primitivas Geomtricas Bsicas 24
2.1 Sistemas De Coordenadas 24
2.2 Describiendo Puntos, Lneas Y Polgonos 26
2.2.1 Puntos 26
2.2.2 Lneas 26
2.2.3 Polgonos 27
2.2.4 Rectngulos 28
2.2.5 Curvas y supercies curvas 28
2.3 Especicando Vrtices 29
2.4 Dibujando Primitivas En OpenGL 30
2.4.1 Restricciones sobre el uso de glBegin y glEnd 31
2.4.2 Utilizando glBegin, glEnd() y glVertex para dibujar primitivas 32
2.5 Gestin De Caractersticas De Estados OpenGL 34
2.6 Desplegando Puntos, Lneas Y Polgonos 35
2.6.1 Detalles de puntos 35
2.6.2 Detalles de lneas 35
2.6.3 Detalles de polgonos 37
Referencias 40
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
10/185
ix
Taller N 4 41
Taller N 5 44
Ejercicio N 2 47
Ejercicio N 3 47
OpenGL Bsico en 3D 48
3. OpenGL Bsico en 3D 49
3.1 Mens desplegables 49
3.2 Creacin de una animacin sin parpadeo, eliminacin de caras traseras 50
3.3 Denir, situar y colocar la cmara que usa OpenGL 52
3.4 La Proyeccin en OpenGL 54
3.5 Visibilidad: Ocultacin de objetos (Z-Buffer) 57
3.6 Las Transformaciones en OpenGL 58
Referencias 61
Taller N 6 61
Taller N 7 65
Ejercicio N 4 66
Color, Materiales e Iluminacin 68
4. Color, Materiales e Iluminacin 69
4.1 Especicacin de un normal en OpenGL 69
4.2 Estableciendo el Modelo de Sombreado 70
4.3 Estableciendo las Propiedades del Material 72
4.4 Estableciendo el Modelo de Iluminacin 74
4.4.1 Luz Ambiente 74
4.4.2 Luz Posicional 76
4.4.3 Luz Direccional 77
4.5 Gestin de un Foco de Luz 79
4.6 Gestin de la atenuacin de la intensidad de la luz 80Referencias 81
Taller N 8 81
Ejercicio N 5 84
Trazado del Mapa de Textura 86
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
11/185
x
5. Trazado del Mapa de Texturas 87
5.1 Texturas 2D para polgonos 87
5.2 Filtrado de Una Textura 93
5.3 Aplicacin de texturas 2D sobre Primitivas GLUT 95
Referencias 105
Taller N 9 106
Taller N 10 108
Ejercicio N 6 111
Aspectos avanzados de OpenGL 112
6. Aspectos Avanzados de OpenGL 113
6.1 Geometras de las primitivas de los dibujos ecientes 113
6.2 Lista de Visualizacin 114
6.3 Especicacin de eliminacin de caras traseras 121
6.4 El efecto fusin en OpenGL 122
6.5 Uso de GlutIdleFuncyglutTimerFunc 124
6.5.1 Funcin GlutIdleFunc 124
6.5.2 Funcin GlutTimerFunc 125
6.6 Denicin de varias reas de dibujo. 125
6.7 Tratamiento de imagines en OpenGL: Guardar y recuperar imagines. 126
6.8 Especicacin de los vectores de vrtice en OpenGL. 131
6.9 Niebla 135
6.10 Cargar modelos .OBJ 140
Figura. Resultado de la ejecucin 142
Referencias 143
Taller N 11 143
Taller N 12 146
Ejercicio N 7 147OpenGL con otros Lenguajes 149
7. OpenGL con otros Lenguajes 150
7.1 Implementacin con C# 150
7.1.1 OpenTK 150
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
12/185
xi
7.1.2 Comenzar un nuevo proyecto 150
7.1.3 Primera Aplicacin con OpenTK 151
7.1.4 Windows Form y GLControl 158
7.2 Implementacin con Java 164
7.2.1 Instalacin de los complementos 165
7.2.2 Una aplicacin JOGL 167
Referencias 169
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
13/185
xii
Prefacio
El mundo ha cambiado enormemente en las ltimas dcadas, estos cambioshan sido propiciados en gran parte por un elemento comn, la computa-dora, la cual desde su aparicin ha tenido un gran desarrollo. Parte de este
desarrollo es la infografa o grcos por computadora desde la aparicin de inter-
faces que hacen ms sencillo el trabajo con el equipo, hasta los actuales avancesen animacin que van dirigidos al entretenimiento. En comparacin con los iniciosde la computacin grca donde el proceso de dibujar se basada en complicados
clculos matemticos y el ensayo y error, hasta la actualidad donde existen grancantidad de programas para el diseo grco se ha progresado mucho lo cual au -gura un futuro prometedor en cuanto a esta rea de la computacin. Inmerso en
este desarrollo se encuentra OpenGL el cual fue desarrollado en Silicon Graphics
Inc. a inicios de la dcada del 90. Esta es una herramienta que permite la creacinde grcos en 2D y 3D, al igual que animaciones; creaciones las cuales pueden
interactuar con los usuarios a travs de los diversos dispositivos de entrada.
OpenGL Renderizado Bsico en C++, incluye los conceptos bsicos paraaprender a programar grcos con OpenGL en C++, presenta un contenido car-gado de ejemplos para aclarar lo ms posible los conceptos presentados, as como
tambin talleres y ejercicios para estimular la capacidad creativa de los estudiantes.
Los contenidos del libro por captulo se pueden resumir de la siguiente manera:
En el captulo 1 se presenta una descripcin de que es OpenGL, deniendo
los conceptos y reglas que rigen el lenguaje, como funciona, que elementos y li -breras se requieren y en que carpetas deben ser copiadas, para la construccin deuna aplicacin o programa en Visual C++ 2010 utilizando las libreras grcas de
OpenGL. Adems se mostraran los pasos para realizar la ejecucin de un proyecto
con Visual C++ 2010 utilizando OpenGL y los mtodos para compilar y ejecutaruna aplicacin.
En el captulo 2 se describen las primitivas geomtricas en funcin a sus vr-tices, a los cuales se les asocian coordenadas, que son las que denen los puntos
de inicio y n de un segmento de lnea o bordes de un polgono. En este captulo
explicaran como se dibujan primitivas mediante la especicacin de un conjunto de
vrtices; y mostrar las funciones de OpenGL que permiten el dibujo de lneas apli -
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
14/185
xiii
cando los patrones de lneas y los patrones de relleno para los polgonos.
En el captulo 3 mostraremos las diferentes funciones y mtodos bsicos
que nos ofrece OpenGL para trabajar grcos en 3D, as como las distintas formas
de aplicar los mismos para obtener el resultado deseado en las diversas tareas a
realizar que se nos presenten en el camino.En el captulo 4, aprenderemos a implementar el uso de colores, materi-
ales, sombras as como tambin la iluminacin (llamase luces), que se le puedeaplicar a los objetos creados para una mejor proyeccin de lo que se est realizan -do. Describiremos las funciones adecuadas para dicho n, a la vez, detallando los
cambios y la manera, en que se debe implementar dichas funciones para obtener
un buen resultado.
En el captulo 5 se presentan las funciones necesarias para aplicar textu-ras a una primitiva (polgono, triangulo, etc.). Se muestran tambin los parmetrosnecesarios para la utilizacin de dichas funciones, y a la vez se pueden realizar
algunos talleres en los que se puede practicar como se utilizan estas funciones enaplicaciones de C++ con OpenGL.
En el captulo 6 se muestran conceptos avanzados de OpenGL como laslistas de visualizacin, eliminacon de caras traseras, niebla, denicin de reas de
dibujo, entre otras. Estos conceptos combinados con los explicados en los captu-los anteriores enriquecen, los conocimientos sobre OpenGL, lo cual permite crearuna gran variedad de aplicaciones diferentes.
En el captulo 7 se presenta una introduccin al trabajo con OpenGL en otros
lenguajes como lo es C#, explicando la manera de trabajar con este en el entorno
Visual Studio. Tambin se aborda la implementacin de OpenGL en Java con el
entrono NetBeans.
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
15/185
C a p t u l o
1
DESCRIPCIN:
En este captulo se tratara sobre la intro-duccin a OpenGL, como interface de pro-gramacin para crear gracos 3D. se de-scribir que es OpenGL, como funciona, que
elementos requiere, sus libreras gracas:glut.dll, glut32.dll, glut32.lib, glut.lib,glut.h.
Adems se presentaran los aspectos a con-siderar para la creacin de un proyecto enOpenGL.
OBJETIVOS:
Conocer los concep-tos fundamentales deOpenGL para visu-alizar grficos 3D en
una aplicacin.
Enumerar las ventajas
de utilizar OPenGL alaislarnos del hard-ware disponible.
Describir las libreras
y el conjunto de co-mandos utilizadospara las aplicacionescon OpenGl.
Conocer la estructurade un programa queutilice OpenGL.
Presentar el cdigode una aplicacin util-iozando OpenGL que
permita observar laforma implementadaen la utilizacin deesta herramienta.
Introduccin a Visual C++ 2010
con OpenGL
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
16/185
2
Captulo 1 - Introduccin a Visual C++ 2010 con OpenGL
1. Introduccin a Visual C++ con OpenGL
1.1 Qu es OpenGL?
Se dene como una interface de programacin de aplicacin para crear grcos
3D. bsicamente se trata de una librera de funciones que permiten visualizar gr-cos 3D en una aplicacin, adems de que es una herramienta de programacincon grcos portable, que ofrece una gran disponibilidad usando interfaces de pro-gramacin de aplicaciones para grcos 2D e imgenes, y gran potencia en el
manejo de grcos 3D de manera fcil y rpida.
Consta de unas 120 funciones distintas, que especican los objetos y las op-eraciones necesarias para producir aplicaciones interactivas en las que intervienengrcos en tres dimensiones.
Esta diseado de forma completamente independiente del hardware por
lo que puede implementarse en plataformas muy diversas (PC, SGI, Digital, Sun,
etc. El precio que hay que pagar en aras de esta portabilidad, es que OpenGL noincluye comandos para gestionar el sistema de ventanas, ni para capturar rdenesde los usuarios, ya sea por ratn o por teclado. En lugar de esto, debemos traba-
jar con la ayuda de cualquier sistema de ventanas que se utilice en la mquina en
concreto en la que estemos trabajando. En nuestro caso utilizaremos el sistema de
ventanas de Windows.
1.2 Cmo funciona OpenGL?
Al trabajar con OpenGl se deben realizar una serie de pasos tales como llamadas
a los comandos de OpenGL que se necesitan para conseguir cierto aspecto, apari-encia o efecto; en vez de escribir la escena y como debe aparecer. Estos coman-dos son utilizados para dibujar primitivas gracas en 3D(puntos, lneas, polgonos);
transformacin de primitiva, atencin a eventos de teclado, raton y ventana; traza-do de texturas; ltrado, denicin de materiales, iluminacin, sombreados; fusin;
menus despegables; transpariencia; niebla, animacin y otros muchos eventos y
opciones especiales.
Cabe destacar que OpenGL funciona para muchas propiedades como una
mquina de estados. Es decir si a una propiedad se le asigna un valor determinado,todo lo que se haga a partir de ese momento se ver afectado por ese valor, hasta
que este se modique o desactive de forma explcita. Por ejemplo, una de esas propiedades es el color actual, con el que se pin-tan los objetos. De esta forma, si asignamos a la propiedad color actual por ejemplo
el valor ROJO, todos los puntos, lneas y polgonos que se dibujen a continuacin
sern de color rojo, hasta que se modique este valor de forma explcita, mediante
la funcin adecuada.
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
17/185
3
Captulo 1 - Introduccin a Visual C++ 2010 con OpenGL
Las propiedades que funcionan de esta forma son:
Color actual.
Punto de vista.
Transformaciones de proyeccin.
Estilo de lneas y polgonos. Modos de dibujar polgonos.
Convenciones de empaquetado de bits.
Posicin y caractersticas de las fuentes de iluminacin.
Propiedades de los materiales de los objetos.
1.3 Libreras relacionadas con OpenGL
Las libreras relacionadas con OpenGl se han desarrollado con el n de simplicarlas tareas de programacin.
Se divide en tres partes funcionales:
La librera OpenGL,que proporciona todo lo necesario para ac-ceder a las funciones de dibujado de OpenGL.
La librera GLU(OpenGL Utility Library), una librera de utilidadesque proporciona acceso rpido a algunas de las funciones ms
comunes de OpenGL., a travs de la ejecucin de comandos de
ms bajo nivel, pertenecientes a la librera OpenGL propiamente
dicha.
GLX (OpenGL Extension to the X Window System) proporciona unacceso a OpenGL para poder interactuar con un sistema de ven-tanas X Window, y est incluido en la propia implementacin deOpenGL (su equivalente en Windows es la librera WGL, externa ala implementacin de OpenGL).
Adems de estas tres libreras, la librera GLUT (OpenGL Utility Toolkit) pro-porciona una interfaz independiente de plataforma para crear aplicaciones de ven-tanas totalmente portables.
1.4 Bibliotecas y Encabezados
OpenGL es una biblioteca de programacin que posee muchas implantaciones. Lacompatibilidad que ofrece Microsoft Windows para OpenGL es como un interpreta-dor de software.
opengl32.dll. Es una librera del software de Microsoft, de de-
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
18/185
4
Captulo 1 - Introduccin a Visual C++ 2010 con OpenGL
sarrollo, biblioteca de vnculo dnmco, en la que se encuentrala implantacin del software de Microsoft, y est localizada en el
directorio del sistema Windows (C:\Windows\System32).
gl.h: Es el archivo encabezado que contiene todos los prototipos
de funciones, tipos y superficies. glut.h. Es el archivo de encabezado que contiene todas las fun-
ciones de la biblioteca de utilidades.
Estos 2 ltimos archivos se encuentran localizados en un directorio especialen la ruta de acceso include (C:\Program Files\Microsoft Visual Studio 10.0\VC\
include).
1.5 Sintaxis de una orden OpenGL
Una orden OpenGL maneja un conjunto de prejos y sujos a identicar de datos o
el nmero de parmetros con el que trabaja, entre otros. La sintaxis de una orden
OpenGl es:
gl [234] [dsi] [v] (args)
gl. El identificar de cada orden de OpenGL inicia siempre con elprefijo gl.
: Es el comando raz de OpenGL.
Los sufijos definen el numero de parmetro de la orden(2,3 o 4) yel tipo de dato(doubl, short, int, float, )
1.6 Estudio de las partes de una orden OpenGL
Las partes de la funcin OpenGL indican de que la biblioteca es la funcin, la
cantidad y tipos de argumentos que acepta la funcin. Cada una de las funciones
OpenGL tienen una raz que representa el comando OpenGL correspondiente.
Ejemplo
glVertex2i ()
gl: funcin de la librera OpenGLglut
vertex: comando raz
2: cantidad de argumentos que se envan.
I: tipo de argumentos enteros.
glColor3f ()
gl: Prefijo que representa a la biblioteca GL.
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
19/185
5
Captulo 1 - Introduccin a Visual C++ 2010 con OpenGL
Color: comando bsico que tiene la raz color.
3: sufijo que indica el numero de argumentos.
F: sufijo que indica tipo de argumentos flotante.
1.7 Tipos de datos de una orden OpenGL
OpenGl dene sus propios tipos de datos que facilitan la portabilidad del cdigo
OpneGl de una plataforma a otra.
A continuacin, mostraremos el signicado de los sujos utilizados para es-pecicar los distintos tipos:
Sujo literal
en CTipo de dato Denicin como
tipo CTipo de datos
OpenGL
b Entero de 8 bits signed char GLbyte
s Entero de 16 bits short GLshort
i Entero de 32 bits int o long GLint, GLsizei
f Coma otante 32
bits oat GLoat, GLclampf
d Coma otante 64
bitsdouble GLdouble, GLclampd
ubEntero de 8 bits
sin signo
unsigned char GLubyte, GLboolean
usEntero de 16 bits
sin signounsigned short GLushort
uiEntero de 32 bits
sin signounsigned int
GLuint, GLenum,
GLbiteld
Tabla Sujos de instrucciones OpenGL
1.8 Estructura de un programa OpenGL
OpenGl es una librera graca que permite el uso de ms de doscientas rdenes
para la generacin de aplicaciones interactivas. Las principales acciones que sepueden realizar mediante rdenes OpenGL incluyen las especicaciones de los
objetos y las operaciones necesarias para producir aplicaciones interactivas en 3D.
La librera OpenGL est formada por seis grupos de funciones: manejo de
ventanas, funciones de visualizacin, ejecucin del programa, gestin de eventos,
gestin de eventos en segundo plano y funciones primitivas.
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
20/185
6
Captulo 1 - Introduccin a Visual C++ 2010 con OpenGL
1.8.1 Manejo de ventanas.
Este grupo de funciones permiten la inicializacin del sistema para que abra una
ventana graca para dibujar. Forman parte de estas funciones:
glutInit(int *argc, char **argv); Inicializa las utilidades deOpenGL. Esta funcin es la que inicializa la GLUT, y negocia con
el sistema de ventana para abrir una. Adems sus argumentosson los estndares para pasar informacin sobre los comandos de
lnea.
glutInitDisplayMode(unsigned int mode); Selecciona el modopantalla. Define el modo en el que debe dibujar la ventana. Es
decir, especifica el modo de visualizacin. Los parmetros se de -finen como flags o mascaras de bits.
glutInitWindowPosicion(int x, int y);Posiciona la ventana enla pantalla. Especifica la posicin de la ventana. Posicin x e y de
la esquina superior izquierda de la nueva ventana con respecto alescritorio que se trate.
glutInitWindowSize(int width, int size); Selecciona el tamaode la ventana. Especica el ancho y alto de la nueva ventana.
glutCreateWindow(char *cadena); Abre la ventana. Esta funcin esla que crea una ventana de visualizacin habilitada para OpenGL yel parmetro es el nombre o titulo de la misma, es decir, la funcin
acta poniendo el titulo indicado en la barra superior de la ventana.
1.8.2 Funciones de visualizacin.
Dene la funcin que se llamara para visualizar la escena, y la que permite forzar
esta llamada. Verbigracia, cuando se produce un cambio en la escena.
glutDisplayFunc(void (*func)(void)); Especifica la funcin quedibuja la escena. Esta funcin establece la funcin de devolucin
de llamada de la presentacin para la venta actual.
glutPostRedisplay(void);Actualiza la ventana actual. Esta funcin
informa a la GLUT que la ventana actual necesita actualizarse, esdecir, refresca el dibujo de la escena.
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
21/185
7
Captulo 1 - Introduccin a Visual C++ 2010 con OpenGL
1.8.3 Ejecucin del programa.
La funcin de este grupo comienza la ejecucin del programa, visualiza todas las
ventanas creadas, permite el envi de rdenes y gestiona los eventos que se gen-eran.
glutMainLoop();Desencadena la ejecucin del programa, inicia elproceso de bucle principal del GLUT. La funcin sede el control del
flujo del programa a la GLUT.
1.8.4 Gestin de eventos.
El grupo de funciones de la gestin de eventos especican las rutinas que se eje -cutan cuando se produce un evento determinado.
glutReshapeFunc (void (*func(int anc, int alt))); Gestion deevento de redimensionamiento de la ventana.
glutKeyboardFunc(void(*func (unsigned char tecla, int x, inty)));Gestion de eventos del teclado. Funciona cuando se pulsauna tecla.
glutMouseFunc(void (*func (int botn, int estado, int x, inty)));Gestin de eventos del raton. Funciona cuando se pulsa unbotn del raton.
glutMotionFunc( void(*func (int x, int y)));Gestion de eventosderaton. Funciona cuando se mueve el raton con un botn pulsado.
1.8.5 Gestion de ventos en segundo plano.
La funcin de la gestin de eventos en segundo plano especica la rutina que se
ejecuta cuando no hay otros eventos pendientes, se utiliza comnmente para reali-zar animaciones.
glutldleFunc(void( *func(void));
1.8.6 Funciones de primitivas.
Este grupo perimite visualizar las primitivas de objetos prdenidos de dibujos mas
completjas que las que incluyen OpenGL.
glutWireCone(base, heigth, stacks), glutSolidCone(base,height, slices, stacks)
glutWireCube(size), glutSolidCube(size)
glutWireDodecahedron(void), glutSolidDodecahedron(void)
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
22/185
8
Captulo 1 - Introduccin a Visual C++ 2010 con OpenGL
glutWirecosahedron(void), glutSolidcosahedron(void)
glutWireOctahedron(void), glutSolidOctahedron(void)
glutWireSphere(radius, slices, stacks), glutSolidSphere(radius,slices, stacks)
glutWireTeapot(void), glutSolidTeapot(void) glutWireTetrahedron(void), glutSolidTetrahedron(void)
Cono Cubo
Dodecaedro Icosaedro
Octaedro Esfera
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
23/185
9
Captulo 1 - Introduccin a Visual C++ 2010 con OpenGL
Tetraedro Torus
Tetera
1.9 Microsoft Visual 2010 C++ y las Libreras Gracas de OpenGL
En esta parte se explicara cmo crear un proyecto utilizando OpenGL y GLUT enVisual C++.
1.9.1 Instalacin de las libreras Gracas de Open GL.
Para poder trabajar con OpenGL. Se deben instalar los siguientes archivos:
Archivos Direccion de las carpetas
glut.dll glut32.dll C:\Windows\System32glut32.lib glut.lib C:\Program Files\Microsoft Visual Studio 10.0\VC\lib
glut.h C:\Program Files\Microsoft Visual Studio 10.0\VC\include
Estos archivos se pueden obtener de la siguiente direccin http://www.xmission.
com/~nate/glut/glut-3.7.6-bin.zip.
1.9.2 Pasos para iniciar un proyecto con Visual C++ y libreras de OpenGL
Los pasos a seguir son los siguientes:
1.9.2.1 Nuevo Proyecto
Para crear un nuevo proyecto del tipo Aplicacin de Consola Win32 se debe selec-cionar Archivo Nuevo Proyecto , como se indica en la gura 1.
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
24/185
10
Captulo 1 - Introduccin a Visual C++ 2010 con OpenGL
Figura 1. Nuevo Proyecto
1.9.2.2 Aplicacin de consola
Estando la ventana Nuevo Proyecto activa, seleccionar la opcion Aplicacin deConsola Win32. Indique el nombre del nuevo proyecto y el lugar donde se deseaguardar.
Figura 2. Aplicacin de Consola
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
25/185
11
Captulo 1 - Introduccin a Visual C++ 2010 con OpenGL
1.9.2.3 Seleccin de Proyecto Vacio
Al seleccionar aceptar en la ventana de Nuevo Proyecto (Figura 2) aparecera laventana del Asistente para Aplicaciones Win32 (Figura 3), en este seleccionamossiguiente, con lo cual aparecera las opciones de conguracin de la aplicacin del
asistente(Figura 4), en esta seleccionamos proyecto vacio.
Figura 3. Asistente para Aplicaciones Win32
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
26/185
12
Captulo 1 - Introduccin a Visual C++ 2010 con OpenGL
Figura 4 Conguracin de la Aplicacin
Recuerde que a partir de ahora, estamos trabajando con los espacios de trabajo
(Workspoce), por lo tanto para seguir trabajando debemos abrir siempre el espacio
de trabajo.
1.9.2.4 Aadir Archivo de cdigo fuente C++
Para aadir un archivo de cdigo fuente C++ se debe seleccionar ProyectoAgregar
Nuevo Elemento como se indica en la Figura 5.
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
27/185
13
Captulo 1 - Introduccin a Visual C++ 2010 con OpenGL
Figura 5. Aadir Nuevo Elemento
Luego aparecera la ventana de Agregar nuevo elemento (Figura 6), dondeseleccionamos Archivo C++ (.cpp) e indicamos el nombre para nuestro archivo.
Figura 6. Ventana de Agregar nuevo elemento
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
28/185
14
Captulo 1 - Introduccin a Visual C++ 2010 con OpenGL
El archivo que agreguemos se ubicara bajo la carpeta Archivos de cdigo fuente,
en el explorador de soluciones de Visual C++ 2010 (Figura 7).
Figura 7. Ubicacin del elemento agregado
1.9.2.5 Compilacin, vinculacin y ejecucin de proyectos
Para compilar podemos utilizar cualquiera de estos mtodos:
Compilar (Compile) Ctrl + F7
Generar F7Iniciar sin Depurar Ctrl + F5
Iniciar Depuracin F5
1.10 Recomendaciones para crear un proyecto con Visual C++ yOpenGL
Es importante tomar en cuenta los siguientes puntos:
Ahorro de espacio en la unidad de disco.
Ahorro de tiempo al evitar tener que crear un proyecto nuevo concada practica.
Solo sern por tanto necesario tener almacenado un proyectoprototipo y los distintos ficheros correspondientes a los cdigos
fuentes de cada practica.
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
29/185
15
Captulo 1 - Introduccin a Visual C++ 2010 con OpenGL
1.11 Entorno de programacin de OpenGL
Para ir familiarizndose un poco con la aplicacin, tenemos este cdigo ejemplo:
#include
#include
#include
Void Mostrar(void){
glClear(GL_COLOR_BUFFER_BIT)glfrush();}
Void Iniciar(void){
glClearColor(0.0, 1.0, 0.0, 1.0)int main(int argc, char **argv){
glutInitDisplayMode(GLUT_SINGLE | GLUT_glutCreateWindows(Mi primer programa);glutDisplayFunc(Mostrar);Iniciar();glutMainLoop();return 0;
}
1.11.1 Inclusin tpica de encabezamiento inicial.
#include
#include
#include
1.11.2 El cuerpo del programa de una aplicacin en OpenGL
Int main (int argc, char **argv){
}
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
30/185
16
Captulo 1 - Introduccin a Visual C++ 2010 con OpenGL
1.11.3 Modo de presentacin de la Ventana OpenGL
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); //Selecciona el modo
pantalla
Sintaxis: void glutInitDisplayMode (unsigned int mode)
Propsito: Inicializa el modo de presentacin de la ventana OpenGLde la biblioteca GLUT.
Parmetros: Mode: indica una marcara o combinacin de mascar-as de bits que describen las caractersticas de la ventana.
1.11.4 Creacin de la ventana Open en pantalla
glutCreateWindows(Mi primer Programa) // Abre la ventana Sintaxis: int glutCreateWindows(Char *name)
Propsito: crea una ventana GLUT de alto nivel habilitada paraOpenGL, que ers considerada ventana actual.
Parmetros: Name: titulo o nombre de la ventana.
1.11.5 Establecer la devolucin de llamada que dibuja el contenido de la ven-tana.
glutDisplayFunc(mostrar) //Registra la funcin redibujar. Sintaxis: void glutDisplayFunc(void(*func)(void));
Propsito: indica a GLUT que debe llamar siempre que se tengaque dibujar el contenido de la ventana.
Parmetros. Func: nombre de la funcin que ejecutaba la inter-pretacin.
1.11.6 Congurando el estado a interpretacin.
La lnea de cdigo Iniciar ();es la funcin que establece el contexto a seguiry que realiza cualquier iniciacin de OpenGL que debera ejecutarse antes de la
interpretacin.
1.11.7 Bucle a la espera de eventos.
glutMainLoop(); Sintaxis: void glutMainLoop(void)
Propsito: esta funcin inicia el proceso de evento principal deGLUT es el lugar donde se procesan todos los mensajes.
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
31/185
17
Captulo 1 - Introduccin a Visual C++ 2010 con OpenGL
1.11.8 Llamadas de grcos OpenGL
glClearColor(0.0, 0.0, 0.0, 1.0);
Sintaxis: void glClearColor(GLclampf red, GLclampf green,
Glclampf blue, GLclampf alpha)
Propsito: establece los valores de relleno que se utilizan cuandose borren los buferes de ojo, verde, azul y transparencia.
Parmetros:
GLclampf red, componente rojo del valor de relleno
GLclampf green, componente verde del valor de relleno
Glclampf blue, componente azul del valor de relleno
GLclampf alpha, componente transparencia del valor de relleno
COLOR COMPUESTO COMPONENTEROJO VERDE AZUL
Amarillo 1 0 0
Azul 0 0 1
Blanco 1 1 1
Can 0 1 1
Gris claro 0.75 0.75 0.75
Gris oscuro 0.25 0.25 0.25
Magenta 1 0 1
Marrn 0.6 0.4 0.12Naranja calabaza 0.98 0.625 0.12
Negro 0 0 0
Prpura 0.6 0.4 0.7
Rojo 1 0 0
Rosa Pastel 0.98 0.04 0.7
Verde 0 1 0
Tabla Algunos colores comunes y sus valores de componente
1.11.9 Limpiando el bfer de color, borra todos los pixeles.
glClear(GL_COLOR_BUFFER_BIT);La lnea de cdigo GLUT establece que OpenGL, para usar el color verde de bor-rado es la orden glClear.
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
32/185
18
Captulo 1 - Introduccin a Visual C++ 2010 con OpenGL
La funcin borra un bufer o una combinacin determinada, la sintaxis de la funcin
es: void glClear(Glbitfdield mask). Limpia los buffers especcos asignndoles
los valores actuales. El argumento mask puede tener los siguientes valores:
Buffer NombreDe color GL_COLOR_BUFFER_BIT
De fondo GL_DEPTH_BUFFER_BIT
De acumulacin GL_ACCUM_BUFFER_BIT
De patron GL_STENCIL_BUFFER_BIT
1.11.10 Limpiando la cola y los bufers de comando OpenGL
La lnea de cdigo: glFlush(); es la encargada de realizar la limpieza y el borradode los bferes de comando OpenGL.
Este comando hace que se ejecute cualquier comando que est esperandoa ejecutarse. Por lo general, los comandos OpenGL se aplican en la cola y se eje -cutan en secuencias de comando para optimizas el rendimiento.
La funcin glFlush();indica a OpenGL que debe proceder con las instruc-ciones de dibujo suministrada hasta el momento antes de esperar cualquier otro
comando de dibujo.
Referencias
Agenjo, J. (30 de Agosto de 2009). SegmentationFault. Recuperado el 25 de
Agosto de 2011, de OpenGL y GLUT en Visual C++: http://www.segmentationfault.
es/2009/08/opengl-glut-visual-cpp/Samaniego Gonzlez, E. Computacin Grca: Manejo de Grcos con OpenGL.
Panam.
Taller N 1
Indicaciones:
Para inicializar el sistema, crear la ventana de dibujo y comenzar el bucle de gestin
de eventos se debe utilizar cdigo que se muestra a continuacin.
Int main(int numParametros; char **ListaParametros){
/*Inicializacion y creacin de venta *///Inicializa toolkitglutInit(&numParametros, ListaParametros);//Selecciona el modo pantallaglutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
33/185
19
Captulo 1 - Introduccin a Visual C++ 2010 con OpenGL
//Selecciona el tamao de la ventanaglutInitWindowSize(anchoVentana, altoVentana);//Posiciona la ventana en la pantallaglutInitWindowPosition(posicionVentanax, posicionVentanay);//Abre la ventana
glutCreateWindow(ListaParametros[0]);glutDisplayFunc(dibuja);//Registra la funcin de redibuja//Bucle a la espera de eventos.
glutMainLoop(); }
La funcin Dibujarealiza el dibujo de la escena.
Taller N 2
Ahora se presenta un programa que genera una ventana de trabajo y dibuje primi-tivas bsicas sobre la misma. Este cdigo trata acerca de la creacin de una ven-tana usando la librera GLUT y Visual C++. Escriba el siguiente cdigo y ejecute el
programa:
#include
#include
#include
Void Mostrar(void){
//Limpia la pantalla. Borra los pixelesglClear(GL_COLOR_BUFFER_BIT);glColor3f(1.0, 1.0, 1.0); //Establece el color a dibujarglBegin(GL_POLYGON); //VrticesglVertex3f(0.25, 0.25, 0.0);glVerter3f(0.75, 0.25, 0.0);glVerter3f(0.75, 0.75, 0.0);glVerter3f(0.25, 0.75, 0.0);
glEnd();}
Void iniciar(void) //Mi inicio{
//Selecciona el color de limpieza del fondo de la ventanaglClearColor(0.0, 0.0, 0.0, 0.0);
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
34/185
20
Captulo 1 - Introduccin a Visual C++ 2010 con OpenGL
//Inicializacin de los valores de visualizacin.glMatrizMode(GL_PROJECTION);glLoadIdentify();glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 10.0);}
Int main(int argc, char **argv){
glutInit(&argc, argv);//Inicializa toolkit//Selecciona el modo pantallaglutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);glutInitWindowSize(500, 500);//Selecciona el tamao de la ventana.//Proporciona la ventana en la pantalla.
glutInitWindowPosition(100, 100);//Abre la ventanaglutInitCreateWindow(Ejemplo Guia Crear Ventana);iniciar();glutDisplayFunc(Mostrar); //Registra la funcin de redibujar.glutMainLoop(); //Bucle a la espera de eventos.return 0;}
Taller N 3
Aplicacin de los comandos bsicos de OpenGL.1. Siga los pasos para iniciar un proyecto con Visual C++ y utilizando las
libreras de OpenGL y cree un proyecto denominado Prueba1.
2. Utilizando el cdigo suministrado en la seccin de reforzamiento. Re-alizar los siguientes cambios, compilar y ejecutar mediante Build 360.) rotx -= 360.; else if (rotx < -360.)
rotx += 360.; roty += y-oy; if (roty > 360.)
roty -= 360.; else if (roty < -360.)
roty += 360.; ox = x; oy = y;
glutPostRedisplay();}
void motion(int x, int y) { if (mot == PAN)
pan(x, y); else if (mot == ROT)
rotate(x,y);}
void mouse(int button, int state, int x, int y) {
if(state == GLUT_DOWN) { switch(button) { case GLUT_LEFT_BUTTON: mot = PAN; motion(ox = x, oy = y); break; case GLUT_MIDDLE_BUTTON: mot = ROT; motion(ox = x, oy = y); break; case GLUT_RIGHT_BUTTON: break; }
} else if (state == GLUT_UP) mot = 0;}
#dene stripeImageWidth 32
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
113/185
99
Captulo 5 - Trazado del Mapa de Textura
GLubyte stripeImage[4*stripeImageWidth];
void makeStripeImage(void) {int j;
for (j = 0; j < stripeImageWidth; j++) { stripeImage[4*j] = (GLubyte) ((j4) ? 255 : 0); stripeImage[4*j+2] = (GLubyte) 0; stripeImage[4*j+3] = (GLubyte) 255; }
}
void hsv_to_rgb(oat h,oat s,oat v,oat *r,oat *g,oat *b){
int i; oat f, p, q, t;
h *= 360.0; if (s==0) { *r = v; *g = v; *b = v; }
else {
if (h==360)
h = 0; h /= 60; i = oorf(h); f = h - i; p = v*(1.0-s); q = v*(1.0-(s*f)); t = v*(1.0-(s*(1.0-f))); switch (i) { case 0 : *r = v; *g = t; *b = p; break; case 1 : *r = q; *g = v; *b = p; break;
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
114/185
100
Captulo 5 - Trazado del Mapa de Textura
case 2 : *r = p; *g = v; *b = t; break; case 3 : *r = p; *g = q; *b = v; break; case 4 : *r = t; *g = p; *b = v; break;
case 5 : *r = v; *g = p; *b = q; break; }
}
}
GLubyte rainbow[4*stripeImageWidth];void makeRainbow(void) {
int j; for (j = 0; j < stripeImageWidth; j++) { oat r, g, b; hsv_to_rgb((oat)j/(stripeImageWidth-1.f), 1.0, 1.0,&r, &g, &b); rainbow[4*j] = r*255; rainbow[4*j+1] = g*255; rainbow[4*j+2] = b*255; rainbow[4*j+3] = (GLubyte) 255; }
}
/* planes for texture coordinate generation */static GLoat xequalzero[] = {1.0, 0.0, 0.0, 0.0};static GLoat slanted[] = {1.0, 1.0, 1.0, 0.0};static GLoat *currentCoeff;static GLenum currentPlane;static GLint currentGenMode;
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
115/185
101
Captulo 5 - Trazado del Mapa de Textura
void init(void) { glClearColor (0.0, 0.0, 0.0, 0.0); glEnable(GL_DEPTH_TEST); glShadeModel(GL_SMOOTH);
makeStripeImage(); makeRainbow(); glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LIN-EAR); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LIN-EAR);
glTexImage1D(GL_TEXTURE_1D, 0, 4, stripeImageWidth, 0, GL_RGBA, GL_UNSIGNED_BYTE, stripeImage); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); currentCoeff = xequalzero; currentGenMode = GL_OBJECT_LINEAR; currentPlane = GL_OBJECT_PLANE; glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, currentGenMode); glTexGenfv(GL_S, currentPlane, currentCoeff);
glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_1D);
glEnable(GL_CULL_FACE); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_AUTO_NORMAL); glEnable(GL_NORMALIZE); glFrontFace(GL_CW); glCullFace(GL_BACK); glMaterialf (GL_FRONT, GL_SHININESS, 64.0);}
void tfunc(void) { static int state; if (state = 1) { glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER,GL_LINEAR); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER,
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
116/185
102
Captulo 5 - Trazado del Mapa de Textura
GL_LINEAR); glTexImage1D(GL_TEXTURE_1D, 0, 4, stripeImageWidth, 0,GL_RGBA, GL_UNSIGNED_BYTE, rainbow); }
else {
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER,GL_LINEAR); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER,GL_LINEAR); glTexImage1D(GL_TEXTURE_1D, 0, 4, stripeImageWidth, 0,GL_RGBA, GL_UNSIGNED_BYTE, stripeImage); }
glutPostRedisplay();
}
void display(void) { static GLUquadric *q; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix(); glTranslatef(0., 0., transx); glRotatef(rotx, 1.0, 0.0, 0.0); glRotatef(45.0, 0.0, 0.0, 1.0); glutSolidTeapot(2.0);
#if 0 if (!q) q = gluNewQuadric(); gluQuadricTexture(q, GL_TRUE); gluCylinder(q, 1.0, 2.0, 3.0, 10, 10);#endif glPopMatrix(); glutSwapBuffers();}
void reshape(int w, int h) { glViewport(0, 0, (GLsizei) w, (GLsizei) h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); if (w
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
117/185
103
Captulo 5 - Trazado del Mapa de Textura
h, -3.5, 3.5, -3.5, 3.5); glMatrixMode(GL_MODELVIEW); glLoadIdentity();}
/*ARGSUSED1*/void keyboard (unsigned char key, int x, int y) { switch (key) { case e: case E: currentGenMode = GL_EYE_LINEAR; currentPlane = GL_EYE_PLANE; glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, currentGen-Mode); glTexGenfv(GL_S, currentPlane, currentCoeff);
glutPostRedisplay(); break; case o: case O: currentGenMode = GL_OBJECT_LINEAR; currentPlane = GL_OBJECT_PLANE; glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, currentGen-Mode); glTexGenfv(GL_S, currentPlane, currentCoeff); glutPostRedisplay(); break;
case s: case S: currentCoeff = slanted; glTexGenfv(GL_S, currentPlane, currentCoeff); glutPostRedisplay(); break; case x: case X: currentCoeff = xequalzero; glTexGenfv(GL_S, currentPlane, currentCoeff); glutPostRedisplay(); break; case t:
tfunc();break;
case 27: exit(0); break;
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
118/185
104
Captulo 5 - Trazado del Mapa de Textura
default: break; }
}
int main(int argc, char*argv[]) { glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize(512, 512); glutInitWindowPosition(100, 100); glutInit(&argc, argv); glutCreateWindow(argv[0]); init(); glutDisplayFunc(display); glutReshapeFunc(reshape); glutKeyboardFunc(keyboard); glutMouseFunc(mouse);
glutMotionFunc(motion); glutMainLoop(); return 0;}
Resultado del Ejemplo
Este ejemplo produce la siguiente imagen, la textura de la imagen se puede cam-biar utilizando las teclas e, o, s, x, t. Tambin se puede mover la iluminacin utili-zando el botn izquierdo del ratn y moviendo este en el sentido del eje Y.
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
119/185
105
Captulo 5 - Trazado del Mapa de Textura
Referencias
Hearn, D., & Baker, M. (2006). Grfcos por Computadora con OpenGL. Madrid:
Pearson Prentice Hall.
Microsoft. (9 de Julio de 2011). MSDN. Recuperado el 8 de Septiembre de2011, de Microsoft Developer Network: http://msdn.microsoft.com/en-us/library/
dd368641(v=vs.85).aspx
Universidad de Valencia. (s.f.). Recuperado el 5 de Septiembre de 2011, de Depar-tamento de Informatica: http://informatica.uv.es/iiguia/AIG/docs/texturas.htm
Urea, C. (2010). Universidad de Granada. Recuperado el 12 de Septiembrede 2011, de Departamento de Lenguajes y Sistemas Informaticos.: http://lsi.ugr.
es/~curena/doce/vr/pracs.10-11/04/
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
120/185
106
Captulo 5 - Trazado del Mapa de Textura
Taller N 9
Copie el siguiente cdigo:
#include
#include
#include #include
GLubyte texArray [32][32][4];
void iniciar (){
glClearColor(.5,0.2,0,0); gluOrtho2D(0,110,0,110); glFlush();
glutSwapBuffers();}
void Dibuja(){
glClear(GL_COLOR_BUFFER_BIT); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT); glTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
glTexImage2D (GL_TEXTURE_2D, 0, GL_INTENSITY, 32, 32, 1, GL_RGBA, GL_BYTE, texArray) ; glEnable (GL_TEXTURE_2D);
glBegin (GL_QUADS); glColor3f(1,0,1); glTexCoord2f (0.0, 0.0);
glVertex2f (100,100);glColor3f(0,1,0);
glTexCoord2f (1.0, 0.0);
glVertex2f (100,10);glColor3f(0,0,1);
glTexCoord2f (1.0, 1.0);glVertex2f (10,10);
glColor3f(1,1,0); glTexCoord2f (0.0, 1.0);
glVertex2f (10,100);
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
121/185
107
Captulo 5 - Trazado del Mapa de Textura
glEnd ( ); glDisable (GL_TEXTURE_2D);
glFlush();glutSwapBuffers();
}
void almacenarDatosTex (){
int x, y, z; for (z = 0; z < 4; z++){ for (x = 0; x < 32 ; x ++){ for ( y = 0 ; y < 32 ; y++){ if( (x + y + z) % 2 == 0) texArray[x][y][z] = 55; else
texArray[x][y][z] = 100; } }
}
}
int main( int argc, char *argv[]){
almacenarDatosTex();glutInit( &argc, argv);glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowPosition(0,0);glutInitWindowSize( 500, 500);glutCreateWindow(Detalles de Texturas);iniciar();glutDisplayFunc( Dibuja);glutMainLoop();return 0;}
En el fragmento de cdigo:
glTexImage2D(GL_TEXTURE_2D, 0, GL_INTENSITY, 32, 32, 1, GL_RGBA, GL_BYTE,
texArray); cambie el valor del elemento GL_INTENSITYpor: 3, 4, GL_RGBA, GL_LU-MINACE4, GL_RGB12.
Anote sus observaciones
En el fragmento de cdigo:
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
122/185
108
Captulo 5 - Trazado del Mapa de Textura
glTexImage2D(GL_TEXTURE_2D, 0, GL_INTENSITY, 32, 32, 1, GL_RGBA, GL_BYTE,
texArray);cambie el valor del elemento GL_BYTE por: GL_BITMAP, GL_SHORT,
GL_UNSIGNED_SHORT. Anote sus resultados
En la funcin almacenarDatosTex
Remplace su cdigo por el siguiente:
int x, y, z;for (z = 0; z < 4; z++){ for (x = 0; x < 32 ; x ++){ for ( y = 0 ; y < 32 ; y++){ if( (x + y + z) % 2 == 0) texArray[x][y][z] = 0; if( (x + y + z) % 3 == 0) texArray[x][y][z] = 25; if( (x + y + z) % 4 == 0)
texArray[x][y][z] = 50; if( (x + y + z) % 5 == 0) texArray[x][y][z] = 75; else
texArray[x][y][z] = 100; }
}
}
Anote sus observaciones.
Taller N 10
Copie el siguiente cdigo:
#include
#include
#include
#include
void iniciar (){
//glClearColor(1,0.2,0,0); glClearColor(0.0,1.0,0.0,1.0); gluOrtho2D(0,110,0,110); glFlush();
glutSwapBuffers();}
void Dibuja()
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
123/185
109
Captulo 5 - Trazado del Mapa de Textura
{
GLint k; GLubyte texLine [16]; // Matriz de texturas de 16 elementos./* Denir dos elementos verdes para el patrn de textura./* Cada color de textura se especica en cuatro posiciones de lamatriz.*/
for (k = 0; k
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
124/185
110
Captulo 5 - Trazado del Mapa de Textura
{
glutInit( &argc, argv); glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowPosition(0,0);glutInitWindowSize( 500, 500);
glutCreateWindow(TEXTURAS EN LINEAS); iniciar(); glutDisplayFunc( Dibuja); glutMainLoop(); return 0;}
Modique el fragmento de cdigo
glBegin (GL_LINES) ; glTexCoord1f (0.0); glVertex3f (10,10,0) ; glTexCoord1f (1.0) ; glVertex3f (100,100,0) ;
glEnd ( ) ;
Cada ejercicio inicia con este cdigo
Cambie las lneas glTexCoord1f (0.0); y glTexCoord1f (1.0) ; porglTexCoord1f (-2.0); y glTexCoord1f (1.0) ;, respectivamente
Cambie las lneas glTexCoord1f (0.0); y glTexCoord1f (1.0) ; porglTexCoord1f (1.0); y glTexCoord1f (-2.0) ;, respectivamente
Cambie las lneas glTexCoord1f (0.0); y glTexCoord1f (1.0) ; porglTexCoord1f (0.0); y glTexCoord1f (-16.0) ;, respectivamente
Cambie las lneas glTexCoord1f (0.0); y glTexCoord1f (1.0) ; porglTexCoord1f (-14.0); y glTexCoord1f (1.0);, respectivamente
Anote sus observaciones en cada caso.
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
125/185
111
Captulo 5 - Trazado del Mapa de Textura
Ejercicio N 6
1. Mencione y explique los 4 aspectos fundamentales para utilizar unatextura en OpenGL:
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
2. Nombre de la funcin que permite se ajusten los parmetros que mod-ifican y son utilizados en una textura:
_________________________________________________________________
3. Explique en qu consiste el filtrado de una textura:
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
4. Mencione las 3 funciones que OpenGL incorpora para GACT:
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
5. Explique el uso de la funcin glTexParametri:
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
126/185
C a p t u l o
112
DESCRIPCIN:En el capitulo presentamos las diferentes
primitivas de dibujos que ayudaran a mejo-rar la eciencia de nuestras aplicaciones.
Se har uso de una lista de visualizacin,es decir de un grupo de funciones OpenGL
que han sido almacenadas para su ejecucin
posterior, y que cuando se invoca una listade visualizacin las funciones que la forman
se ejecutan en el mismo orden en que fuer-on almacenadas. Y, la eliminacin de carastraserasSe presentan los comandos paradenir el efecto escalera o aliasing, las fun-ciones Glutidlefunc y Gluttimer: se hace uso
de las funciones que permiten dividir el rea
de la ventana en varas subreas con el n de
mostrar a los mismos tiempos distintos vistasy del conjunto de instrucciones para aadir
mens desplegables a una aplicacin. Se us-aran las funciones para guardar el contenido
de la ventana grca en un chero, como
mostrar la imagen que contiene en chero enuna ventana, y la denicin de vectores de
vrtices y niebla.
OBJETIVOS:
Presentar los pasosnecesarios para creare invocar una lista devisualizacin.
Definir las funcionesy comandos para laeliminacin de carastraseras.
Proporcionar lasrdenes de OpenGL
para evitar el efectoescalera o aliasing.
Mostrar los coman-dos OpenGL que per-mite la realizacin detrabajos con varias
reas de dibujo.
Describir los coman-dos de OpenGL paraguardar el contenido
de la ventana grficaen un fichero y recu-perar imgenes.
Aspectos avanzados de OpenGL
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
127/185
113
Captulo 6 -Aspectos avanzados de OpenGL
6. Aspectos Avanzados de OpenGL
6.1 Geometras de las primitivas de los dibujos ecientes
En algunas aplicaciones con OpenGL se requiere dibujar tiras de segmentos de
lneas, lazos de segmentos de lneas, tiras de tringulos, abanicos de tringulos,tiras de romboides.
Para lograrlo, se usa la funcin de OpenGL void glVertex[2 3 4] {s i d
f} [v] (TYPE coordenadas)que es la que dene los vrtices que especican la
geometra de las primitivas bsicas de OpenGL.
El cdigo que describe la geometra de las primitivas ecientes se especica
entre llamadas a las funciones, void glBegin(GLenum modo)y void glEnd(void)donde glEnum modo indica el tipo de primitivas pudiendo ser:
GL_LINE_LOOP: Lazo de segmentos de lneas
GL_LINE_STRIP: Tira de segmento de lnea GL_QUAD_STRIP: Tira de romboides
GL_TRIANGLE_FAN: Abanico de tringulos
GL_TRIANGLE_STRIP: Tira de tringulos
Se debe tener presente que los segmentos de lnea se dibujan con el ltimo
color seleccionado, el ltimo grosor seleccionado y el ltimo patrn de lneas selec-cionado. El segmento de cdigo que se presenta a continuacin indica cmo sedibuja la geometra de las primitivas ecientes:
void dibuja()
{Gloat v[8][2] ={{0.0f,0.0f},{0.1f,1.0f},{0.9f,0.2f},{1.1f,1.1f},{1.9f,0.3f}{1.8f,0.9f},{2.7f,0.0f},{2.9f,1.2f}};glPushMatrix();glTranslate(4.0,2.0,0.0);glBegin(GL_LINE_LOOP);glVertex2fv(v[0]); glVertex2fv(v[1];)glVertex2fv(v[3]); glVertex2fv(v[5];)glVertex2fv(v[7]); glVertex2fv(v[6];)glVertex2fv(v[4]); glVertex2fv(v[2];)glEnd();
glPopMatrix();
glPushMatrix();glTranslate(2.0,-2.6,0.0);glBegin(GL_QUAD_STRIP);glVertex2fv(v[0]); glVertex2fv(v[1];)glVertex2fv(v[2]); glVertex2fv(v[3];)
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
128/185
114
Captulo 6 -Aspectos avanzados de OpenGL
glVertex2fv(v[4]); glVertex2fv(v[5];)glVertex2fv(v[6]); glVertex2fv(v[7];)glEnd();glPopMatrix();}
6.2 Lista de Visualizacin
Una lista de visualizacin o display list es un conjunto de comandos que se al-macenan para ser ejecutados posteriormente. La mayora de los comandos de
OpenGL se pueden ejecutar de dos maneras:
Modo inmediato: Los comandos se ejecutan conforme se encuen-tran en el programa. Hasta ahora todos los ejemplos vistos se eje -cutan de modo inmediato.
Modo diferido: Los comandos se almacenan en una lista de visual-izacin y son ejecutados en otro punto del programa
Los modos de ejecucin no son excluyentes, es decir, en un mismo pro-grama pueden aparecen comandos que se ejecuten en modo inmediato y en modo
diferido.
Para crear una lista de visualizacin utilizamos las funciones:
gl NewList: marca el inicio del conjunto de funciones que se alma-cenan en la lista
glEndList: marca el final del conjunto de funciones que se alma-cenan en la lista.
En la funcin, void glNewList (GLuint lista, GLenum modo), la lista es unentero que identica a la lista, y debe ser nico, y el modo, que indica el modo de
la lista. Puede serGL_COMPILE(slo compila la lista) o GL_COMPILE_AND_EXECUTE(lacompila y la ejecuta a la vez). Y la funcin void glEndList (void), indica el nal de
la lista de visualizacin.
Ejemplo:
glNewList (1, GL_COMPILE)glColor3f (1.0, 0.0, 0.0);glBegin (GL_POLYGON)glVertex3f (50.0, 100.0, 50.0);glVertex3f (100.0, 200.0, 10.0);glVertex3f (10.0, 200.0, 50.0);glEnd ();glTranslatef (3.0, 0.0, 0.0);glEndList ();
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
129/185
115
Captulo 6 -Aspectos avanzados de OpenGL
El uso de listas de visualizacin resulta ms rpido que la ejecucin en modo
inmediato y, por lo tanto, resulta conveniente utilizarlas. Adems, facilitan el en-capsulamiento y la reutilizacin de objetos. Creando una lista y ejecutndola donde
necesitemos, estamos realizando un encapsulamiento de las instrucciones que lacomponen. La ventaja principal de realizar este encapsulamiento con una lista de
visualizacin en vez de con una funcin, es que las operaciones que incluye se
realizan al compilar la lista.
En el siguiente ejemplo dibujamos un crculo en modo inmediato y utilizando
una lista de visualizacin. El clculo de los vrtices es un proceso computacional-mente costoso debido a las funciones trigonomtricas que aparecen. La versin
con lista de visualizacin resulta mucho ms rpida al ejecutarla, puesto que los
clculos se realizan en tiempo de compilacin.
Ejemplo
// Versin en modo inmediato
dibujarCirculo (){
GLint i;GLoat coseno, seno;glBegin (GL_POLYGON);for (i=0; i
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
130/185
116
Captulo 6 -Aspectos avanzados de OpenGL
Despus de a ver creado la lista de visualizacin, podemos ejecutarla en
cualquier lugar del programa, y tantas veces como queramos. La funcin que la
ejecuta es glCallList.
En la funcin void glCallList (GLuint lista), la lista identica la lista. En
el ejemplo siguiente, aplicamos la funcin glCallList.
Ejemplo
main (){
...
// Crear la lista de visualizacindibujarCirculo ();...
// Ejecutar la lista de visualizacinglCallList (LISTA_CIRCULO);...
glCallList (LISTA_CIRCULO);...
}
El incremento en la velocidad de proceso que se produce al utilizar listas de visual-izacin, depende de la implementacin concreta de OpenGL y del hardware sobreel que est instalado. En cualquier caso, como mnimo el uso de listas de visualiza-cin es tan rpido como el modo inmediato.
Por otro lado, debemos tener en cuenta al utilizar listas de visualizacin, que algu-nos comandos son sensibles al contexto. Adems, los cambios que se produzcanen el contexto dentro de la lista, repercutirn a continuacin en los dems coman-dos, estn dentro de una lista o se ejecuten en modo inmediato.
En el siguiente ejemplo, la instruccin glTranslatef,hace que cada vez que seejecuta la lista, se acumule una traslacin en la matriz de modelo y vista y que, por
lo tanto, los objetos que se dibujen a continuacin, incluso la propia lista si se eje-cuta de nuevo, sufran esta traslacin. De igual manera, el cambio de color afecta a
todos los objetos que se ejecuten a continuacin.
Ejemplo
void creaTriangulo (){
glNewList (1, GL_COMPILE);glColor3f (1, 0, 0);
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
131/185
117
Captulo 6 -Aspectos avanzados de OpenGL
glBegin (GL_TRIANGLES);glVertex2f (0, 0);glVertex2f (1, 0);glVertex2f (0, 1);glEnd ();glTraslatef (1.5, 0, 0);glEndList ();}
Para conseguir que no se altere el contexto, debemos utilizar las funciones:
gl PushMat ri x
glPopMatrix
glPushAttrib
glPopAttrib.
Ejemplo
void crearTriangulo (){
glNewList (1, GL_COMPILE);glPushMatrix ();glPushAttrib (GL_CURRENT_BIT);glColor3f (1, 0, 0);glBegin (GL_TRIANGLES);glVertex2f (0, 0);glVertex2f (1, 0);glVertex2f (0, 1);glEnd ();glTraslatef (1.5, 0, 0);glPopAttrib ();glPopMatrix ();glEndList ();}
Debemos destacar que no todas las funciones de OpenGL pueden guard-arse en una lista de visualizacin, esto ocurre con las funciones que pasan algn
parmetro por referencia, o que devuelven un valor.
Estas funciones son:
glDeleteList
glFeedbackBuffer
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
132/185
118
Captulo 6 -Aspectos avanzados de OpenGL
glFinish
glFlush
glGenLists
glGet
glIsEnabled
glIsList
glPixelStore
glReadPixels
glRenderMode
glSelectBuffer
Si se incluye alguna de estas funciones, se ejecutar durante la creacin
(compilacin) de la lista, pero no se almacenar en la misma. Es posible crear listasjerrquicas, es decir, listas que ejecutan otras listas. Las listas jerrquicas son muy
tiles cuando estamos deniendo objetos formados por varias componentes, espe-cialmente si algunas de ellas se repiten varias veces.
En el siguiente ejemplo, empleamos una lista de visualizacin para crear una
bicicleta, suponiendo que creamos otras listas para denir el pedal, el cuadro y las
ruedas.
Ejemplo
#dene PEDAL 1#dene CUADRO 2#dene RUEDA 3#dene BICICLETA 4glNewList (PEDAL, GL_COMPILE);...
glEndList ();glNewList (CUADRO, GL_COMPILE);...
glEndList ();
glNewList (RUEDA, GL_COMPILE);...glEndList ();glNewList (BICICLETA, GL_COMPILE);glCallList (PEDAL);glCallList (CUADRO);glTranslatef (1.0, 0.0, 0.0);glCallList (RUEDA);
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
133/185
119
Captulo 6 -Aspectos avanzados de OpenGL
glTranslatef (3.0, 0.0, 0.0);glCallList (RUEDA);glEndList ()
Los identicadores de las listas de visualizacin deben ser enteros positivos
nicos, lo que implica que debemos tener un especial cuidado es no duplicar n-dices.
Cuando se manejan muchas listas de visualizacin puede ser til recurrir
a las siguientes funciones determinadas de OpenGL que proporcionan ndices de
listas de visualizacin no utilizados:
GLuint glGenLists (GLsizei rango): el rango es el nmero de n -dices que queremos obtener. Esta funcin nos proporciona tantos
ndices para listas de visualizacin no usados como indiquemoscon el parmetro rango. Devuelve el primer ndice vaco y ste
junto con los dems, que son correlativos, se marcan como ocu-pados.
GLboolean glIsList (GLuint indice): el ndice, como su palabra lodice, sera el ndice de la lista. Indica si el ndice est usado.
glDeleteLists (GLuint indice, GLsizei rango), el ndice, sera elndice inicial, rango: nmero de ndices que queremos borrar. Esta
funcin borra un conjunto de listas de visualizacin correlativas,
definidas a partir de un ndice inicial y un rango.
EjemploGLuint indiceLista;indiceLista = glGenLists (1);if (glIsList (indiceLista)){
glNewList (indiceLista, GL_COMPILE);...
glEndList();}...
glDeleteLists (indiceLista, 1);
OpenGL proporciona tambin la posibilidad de ejecutar varias listas de visu-alizacin con una nica llamada. Para ello es necesario guardar los ndices en unarray (que puede ser de cualquier tipo) y utilizar las siguientes funciones:
void glCallLists (GLsize n, GLenum tipo, const GLvoid *listas):
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
134/185
120
Captulo 6 -Aspectos avanzados de OpenGL
Donde n, sera el nmero de elementos del array de ndices de listas, el tipo, serael tipo de datos del array. Puede ser GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, GL_2_BYTES, GL_3_BYTES
o GL_4_BYTES, y las listas, son array de ndices de las listas. Esta funcin ejecuta
un conjunto de listas de visualizacin cuyos ndices se encuentran en el array listas.
void glListBase (GLuint base):
La base es el valor del offset, el cual ja un valor como offset que debe aadirse a
los ndices del array que se ejecuta con glCallLists.La ejecucin de varias listas
con glCallListsse utiliza, por ejemplo, para escribir texto.
En el siguiente ejemplo, tenemos una funcin que crea una lista de visual-izacin para cada letra del alfabeto. Una segunda funcin escribe una cadena de
caracteres utilizando llamadas alas listas de visualizacin correspondientes.
EjemploGLuint CrearFuente (){
GLuint fuente;fuente = glGenLists (26);/* Crear lista para la letra A */glNewList (fuente, GL_COMPILE);.
...
glEndList();
/* Crear lista para la letra B */glNewList (fuente+1, GL_COMPILE);...
glEndList();...
return (fuente);}void EscribirCadena (GLuint fuente, char *cadena){
if (fuente == 0 || cadena == NULL)return;/* Se pone como base el primer ndice de la fuente y le restamos
65. As,para la A (cdigo ASCII 65), se mostrar la primera lista, para laB lasegunda ... */glListBase (fuente-65);glCallLists (strlen (cadena), GL_UNSIGNED_BYTE, cadena);}main ()
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
135/185
121
Captulo 6 -Aspectos avanzados de OpenGL
{
...
GLuint fuente;fuente = CrearFuente ();EscribirCadena (fuente, OPENGL);
...
6.3 Especicacin de eliminacin de caras traseras
Dado un conjunto de objetos 3D y una especicacin de la vista, se desea conocer
las supercies de los objetos visibles desde la posicin del observador. Si los ob-jetos que utilizamos estn cerrados, no poseen agujeros, podemos evitar el coste
de dibujar las caras traseras que no son visibles por el observador
La eliminacin de caras posteriores se lleva a cabo mediante las funciones,
glEnable (GL_CULL_FACE);
glCullFace (mode);donde al parmetro mode se le asigna el valor GL_BACK.De hecho, podemos utilizaresta funcin para eliminar en su lugar las caras frontales, o podramos incluso elimi-nar tanto las caras frontales como las posteriores. Por ejemplo, si nuestra posicin
de visualizacin se encuentra dentro de un edicio, entonces lo que queremos es
ver las caras posteriores (el interior de las habitaciones). En este caso, podramosasignar al parmetro mode el valor GL_FRONTo podramos cambiar la denicin dequ cara de los polgonos es la frontal utilizando la funcinglFrontFaceque seexplica ms adelante. Entonces, si la posicin de visualizacin se desplaza al ex-terior del edicio, podemos eliminar las caras posteriores de la imagen. Asimismo,
en algunas aplicaciones, puede que slo queramos ver otras primitivas dentro dela escena, como los conjuntos de puntos y los segmentos de lneas individuales.En este caso, para eliminar todas las supercies poligonales de una escena, asig-naramos al parmetro mode la constante simblica OpenGL GL_FRONT_AND_BACK.
De manera predeterminada, el parmetro mode en la funcin glCullFacetiene el valor GL_BACK. Por tanto, si activamos la eliminacin de caras posterioresmediante la funcin glEnablesin invocar explcita-mente la funcin glCullFace, seeliminarn las caras posteriores de la escena. La rutina de eliminacin se desactivamediante,
gIDisable (GL_CULL_FACE);
La funcin de cara frontal de OpenGLAunque, de manera predeterminada, la ordenacin de los vrtices de un polgonocontrola la identicacin de las caras frontal y trasera, podemos etiquetar de for-ma independiente las supercies seleccionadas de una escena como frontales o
traseras con la funcin:
glFrontFace (vertexOrder);
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
136/185
122
Captulo 6 -Aspectos avanzados de OpenGL
Si cambiamos el argumento vertexOrder a la constante de OpenGL GL_CW,un polgono denido a continuacin con una ordenacin de sus vrtices en el sen-tido de las agujas del reloj se considera que es de can frontal. Esta caracterstica
de OpenGL se puede utilizar para intercambiar las caras de un polgono, en el quehayamos especicado sus vrtices en el orden correspondiente al sentido horario.
La constante GL_CCWetiqueta una ordenacin de los vrtices en sentido contrario alas agujas del reloj como de cara frontal, que es LA ordenacin predeterminada.
Si denimos esa cara como ABC, el sentido de giro ser como las agujas delreloj. Si seguimos la regla de la mano derecha, la cara frontal queda hacia dentro
de la pantalla. Si denimos la cara como CBA, ocurre al contrario, la cara frontal es
la que nosotros vemos.
6.4 El efecto fusin en OpenGL
OpenGL provee una serie de funciones que ayudan a evitar el efecto que se pro-duce al asignar a un pixel el color de la primitiva que se est dibujando, sin tener en
cuenta si la primitiva cumple el total o solo parte del pixel.
Para eliminar el efecto fusin, tambin conocido como (efecto escalera o
antialiasing), el proceso utilizado por OpenGL consiste en calcular la supercie depixel que verdaderamente estara cubierta por la geometra y, en modo RGBA,hacer el resto del pixel transparente.
Cabe destacar que para que esto se logre, se requiere habilitar la transpar-encia y luego iniciar los parmetros necesarios. Los comandos establecidos sonlos siguientes:
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
137/185
123
Captulo 6 -Aspectos avanzados de OpenGL
glEnable(GL_BLEND)
glBlendFunc(GLenun sfactor, GLenun dfactor);
La orden glBlendFunc, establece los factores de origen y de des -tino de la fusin de color.
El primer parmetro de la orden sfactor indica la funcin de la
fusin del color origen.
El segundo parmetro, dfactor indica la funcin de fusin del colordestino.
Adicionalmente, hay que llamar a glEnable(GL_BLEND) para activarla funcin de fusin de color.
Las configuraciones predeterminadas para la fusin son
glBlendFunc(GL_ONE, GL_ZERO).
Ahora mostraremos una lista de factores de fusin validos:
GL_ZERO
GL_ONE
GL_SRC_COLOR
GL_ONE_MINUS_SRC_COLOR
GL_DST_COLOR
GL_ONE_MINUS_DST_COLOR
GL_ONE_SRC_ALPHA
GL_ONE_MINUS_SCR_ALPHA
GL_DST_ALPHA
GL_ONE_MINUS_DST_ALPHA
GL_CONSTANT_COLOR
GL_ONE_MINUS_CONSTANT_COLOR
GL_CONSTANT_ALPHA
GL_ONE_MINUS_CONSTANT_ALPHA
GL_SRC_ALPHA_SATURATE
Es importante tener claro que en el momento que se desea aplicar los factores de
fusin de OpenGL, el primer paso a realizar es habilitarlo con la funcin glEnable,
envindole como parmetros la geometra que se desea suavizar, de esta manera:
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
138/185
124
Captulo 6 -Aspectos avanzados de OpenGL
GL_POINT_SMOOTH,
GL_LINE_SMOOTH,
GL_POLYGON_SMOOTH,
entre otras. Por ejemplo: glEnable(GL_LINE_SMOOTH).
Ahora bien, Para mejorar la calidad del efecto fusin se utiliza la siguiente
rutina que permite controlar la relacin entre calidad de la imagen y velocidad dedibujo:
Void glHint(GLenum objetivo, Glenum modo);
La funcin glHintpermite un control opcional de determinados comportami-entos de interpretacin.
El parmetro objeto indica que comportamiento est siendo controlado y
especica la calidad de la imagen de puntos, lneas y polgonos durante las opera -ciones del efecto de fusin.
Los valores posibles son:
GL_POINT_SMOOTH_HINT
GL_LINE_SMOOTH_HINT
GL_POLYGON_SMOOTH_HINT
El parmetro modo puede ser:
GL_FASTEST, Para indicar que se elige la opcin ms eficiente.
GL_NICEST, Se elige la opcin de mayor calidad.
GL_DONT_CARE, Para no indicar ninguna referencia.
6.5 Uso de GlutIdleFuncyglutTimerFunc
6.5.1 Funcin GlutIdleFunc
glutIdleFuncestablece la devolucin de llamada de espera global.
glutIdleFunc vaco (void (* func) (void));
glutIdleFuncestablece la devolucin de llamada de espera global para ser fun-
cional para que en un programa de GLUT se puedan realizar tareas de procesami-ento de fondo o una animacin continua en los eventos del sistema de ventanas no
se estn recibiendo. Si est activado, el callback idle est continuamente llamado
cuando los eventos no se estn recibiendo. La rutina callback no tiene parmetros.
La ventana y men actual no ser cambiado antes de la devolucin de llamadade inactividad. Programas con mltiples ventanas y / o mens debe establecer
explcitamente la ventana actual y / o actuales del men y no depender de su con-
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
139/185
125
Captulo 6 -Aspectos avanzados de OpenGL
guracin actual.
El monto de la computacin y la prestacin a cabo en un callback idle de-bera reducirse al mnimo para no afectar la respuesta interactiva del programa. En
general, no ms que un solo marco de la prestacin debe hacerse en un callback
idle. Pasando NULL a glutIdleFunc se desactiva la generacin de la devolucinde llamada de inactividad.
6.5.2 Funcin GlutTimerFunc
glutTimerFunc registra una devolucin de llamada de temporizador que se activaen un nmero especicado de milisegundos.
glutTimerFunc vaco (unsigned int milisegundos, void (* func) (int valor),
valor);
GlutTimerFuncregistra la funcin de devolucin de llamada del temporizador que
se activa por lo menos en milisegundos milisegundos. El parmetro valor a la dev-olucin de llamada del temporizador ser el valor del parmetro valor a glutTimer-Func.Devoluciones de llamadas de temporizador mltiples, a veces iguales o difer-entes pueden ser registradas de forma simultnea.
El nmero de milisegundos es un lmite inferior en el tiempo antes que la
devolucin de llamada se genera y se indica por unsigned int milisegundos. GLUTintenta entregar el temporizador de devolucin de llamada tan pronto como seaposible despus de la expiracin del intervalo de tiempo de la devolucin de lla-mada.
No hay soporte para cancelar una devolucin de llamada registrada. En sulugar, ignorar una devolucin de llamada en funcin de su valor del parmetro cuan-do se activa.
6.6 Denicin de varias reas de dibujo.
Es posible realizar tareas donde se quieran visualizar varias sub-reas del dibujo al
mismo tiempo es decir que una misma ventana pueda dividirse mostrando visual-izaciones diferentes. Como por ejemplo supongamos que hemos creado un progra-ma de diseo de modelos 3D, sera posible visualizar cada una de sus perspectivasal mismo tiempo.
El resultado de la proyeccin se ja mediante la llamada a la funcin glView-port. Y el prototipo de esta funcin es la siguiente:
void glViewport (GLint x, GLint y, GLsizei ancho, GLsizei alto)Los parmetros x e y de esta funcin especican las esquina inferior izquierda de
la vista dentro de la ventana, y los parmetros ancho y largo especican las dimen-siones en pixeles de dicha rea.
Frecuentemente cuando se llama esta funcin con dos parejas de nmeros
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
140/185
126
Captulo 6 -Aspectos avanzados de OpenGL
especicando el rea de dibujo en la ventana se produce un error, ya que en reali-dad se trata de las dimensiones en lugar de un segundo punto.
Luego de haber especicado el tipo de proyeccin, dibujada la escena, y
lgicamente denido el rea de dibujo; si lo que se desea es dividir el rea de la
ventana para visualizar varias a la vez se deben seguir los siguientes pasos supo-niendo que una misma ventana ser dividida en dos sub-reas:
Definir el rea de dibujo.
Especifica la proyeccin.
Dibuja la escena.
Define el rea de dibujo 2.
Especifica la proyeccin.
Dibuja la escena.
Esto se repite la cantidad de veces que se desea dividir el rea de la ventana.Para realizar esto se debe considerar lo siguiente:
Al trabajar con una sola rea de dibujo, la funcin glViewport sellamara dentro de la rutina de eventos de la ventana, con la finali -dad de que el rea de dibujo se pueda redimensionar si el tamao
de la ventana lo hace tambin.
Cuando se trabaja con distintas reas la funcin glViewport se lla-mara cada vez que haya una rea distinta y cada una de ellas debeordenar que se dibuje la escena que le corresponda, por lo que se
deber indicar desde la rutina para dibujar la escena.
6.7 Tratamiento de imagines en OpenGL: Guardar y recuperar imag-ines.
A lo largo de trabajar en OpenGL nos resulta necesario guardar lo que tenemos en
nuestra ventana graca en un chero o mostrar la imagen que contiene en chero
en una ventana grca. En OpenGL lo podemos hacer transriendo de la memoria
del sistema grco a la memoria principal o de la memoria principal y luego hacia
la memoria del sistema grco. Este proceso de transferir los datos realiza en dos
pasos: primero los datos se transere de la memoria del sistema grco a la me-moria principal y segundo los datos se transere de la memoria principal al archivo.
Las funciones que nos permiten realizan estas tranferencias son glReadPix-
elsy glDrawPixels.
Para transferir los datos de la memoria del sistema grco a la memoria prin-cipal se utiliza la orden en OpenGL: void glReadPixels(GLint x, GLint y,
GLsizei ancho, GLsizei alto,
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
141/185
127
Captulo 6 -Aspectos avanzados de OpenGL
GLenum format, GLenum tipo,
GLvoid*pixeles);
Con esta orden podemos denir el rea rectangular de nuestra ventana gr-ca que deseamos transferir a la memoria principal.
Parmetros
El parmetro xy el parmetro yse utilizan para definir el vrticeinferior izquierdo en coordenadas de ventana.
Los parmetros alto y ancho indican la altura y ancho del rectngu-lo de pxeles. Si se escribe en anchura y altura 1 como parmet-ros de valor, esto correspondera a un solo pxel.
El parmetro formato nos indica de que elemento est formado un
pixel. Se aceptan estos valores simblicos:
Valor Signicado
GL_COLOR_INDEX
Los ndices de color se leen de la memoria de color se-leccionado por glReadBuffer. Cada ndice se convierte en
punto jo, desplazado hacia la izquierda o derecha, de-pendiendo del valor y el signo de GL_INDEX_SHIFT, y seaade a GL_INDEX_OFFSET.Si es GL_MAP_COLOR GL_TRUE,los ndices son reemplazados por sus asignaciones en elGL_PIXEL_MAP_I_TO_I.
GL_STENCIL_INDEX
Stencil valores se leen desde el stencil buffer. Cada ndice
se convierte en punto jo, desplazado hacia la izquierda
o derecha, dependiendo del valor y el signo de GL_INDEX_SHIFT, y se aade a GL_INDEX_OFFSET. Si es GL_MAP_STEN-CIL GL_TRUE, los ndices son reemplazados por sus asig-naciones en el GL_PIXEL_MAP_S_TO_S.
GL_DEPTH_COMPONENT
Los valores de profundidad se leen en el bfer de profundi-dad. Cada componente se convierte en punto otante por
ejemplo que los mapas de profundidad mnima de valor a
0.0 y los mapas de valor mximo de 1,0. Cada componen-te se multiplica por GL_DEPTH_SCALE, sumado a GL_DEPTH_BIASy, nalmente, anclada en el rango [0,1].
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
142/185
128
Captulo 6 -Aspectos avanzados de OpenGL
GL_RED, GL_GREEN,GL_BLUE, GL_ALPHA,GL_RGB, GL_RGBA,GL_BGR_EXT, GL_BGRA_EXT, GL_LU-MINANCE, GL_LUMI-NANCE_ALPHA
Procesamiento diere dependiendo de si los ndices de
buffers de color almacenar el color o los componentes
RGBA de color. Si los ndices de color se almacenan, seleen de la memoria de color seleccionado por glRead-
Buffer. Cada ndice se convierte en punto jo, dependi-endo del valor y el signo de GL_INDEX_SHIFT, y se aadea GL_INDEX_OFFSET.Los ndices son luego reemplazadospor el rojo, verde, azul y alfa obtenida por la indexacin
de los GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B y tablas GL_PIXEL_MAP_I_TO_A. Si loscomponentes de color RGBA se almacenan en el buffer
de color, que se leen de la memoria de color seleccionadopor glReadBuffer . Cada componente de color se convi-erte a tal punto otante que los mapas de intensidad. Cada
componente se multiplica por GL_c_SCALE y se aade a
GL_c_BIAS, donde c es GL_RED, GL_GREEN, GL_BLUE yGL_ALPHA. Por ltimo, si es GL_MAP_COLOR GL_TRUE, cadacomponente de color c se sustituye por su asignacin enla tabla GL_PIXEL_MAP_c_TO_c.
El parmetro tipo se debe especificar de que tipo de elementosconsta cada pixel, debe ser uno de los siguientes valores.
Tipo ndice de la mscara Componente de conver-sin
GL_UNSIGNED_BYTE2 8 1 (2 8 1) cGL_BYTE 2 7 1 [(2 7 1) c -1] / 2
GL_BITMAP 1 1G L _ U N S I G N E D _SHORT
2 16 1 (2 16 1) c
GL_SHORT 2 15 1 [(2 15 1) c 1] / 2GL_UNSIGNED_INT_ 2 32 1 (2 32 1) cGL_INT 2 31 1 [(2 31 1) c 1] / 2GL_FLOAT ninguno c
Parmetro pixeles es un apuntador a los datos de pixeles en laimagen.
Funcin glDrawPixels
Es la funcin que escribe en un bloque de pxeles para el framebuffer.
Para utilizarla es con la orden void glDrawPixels (
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
143/185
129
Captulo 6 -Aspectos avanzados de OpenGL
GLsizei ancho,
GLsizei alto,
GLenum formato,
GLenum tipo,
const GLvoid pxeles * );
Parmetros
El parmetro Anchose utiliza para asignar la dimensin de la an-chura del rectngulo de pxeles que se escribir en el uso de estedispositivo.
El parmetro Alto es usado para asignar una altura al dispositivo.
El parmetro formatose usa para asignar el formato de los datos
en pxeles. Utiliza estas constantes:
Valor Signicado
GL_COLOR_INDEX
Cada pixel es un valor nico, un ndice decolor. La funcin glDrawPixels conviertecada pixel en formato de punto jo.
GL_STENCIL_INDEX
Cada pixel es un valor nico, un ndice de laplantilla.La funcin glDrawPixels convierte
en formato de punto jo.
GL_DEPTH_COMPONENT
Cada pixel es un componente de un solofondo. La funcin glDrawPixels conviertedatos de coma otante directamente a un in-terno de formato de punto otante con una
precisin sin especicar.
GL_RGBA
Cada pixel es un grupo de cuatro compo-nentes en este orden: rojo, verde, azul, alfa.
Convierte valores de punto otante directa-mente.
GL_RED
Cada pixel es un componente rojo. La fun-cin convierte este componente a lo internoen un punto otante de la misma manera que
el componente rojo de un pxel es RGBA, y
luego lo convierte en un pixel RGBA con elconjunto verde y azul, despus se lee como
un pixel RGBA.
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
144/185
130
Captulo 6 -Aspectos avanzados de OpenGL
GL_GREEN
Cada pixel es un componente verde nico.La funcin convierte este componente a lo
interno en un punto otante de la misma
manera que el componente verde de un px-
el es RGBA, y luego lo convierte en un pixelRGBA con el conjunto rojo y azul, despusse lee como un pixel RGBA.
GL_BLUE
funcin convierte este componente a lo in-terno formato de punto otante de la misma
manera que el componente azul de un pxeles RGBA, y luego lo convierte en un pixelRGBA con el conjunto rojo y verde. La fun-cin convierte este componente a lo internoen un punto otante de la misma manera que
el componente azul de un pxel es RGBA, y
luego lo convierte en un pixel RGBA con elconjunto rojo y verde, despus se lee como
un pixel RGBA.GL_ALPHA Cada pixel es un componente alfa solo.
GL_RGB
Cada pixel es un grupo de tres componentesen este orden: rojo, verde, azul. La funcin
glDrawPixels convierte cada componentea lo interno formato de punto otante de la
misma manera que los componentes rojo,
verde y azul de un pxel se RGBA.
GL_LUMINANCE Cada pixel es un componente de luminanciasolo.
GL_LUMINANCE_ALPHACada pixel es un grupo de dos componentesen este orden: luminancia, la alfa.
GL_BGR_EXT
Cada pixel es un grupo de tres componentesen este orden: azul, verde, rojo. GL_BGR_EXTproporciona un formato que coincida con
el diseo de memoria de Windows, mapasde bits independientes del dispositivo. Porlo tanto, las aplicaciones pueden utilizar los
mismos datos con llamadas a funciones deWindows y las llamadas OpenGL pixel fun-cin.
GL_BGRA_EXTCada pixel es un grupo de cuatro componen-tes en este orden: azul, verde, rojo, alfa.
El parmetro tipo se utiliza para especificar el formato de cada
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
145/185
131
Captulo 6 -Aspectos avanzados de OpenGL
pixel. Se aceptan los siguientes:
Valor SignicadoGL_UNSIGNED_BYTE Sin signo de 8 bits sin signoGL_BYTE Entero de 8 bits sin signoGL_BITMAP Bits individuales de 8 bits sin signo enterosGL_UNSIGNED_SHORT Sin signo de 16 bits sin signoGL_SHORT Entero de 16 bits sin signoGL_UNSIGNED_INT Sin signo de 32 bits sin signoGL_INT Entero de 32 bitsGL_FLOAT Un solo punto otante de precisin
Parmetro pixeleses un puntero a los datos en pixeles.
6.8 Especicacin de los vectores de vrtice en OpenGL.
Cuando se quiere dibujar primitivas geomtricas en OpenGL, es necesario llamar
a muchas funciones. Por ejemplo para dibujar un polgono de 20 bordes, necesitas
llamar por lo menos a 22 funciones: una para llamar a glBegin(), una funcin para
cada uno de los vrtices, y para terminar la funcin de glEnd(). Y si se le quiereaadir ms informacin como colores RBGA, ndices de color y normales, para
cada uno de los vrtices; esto puede duplicar o triplicar el nmero de funciones que
se necesitaran llamar, para una solo primitiva geomtrica. Y esto puede impedir labuena ejecucin del programa y tambin a afectar el rendimiento del sistema.
Pero para evitar esto OpenGL tiene vectores de vrtices que permite especi-car un grupo de vrtices relacionados en unos pocos arreglos y accediendo a losdatos de estos. Esto nos da la opcin de llamar a menos funciones.
Hay tres pasos que se utilizan en la especicacin de vectores de vrtice son:
1. Activar el vector apropiado, existen de diferentes tipos: en la sigu-iente tabla se muestra la lista de vectores que pueden ser llamadosen OpenGL.
Vector Descripcin
GL_VERTEX_ARRAY Coordenadas de vrticesGL_NORMAL_ARRAY NormalesGL_COLOR_ARRAY Colores RBGAGL_INDEX_ARRAY ndice de colorGL_FOG_COORD_ARRAY Coordenadas de nieblaGL_TEXTURE_COORD_ARRAY Coordenadas de textura
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
146/185
132
Captulo 6 -Aspectos avanzados de OpenGL
GL_EDGE_FLAG_ARRAY Banderas de aristas de Polgonos
Tabla 1: vectores que pueden ser llamados en OpenGL.
En OpenGL estos vectores son llamados con la funcin glEnableClientState(), yson desactivados con la funcin de glDisableClientState().
2. Especificando los datos parta los vectores: hay diferentes funcionespara especificar datos para un vector, una funcin para cada tipo de
vector.
Coordenadas de vrtices.
void glVertexPointer(GLint tamao, GLenum tipo, GLsizei empaqueta-miento, const GLvoid *puntero);
Colores RBGA.
void glColorPointer(GLint tamao, GLenum tipo, GLsizei empaquetamiento, constGLvoid *puntero);
ndice de color.
void glIndexPointer(GLenum tipo, GLsizei empaquetamiento, constGLvoid *puntero);
Normales.
void glNormalPointer(GLenum tipo, GLsizei empaquetamiento, constGLvoid *puntero);
Coordenadas de niebla.
void glFogCoordPointer(GLenum tipo, GLsizei empaquetamiento, const
GLvoid *puntero); Coordenadas de textura.
void glTexCoordPointer(GLint tamao, GLenum tipo, GLsizei em-paquetamiento, const GLvoid *puntero);
Banderas de aristas de Polgonos.
void glEdgeFlagPointer(GLsizei empaquetamiento, const GLvoid*puntero)
Donde: Puntero es la direccin de memoria donde residen los datos.
Tipo indica el tipo de dato en el vector (GL_SHORT, GL_INT, GL_FLOAT, GL_DOUBLE).
Tamao indica el nmero de coordenadas por vrtice que puedenser 2, 3, o 4.
-
7/26/2019 OpenGL Renderizado1 Bsico con C++
147/185
133
Captulo 6 -Aspectos avanzados de OpenGL
Empaquetamiento indica el espacio, en bytes, entre coordenadassucesivas de un vrtice, si es cero, los datos se encuentran unotras otro sin ningn tipo espacio adicional entre ellos.
Ejemplo
Fragmento de cdigo para habilitar vectores de vrtices.
static GLint vertices[] = {25, 25,100, 325,
175, 25,
175, 325,
250, 25,
325, 325};
static GLoat colors[] = {1.0, 0.2, 0.2,
0.2, 0.2, 1.0,0.8, 1