OpenGL Renderizado1 Básico con C++

7/26/2019 OpenGL Renderizado1 Bsico con C++

1/185


2/185

OpenGLRenderizadoBsicoconC++


3/185


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


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


6/185

A Jos Manuel Diaz Zaid (q.e.p.d), amigo y

compaero.


7/185


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


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


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


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


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


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 -


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.


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


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.


17/185

3


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-


18/185

4


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.


19/185

5


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.


20/185

6


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.


21/185

7


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)


22/185

8


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


23/185

9


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.


24/185

10


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


25/185

11


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


26/185

12


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.


27/185

13


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


28/185

14


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.


29/185

15


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){

}


30/185

16


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.


31/185

17


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.


32/185

18


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);


33/185

19


//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);


34/185

20


//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


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;


114/185

100


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;


115/185

101


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,


116/185

102


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


117/185

103


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;


118/185

104


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.


119/185

105


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/


120/185

106


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);


121/185

107


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:


122/185

108


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()


123/185

109


{

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


124/185

110


{

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.


125/185

111


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:

_________________________________________________________________

_________________________________________________________________

_________________________________________________________________

_________________________________________________________________

_________________________________________________________________


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


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];)


128/185

114


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 ();


129/185

115


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


130/185

116


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);


131/185

117


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


132/185

118


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);


133/185

119


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):


134/185

120


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 ()


135/185

121


{

...

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);


136/185

122


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:


137/185

123


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:


138/185

124


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-


139/185

125


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


140/185

126


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,


141/185

127


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].


142/185

128


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 (


143/185

129


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.


144/185

130


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


145/185

131


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


146/185

132


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.


147/185

133


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

OpenGL Renderizado1 Básico con C++

Documents

Transcript of OpenGL Renderizado1 Básico con C++