P. 1
tema2

tema2

|Views: 2|Likes:
Publicado porRoldan Quispe Ayqui

More info:

Published by: Roldan Quispe Ayqui on Apr 23, 2013
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

12/18/2013

pdf

text

original

Sections

  • 2.1. Introducción
  • 2.3. ¿Qué es OpenGL?
  • 2.3.1. Características de OpenGL
  • 2.4. Aplicaciones
  • 2.5. Librerías relacionadas con OpenGL
  • 2.5.1 GLUT (OpenGL Utility Toolkit)
  • 2.5.1.1. Características
  • 2.5.1.2. Funciones de GLUT
  • 2.5.2 Librería AUX
  • 2.5.2.1. Características
  • 2.5.2.2. Funciones
  • 2.6. Programación con OpenGL para Windows. WIGGLE
  • 2.6.1. Función WinMain
  • 2.6.2. Función WndProc
  • 2.6.3. Dibujar en una ventana de Windows
  • 2.7. Usar OPENGL
  • 2.7.1. Dibujar en 3D
  • 2.7.1.1. Dibujar Objetos
  • 2.7.2. Transformación de Coordenadas
  • 2.7.3. Color y Sombras
  • 2.7.4. Luces y Lámparas
  • 2.7.5. Gráficos Planos en Opengl
  • 2.7.5.1. Mapas de bits
  • 2.7.5.2. Mapas de píxeles
  • 2.7.6. Texturas
  • 2.8. Conclusiones
  • 2.9. Bibliografía

5º Ingeniería Informática

Informática Gráfica

Capitulo 2:

Introducción a OpenGL

Montserrat Mateos Sánchez

Introducción OpenGL
2.1. INTRODUCCIÓN ...................................................................................................................... 3 2.2 RESEÑA HISTÓRICA ............................................................................................................... 4 2.3. ¿QUÉ ES OPENGL? .................................................................................................................. 5 2.3.1. CARACTERÍSTICAS DE OPEN GL .............................................................................................. 5 2.4. APLICACIONES ........................................................................................................................ 8 2.5. LIBRERÍAS RELACIONADAS CON OPENGL ................................................................. 11 2.5.1 GLUT (O PENGL UTILITY TOOLKIT) ..................................................................................... 12 2.5.1.1. Características .............................................................................................................. 12 2.5.1.2. Funciones de GLUT...................................................................................................... 12 2.5.2 LIBRERÍA AUX ...................................................................................................................... 23 2.5.2.1. Características .............................................................................................................. 23 2.5.2.2. Funciones ...................................................................................................................... 24 2.6. PROGRAMACIÓN CON OPENGL PARA WINDOWS. WIGGLE ................................. 27 2.6.1. FUNCIÓN W INMAIN .............................................................................................................. 28 2.6.2. FUNCIÓN W NDPROC ............................................................................................................. 30 2.6.3. DIBUJAR EN UNA VENTANA DE WINDOWS............................................................................. 32 2.7. USAR OPENGL ........................................................................................................................ 38 2.7.1. DIBUJAR EN 3D..................................................................................................................... 38 2.7.1.1. Dibujar Objetos ............................................................................................................ 38 2.7.2. TRANSFORMACIÓN DE COORDENADAS ................................................................................. 43 2.7.3. COLOR Y SOMBRAS............................................................................................................... 46 2.7.4. LUCES Y LÁMPARAS ............................................................................................................. 48 2.7.5. GRÁFICOS P LANOS EN OPENGL ............................................................................................. 51 2.7.5.1. Mapas de bits ................................................................................................................ 51 2.7.5.2. Mapas de píxeles ........................................................................................................... 53 2.7.6. TEXTURAS............................................................................................................................. 54 2.8. CONCLUSIONES ..................................................................................................................... 54 2.9. BIBLIOGRAFÍA....................................................................................................................... 55

2

2. Introducción OpenGL
2.1. Introducción
Utilizar información gráfica se ha convertido en el mundo de la computación en un recurso habitual para la comunicación entre los ordenadores y los usuarios. Este tipo de información no solo se usa para la gestión de las aplicaciones a través de la utilización de menús y ventanas, sino que cada vez se usa más para la representación gráfica de imágenes reales. Las imágenes reales o con efectos realistas se consiguen aproximando al máximo la representación gráfica que se genera en la pantalla del ordenador a las imágenes que percibe el ser humano con la vista. Para dar realismo a las imágenes por ordenador se utilizan técnicas de sombreado, brillo, nieblas, transparencias etc.

El empleo de imágenes tridimensionales o con realismo gráfico es un recurso más, dentro de los que se dispone para el desarrollo de cualquier aplicación informática.

El uso de manera eficiente de todos estos recursos, así como, la estandarización de los procedimientos de generación de gráficos por computador, se abordaron por primera vez con las librerías de gráficos OpenGL.

El que todas las aplicaciones que presentan gráficos por computador sigan los mismos patrones, representa una importante ventaja en cuanto a la portabilidad entre sistemas diferentes. Si además esos patrones se ajustan a modelos y métodos avanzados y eficientes para la representación gráfica por ordenador, entonces se tiene la herramienta ideal.

Todo esto lo cumple la librería OpenGL, compatibilidad y versatilidad. Pocos efectos gráficos quedan fuera de las capacidades que tienen las OpenGL y cada vez más sistemas permiten la ejecución de aplicaciones basadas en OpenGL.

En éste capitulo de introducción a OpenGL, primero se explicará que es OpenGL, junto sus características más destacadas, posteriormente se explicarán de forma muy rápida algunas de las librerías relacionadas con ésta y por último y de forma rápida se mostrarán algunas de las funciones de OpenGL. 3

2.2 Reseña Histórica
OpenGL, se puede considerar como una norma industrial. Su antecesora fue GL (Graphics Library) desarrollada por Silicon Graphics, Inc. (líder mundial en gráficos y animaciones por ordenador) en 1982. Iris GL fue la primera API (Aplication Programing Interface) de programación para las

estaciones gráficas IRIS de alto rendimiento de la compañía. Estas máquinas, contaban con un hardware optimizado para la visualización de gráficos. Con éste hardware, se podía entre otras cosas, realizar transformaciones matriciales muy rápidas, además proporcionaban soporte grafico para el buffer de profundidad y otras prestaciones.

Las subrutinas de GL hacen uso directo de las tarjetas gráficas instaladas en las estaciones de trabajo; los gráficos GL normalmente se refieren a gráficos hardware, en oposición a gráficos X Windows, que se refieren a gráficos software. Cuando se realiza renderización software, la imagen gráfica es creada vía el software que está corriendo en la máquina. La imagen renderizada es entonces visualizada en una ventana llamada X. Con el renderizado por hardware, la mayor parte del trabajo de crear la imagen la hace la tarjeta gráfica.

GL incluye soporte para conseguir desde dispositivos la entrada de datos, crear y dibujar en ventanas, configuración y control del buffer y renderizado 3D básico y avanzado.

GL fue elegido por IBM como el API para soportar los adaptadores gráficos que fueron instalados en las estaciones de trabajo de la serie RS/6000, y fue usado por mas de 1500

aplicaciones incluyendo IBM Data Explorer, AVS, Grass, (www.ats.ucla.edu)

Pero, IRIS GL no era portable a otras plataformas hardware con lo que se trabajó sobre ello y apareció OpenGL.

Este nuevo lenguaje, debía ofrecer la potencia de GL y a la vez, ser más abierto para su adaptación tanto a otras plataformas hardware así como a otros sistemas operativos.

El 1 de Julio de 1992 se presentó la versión 1.0 de la especificación de OpenGL. Poco después, en la sala de exhibición de empresas se expuso la proyección de secuencias de películas 4

como Terminator 2, El juicio final y algunas aplicaciones médicas gráficas creadas con OpenGL, y esto tuvo un gran impacto.

En 1995 se aprobó la especificación final de la versión 1.1 de OpenGL. (Sweet, M. et all)

Actualmente, existe la Plataforma para Revisiones de la Arquitectura OpenGL (ARB), está formada por SGI, DEC , IBM, Intel, Microsoft, se reúne dos veces al año y es la que decide las mejoras de OpenGL. Estas reuniones o encuentros, son de carácter público y puede asistir cualquier compañía aunque solo tienen derecho a voto las anteriores.

2.3. ¿Qué es OpenGL?
OpenGL, es una interfaz software para gráficos por hardware. Es una biblioteca de trazado de gráficos de alto rendimiento, fácil de usar, intuitivo, portable, en el que el programador describe las llamadas necesarias a funciones y comandos para conseguir una escena, apariencia o efecto. Consta de 120 comandos o funciones distintos que tienen la misma sintaxis; e stas funciones, se pueden usar para especificar objetos y las operaciones necesarias para desarrollar aplicaciones gráficas interactivas 2D y 3D; Los algoritmos que utiliza Silicon Graphics. (Neider, J. et all). fueron desarrollados y optimizados por

2.3.1. Características de OpenGL OpenGL es por diseño independiente del hardware, sistema operativo o sistema de ventanas. Las funciones de OpenGL trabajan de la misma forma en cualquier plataforma, es decir, se pueden llamar a las funciones de OpenGL desde un programa escrito y obtener los mismos resultados independientemente del lugar donde el programa se este ejecutando. Esto hace que sea portable y la programación sea más fácil con OpenGL que con un API integrado en el sistema de ventanas. Para conseguir la independencia del hardware, OpenGL no incluye ninguna función para la gestión de ventanas, interactividad con el usuario ni manejo de ficheros. Cada sistema operativo tiene sus propias funciones para realizar estas tareas, por lo que, los programas creados con OpenGL deben interactuar con el sistema de ventanas de la plataforma donde o l s gráficos serán visualizados ya que los gráficos, son normalmente visualizados en una ventana. Hay varias 5

etc) sino que tiene primitivas que permiten dibujar puntos.ats. Todos los comandos de OpenGL utilizan la misma sintaxis. están diseñadas para permitir crear gráficos 2D y 3D con especial énfasis en 3D. es decir. 6 . que indican el número de parámetros del comando y el tipo de sus argumentos. glColor3f(1. mapeado de texturas. Cuando en un programa se especifica que dibuje algo. También en algunos comandos va seguido como sufijo un numero y una letra. Una display list es una lista no editable de comandos almacenados para una ejecución posterior y se puede ejecutar más de una vez.1.0. utilización de color e iluminación. e incluso el cliente y el servidor no tienen porque ejecutarse en el mismo tipo de plataforma o sistema operativo. Todos ellos usan el prefijo gl y después la palabra que forma el comando con la primera letra en mayúscula.ucla. y es el programador el que tendrá que construir objetos más complejos. también se puede utilizar para dibujar la misma forma mas de una vez si esta se repite como un elemento de un grafico. Por ejemplo.0.1. Existe un protocolo para mover por la red los comandos de OpenGL entre el servidor y el cliente. sombras.0) Éste comando es de OpenGL y permite cambiar el color activo (Color) y tendrá 3 parámetros de tipo float.. movimiento borroso. el programa o aplicación que produce los gráficos puede correr en otra maquina distinta en la que se están visualizando los gráficos. se pueden usar para redibujar el grafico cuando el usuario cambia el tamaño de la ventana. transformaciones.. moléculas. líneas y polígonos. OpenGL tiene funciones o primitivas con las que se podrá realizar modelado 3D. (www. Así por ejemplo.herramientas y librerías para el manejo de ventanas que han sido desarrolladas para trabajar con OpenGL. (www.. Pero existe la opción de poner comandos en Display Lists. De esta forma el ordenador que visualiza los gráficos no es el mismo que ejecuta el programa de gráficos.edu) Las funciones de OpenGL como ya se comentó anteriormente.org) Está diseñado para trabajar eficientemente en un entorno cliente/servidor. pájaros. lo hace inmediatamente. Con OpenGL cualquier comando es ejecutado inmediatamente. animación.linuxfocus. Para conseguir rendimiento no tiene comandos para describir modelos complejos (mapas.

algunos comandos pueden llevar la letra v al final que indica que el parámetro de la función es un puntero a un array o vector. y ese color seguirá activo hasta que se ponga otro color. Otros lenguajes de programación como Visual Basic que pueden invocar a funciones de C. Igual que ocurre con el color. también se podrá almacenar el valor de estas variables de estado para posteriormente recuperarlo. también podrán hacer uso de OpenGL. 7 . OpenGL t iene sus propios tipos de datos para así hacer el código mas fácilmente portable. dependiendo del compilador y entorno habrá unas reglas para planificar el espacio de memoria de varias variables. Java. después disponer los objetos en el espacio tridimensional y seleccionar la posición deseada para ver la composición. aunque estos tipos de datos corresponden con los tipos de datos de C.Además. Pero si es importante tener en cuenta que si se utilizan los tipos de datos de C. Aunque todos los manuales y documentación de opengl vienen con C. para evitar esto se deben utilizar los tipos de Opengl. posiciones y características de luces y propiedades del material que los objetos están siendo dibujados. OpenGL tiene otra variables de estado para otros controles tales como la vista actual y transformación de proyecciones. se puede poner un color y dibujar un objeto. lo primero que se debe hacer es construir formas desde la primitivas geométricas. Las funciones que permiten hacer esto son glPushAttrib() y glPopAttrib(). OpenGL se puede considerar como una máquina de estados. C++. OpenGL ha sido diseñado para ser llamado por C. Ada. Las aplicaciones se pueden poner en varios estados que permanecen en efecto hasta que se cambian. Cada variable de estado tiene un valor por defecto y el programador podrá preguntar el valor actual de cada una de estas variables. posteriormente calcular el color para todos los objetos y por último convertir la descripción matemática de los objetos y su información de color asociada a píxeles en la pantalla (rasterización). y por tanto se podrán utilizar unos u otros indistintamente. Fortran. Algunas de estas variables de estado se pueden habilitar o deshabilitar con los comandos glEnable() o glDisable(). Además. Así que. Por ejemplo el color. Con OpenGL se debe seguir un o rden para la realización de las operaciones graficas necesarias para renderizar una imagen en la pantalla.

crear efectos visuales 3d para películas ? ? 3Space Publisher. modelado. tanto profesionales como de consumo. rendering. construcción de escenas y animaciones ? ? Inferno. Aplicaciones OpenGL es la API para gráficos 3D más utilizada para aplicaciones gráficas.4. Glbitfield Tabla 2.Todos los tipos de opengl tienen el sufijo gl y a continuación el tipo de C correspondiente. GLenum. 8 . así como para juegos y se usa para una amplia variedad de fines. para crear gráficos y animaciones 3D para la web - Aplicaciones CAD para diseño. Glsizei GLfloat. Se pueden distinguir las siguientes categorías: - Software para modelado.1: Tipos de OpenGL Definición como tipo C Representación interna Char con signo Short Long Float Double Unsigned char Unsigned short Unsigned long Entero de 8 bits Entero de 16 bits Entero de 32 bits Coma flotante de 32 bits Coma flotante de 64 bits Entero de 8 bits sin signo Entero de 16 bits sin signo Entero de 32 bits sin signo (Huescar M. rendering y efectos animados. La siguiente tabla nos lo muestra: Tipo de dato en OpenGL Glbyte Glshort GLint. GLclampf Gldouble. GLclampd GLubyte. ingeniería y arquitectura: ? ? SoftCAD ? ? Kinetix ? ? Actify - Herramientas y librerias para el desarrollo de aplicaciones y juegos. et all) 2. GLboolean Glushort GLuint. Algunas aplicaciones podrían ser: ? ? Carrara.

Simulador y generador de imágenes - Aplicaciones científicas.? ? 3D Charting Toolkit ? ? 3D MasterSuite ? ? AllegroGL ? ? 3D game engine scene composer & player ? ? Surrender - Juegos ? ? Azteroids ? ? Diablo II ? ? Quake II ? ? Star Trek Voyager – Elite Force ? ? Ultimate Golf - Realidad virtual ? ? VRWave ? ? V-Realm Builder ? ? Envision - Salvapantallas ? ? Physical Toy screen saber ? ? Screensaver fighter game - Aplicaciones de simulación y visualización ? ? Amira.opengl. médicas y de análisis de datos ? ? Momol. modelado molecular ? ? Functor. visualización de datos de laboratorio ? ? SimFUSION . análisis gráficos de funciones algebraicas ? ? MapRender3D ? ? Solar System Simulation (www. visualización 3D para medicina ? ? HiQ.org) 9 .

2: Figuras geométicas Figura 2.Algunos ejemplos sencillos de escenas que se pueden hacer con OpenGL podrían ser los siguientes: Figura 2.1: Animación 10 .

8: Texturas 2.5: Perspectiva Figura 2. gl.dll. Funciones que definen OPENGL (es la propia librería. La librería glu32. y su cabecera glu.5. Esta librería contiene funciones útiles que hacen el trabajo diario más sencillo.dll. glaux. 11 .7: Sombras Figura 2.lib. Esta escrita usando funciones y comandos de opengl. como el dibujo de esferas. cilindros. Librerías relacionadas con OpenGL Hay que destacar que la API de OpenGL está divida en tres librerías distintas: AUX.h. opengl32.h) .6: Perspectiva Figura 2. glaux.h).Figura 2. Todas las funciones comienzan con el sufijo aux . (denominada también librería de recursos. Es una librería que proporciona una estructura de trabajo independiente de la plataforma para invocar a las funciones de opengl. discos.

y otras. 2. buffers.5.5.5. y por tanto. permitirá e scribir programas OpenGL independientes del sistema de ventanas. y luego el programador podrá modificar el valor de dichas variables para ajustarlas.2. entrada por teclado y menús. es decir. 2. utiliza una serie de variables de estado que duran toda la ejecución de la aplicación. las aplicaciones de OpenGl que usan GLUT se pueden portar entre plataformas sin tener que introducir muchos cambios en el código fuente. GLUT. es el sistema de ventanas nativo el encargado de abrir y trazar ventanas.1 GLUT (OpenGL Utility Toolkit) 2. Las funciones de GLUT son simples. tienen pocos parámetros y no manejan punteros excepto los punteros a cadenas de caracteres y manejadores de fuentes que se le pasan a algunas funciones.1. Características GLUT ofrece una interfaz común para múltiples plataformas para el manejo de ventanas. renderización de texto. Funciones de GLUT Las funciones de GLUT se pueden dividir o clasificar según su funcionalidad: ?? Inicialización 12 . los desarrolladores podrán usar un interface común para el sistema de ventanas independiente de la plataforma.Otro aspecto a tener en cuenta a la hora de hablar de las librerías relacionadas con OpenGL. - Al igual que OpenGL.1. Por eso OpenGL debe comunicarse con el sistema nativo a través de librerias adicionales auxiliares. es que la especificación de OpenGL se aisló de cualquier dependencia de un sistema de ventanas concreto. - Es un interfaz de programación con enlaces para ANSI C y FORTRAN que. por lo que. - Es pequeño y fácil de aprender. como por ejemplo GLX (interacción entre OpenGL y el sistema Windows).1.

0). Listado 2. glutInitWindowPosition(0. height ventana el ancho y alto respectivamente en pixeles de la glutInitDisplayMode(unsigned int mode) Indica mediante mode el modo de display.Antes de empezar a GLUT. GLUT_RGB. trabajar hay que inicializar el estado de la máquina de estados de Todas las funciones de inicialización comienzan por glutInit Dentro de este grupo de funciones tendríamos las siguientes: glutInit (int **argcp. GLUT DOUBLE GLUT_LUMINANCE…. glutInitWindowPosition(int x. glutInit(&argc. int **y) Indica mediante x e y la posición en la pantalla en píxeles de la ventana. argv). char **argv ) Modifica las variables de estado de Glut y negocia una sesión con el sistema de ventanas.. Los parámetros que se le pasan son las variables argc y argv de la función main de C respectivamente. GLUT_SINGLE.1: Inicialización con Glut el sistema de ventanas 13 . glutInitWindowsSize(int width. glutInitWindowSize(500. glutInitDisplayMode(GLUT_DOUBLE| GLUT_RGBA).500). GLUT_INDEX. El siguiente trozo de código nos muestra como inicializar la máquina de estados. int **height) Indica mediante width. este valor puede ser entre otros GLUT_RGBA.

El doble buffer se utiliza para animaciones. porque así se puede eliminar el parpadeo cuando cambia la imagen en la secuencia de animación. int y) Solicita un cambio de posición de la ventana a la posición indicada por x e y glutReshapeWindow(int width. a lgunas de ellas son las siguientes: glutSetWindow(int winId) Establece la ventana con el identificador winId como ventana actual glutGetWindow(void) Solicita el identificador de la ventana actual glutDestroyWindow(int winId) Cierra la ventana especificada por winId glutPostRedisplay(void) Solicita que la ventana sea redibujada glutPositionWindow(int x. ?? Gestión de ventanas Para abrir una ventana. o enviar la orden de abrir una ventana para la aplicación al sistema de ventanas subyacente se hace con. nos devolverá el identificador de la ventana Además de ésta función existen otras funciones para el manejo de ventanas.En este ejemplo se utiliza doble buffer. int glutCreateWindow(char **name) donde name es el nombre de la ventana. el nuevo tamaño vendrá dado por width y height glutFullScreen() 14 . int height) Solicita un cambio en el tamaño de la ventana.

15 . Minimizada.Solicita que la ventana actual sea cambia a tamaño completo glutShowWindows(void) Solicita que la ventana sea mostrada glutHideWindows(void) Solicita que la ventana se oculte glutIconifyWindow(void) Solicita que la ventana se minimice glutSetWindowTitle(char *name) Pone la barra de título en la ventana. glutSetIconTitle(char *name) Pone el título en la ventana.

El listado 2.25. } Listado 2. glutMainLoop(). return 0.0f.5f).h> void pintar(void) { glClearColor(1.0).0f. 0. glVertex2f(0.25).25.0f. 1.0f. glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA). glEnd().25. glClear(GL_COLOR_BUFFER_BIT). argv). glVertex2f(-0. glColor3f(0. 0. glPointSize(50). glBegin(GL_POINTS). glVertex2f(0. 1.0f).25.0f. 0.500).0f.0f. char **argv) { glutInit(&argc. glutInitWindowSize(500. 1.0. glColor3f(0.1 nos muestra como crear una ventana y como crear un dibujo en ella.5f. glColor3f(0. #include <GL/glut. int main(int argc. glutInitWindowPosition(0. 0.-0.0f).25).2: Creación y dibujado de ventanas 16 .0f.-0. glutCreateWindow("Mi primera ventana"). 1. 0. glColor3f(1.5f.25).0f. 0. glVertex2f(-0.0.0f). glutDisplayFunc(pintar). }.0f). 1. glFlush().25).

9: Ventana creada con Glut. y esta función es global para todas las ventanas de la aplicación. - Para crear una subventana. a la hora de implementar esta función tendrá que estar implementado el refresco para todas las ventanas. el identificador es un entero devuelto por la función glutCreateWindow - Solo puede haber una función callback idle() en una aplicación. por lo tanto. Figura 2. 17 . ?? Usar subventanas A la hora de crear subventanas tenemos que tener en cuenta los siguientes aspectos: - Cuando se crea una ventana. hay que guardar el identificador de la ventana.La ejecución de éste pequeño programa nos mostrará una ventana como la siguiente. hay que proporcionar el identificador de la ventana superior y las coordenadas para la subventana y el ancho y el alto para la subventana.

es decir. como parámetro se le pasa la función que llamara cuando se cambie de tamaño y el nuevo tamaño. int height) ?? Procesado de Eventos GLUT esta dirigido por eventos... esta función es llamada cuando no hay entradas de usuario. Después de registrar todos los eventos en el programa hay que llamar a la función de procesado de eventos que es glutMainLoop() Funciones de registro de callback: glutDisplayFunc(void * void) Registra la función de display para la ventana actual. se redimensiona. una tecla del teclado que se ha pulsado. glutIdleFunc(void * void) Registra la función idle. una ventana que se abre. 18 . hay un bucle continuo que comienza después de la inicialización y va procesando todos los eventos. con lo que hay una perdida de rendimiento porque el driver de la tarjeta de video tiene que refrescar la memoria para cada una de las ventanas. int width. int glutCreateSubWindow(int winId. como parámetro se le pasa la función que se ejecutará cuando se produzca el evento de visualizar la ventana. int height)) Registra la función de cambio de tamaño para la ventana actual. glutReshapeFunc(void *void( int width.- Cuando Glut abre una subventana. le proporciona un contexto completo. como parámetro se le pasa la función que se ejecutará. int y. Para la creación de una subventana se utiliza la siguiente función. Los eventos pueden ser por ejemplo un botón del ratón que se pulsa. se cierra. Los eventos se registran como rutinas de registro callback . int x.

dibujar en una ventana. Otra rutina útil en animaciones es: glutSwapBuffers() Intercambia los buffers. trazar texto. ?? Trazar texto en una ventana OpenGL La librería OpenGL no tiene funciones para manejar el trazado de texto. ?? Uso de teclado En el momento de pulsar una tecla en el teclado. GLUT proporciona unas funciones que permiten dibujar un carácter en una posición especificada: GlutBitmapCharacter GlRasterPos Con el siguiente programa se puede ver gran parte de estas funciones como son crear una subventana.y del cursor. tratar el evento de pulsación de teclado o cambiar el tamaño de la ventana. mostrando en la ventana de golpe todo lo que se ha dibujado. 19 . el driver de proceso de eventos de GLUT registra un evento de teclado. La generación de callbacks de teclado se puede deshabilitar con la función glutKeyBoardFunc() y pasándole el valor NULL. por lo que cada uno tiene que hacerse su propia librería de bitmaps para cada carácter. La función asociada de callback toma como argumentos el código ASCII asociado con la tecla y la posición x. unsigned charkey. Estos eventos son manejados por las funciones callback de teclado.glutKeyboardFunc(void *void. int y) Registra la función de pulsado de teclado para la ventana actual. solo tiene unas directivas muy primitivas para el trazado de bitmaps. int x.

1.0F). glClearColor(1. 0.99F). void pintarcadena (char *s) { unsigned int i. glEnd ().0F). glLoadIdentity (). 20 .0F. glBegin (GL_POLYGON). void pintarsubventana () { glutSetWindow (IdSub). glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT).5F). glColor3f (0. 0.0F.0F).0.5F.0F).0F. glVertex2f(0. glVertex2f (0.0F. 0. 0.0F).0. 0. }.999F. 0. 1. void pintarventana(void) { glutSetWindow (IdMain). glEnd ().0F.h> int IdMain. glColor3f (0.0. 1.0F.0. 1.0F).0).0. glVertex2f(0. static char label[100].0. glutSwapBuffers (). 1. 0.5F).0.0F).0F.0F.0F).0F. static double tiempo = 0. s[i]). glVertex2f(0.0F. glVertex2f (0. glRotatef (angulo. i < strlen (s).0).#include <string. glClearColor (1.h> #include <stdio. i++) glutBitmapCharacter (GLUT_BITMAP_TIMES_ROMAN_24. 0.0F. 0.5F.0F. glVertex2f (0. static double angulo = 0. 0. for (i = 0. 0.0.0F.0F).0F.1. glColor3f (0. 0.0.0F).99F).0F. 0. glVertex2f (0. glColor3f (1. 0. glPushMatrix (). glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT). }. 1.h> #include <GL/glut. int IdSub.0F. glVertex2f(0.999F.0F. 1. glBegin (GL_LINE_LOOP).0. 0. glPopMatrix (). 0. glColor3f (1.h> #include <GL/gl.

glRasterPos2f (0. 0.40F. 0.0F). 1. void teclado (unsigned char key. glMatrixMode (GL_MODELVIEW).35F). sprintf (label.glColor3f (1. int x.0F. case 'q': case 'Q': exit (0). 0. gluOrtho2D (0. 1. glutSetWindow (IdMain). info_banner = !info_banner.0F). glRasterPos2f (0.10. 1. pintarcadena ( label).0F. pintarcadena (label). glMatrixMode (GL_PROJECTION). }. glLoadIdentity (). void tamanosubventana (int w.0F. 0.33F.0F. w. }. " Subventana "). 5). }. 1. sprintf (label. int h) { glViewport (0. switch (key) { case 'i': case 'I': if (info_banner) { glutSetWindow (IdSub). h).0F. 0. break. 0.0F. glutHideWindow (). h). glutPositionWindow (5. " de OpenGL creada con GLUT "). int y) { static int info_banner = 1. gluOrtho2D (-1. 21 .0F). void tamanoventana (int w. glutShowWindow ().0F. glMatrixMode (GL_PROJECTION). glutReshapeWindow (w . h / 10). glutSwapBuffers (). -1. glLoadIdentity (). 1. glLoadIdentity ().70F). break. }. int h) { glViewport (0. } else { glutSetWindow (IdSub). w. glutSetWindow (IdSub).0F. }.

glutSetWindow (IdSub).1. glutInitWindowSize (600. glutSetWindow (IdMain). glutReshapeFunc (tamanoventana).}. glutDisplayFunc (pintarventana). 20. return 0. argv). glutMainLoop (). Listado 2. Figura 2.3: Crear ventanas y subventanas con Glut El ejemplo anterior nos daría la siguiente salida. char **argv) { glutInit (&argc. void idle (void) { angulo += 5. IdSub = glutCreateSubWindow (IdMain. glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH). 20). glutPostRedisplay (). }. IdMain = glutCreateWindow ("Ventana con subventanas").10: Ventana que contiene una subventana creada con Glut. glutInitWindowPosition (20. glutIdleFunc (idle). int main (int argc. 600). glutPostRedisplay (). tiempo += 0. 600 / 10). glutKeyboardFunc (teclado). 20. glutReshapeFunc (tamanosubventana). 22 . 600 .10. }. glutDisplayFunc (pintarsubventana).0.

int nr) glutAddSubMenu(char *s.5.org.5. es una cuestión importante a tener en cuenta cuando se realizan aplicaciones. (Kilgard. entre otras. Las funciones de la librería son iguales en todas las plataformas. también tiene funciones para operaciones especificas del sistema. M.2 Librería AUX 2. AUX. olvidándose de los detalles de la plataforma y sistema operativo. dibujar figuras 3D completas.) 23 . Las funciones de la librería son rudimentarias y permiten gestionar la creación y manipulación de ventanas. int nr) glutAttachMenu() (www.1. (Sweet. Se utiliza para probar cosas programadas en OpenGL. GLUT también dispone una serie de funciones para la creación de menús. Algunas de ellas serían: int glutCreateMenu(void (f*) (int)) mainMenu(int) subMenu(int) glutAddMenuEntry(char *s...2. Características Esta librería no forma parte de la especificación de OpenGL. por lo tanto.?? Menús Una forma más de comunicación entre el usuario y una aplicación es el uso de menús. Fue creada principalmente para facilitar el aprendizaje de OpenGL. pero no para escribir aplicaciones serias.linuxfocus. 1998). como pueden ser intercambio de buffers y apertura de imágenes.. 1996) 2. pero aparece en todas las plataformas a las que se porta opengl. por lo tanto no se debe utilizar demasiado.. las entradas de usuario. Internamente la librería AUX hace uso de la API nativa del entorno para estas funciones. M.

5.4: Crear ventanas con la librería Aux 24 .0F).350). } Listado 2. Funciones ?? Inicialización Las funciones utilizadas para la inicialización son: auxInitDisplayMode(Glbitfield mascara) Inicializa el modo de visualización en la ventana. auxInitPosition(GLint x.2. El siguiente ejemplo muestra como inicializar el sistema y la creación de una ventana. el manejo de ventanas. GLint y. 1. Es la primera función a la que hay que llamar. auxInitWindow("Mi ventana creada con la librería AUX").h> void CALLBACK nada() { }.0F.350. #include <gl\glaux. Glsizei alto) Especifica la posición en la pantalla y el tamaño de la ventana. 2. aunque la librería AUX es menos completa que GLUT. el procesado de eventos. El parámetro indicará las características de la ventana. El parámetro será el título que aparecerá en la barra de la ventana. glFlush().0F. auxMainLoop(nada). glClearColor(1.2. 1. auxInitPosition(0. void main(void) { auxInitDisplayMode(AUX_SINGLE|AUX_RGBA).Al igual que la librería GLUT tiene funciones para la inicialización. Glsizei ancho.0F. 1. ?? Gestión de ventanas Para crear e inicializar la ventana de dibujo se utiliza la función auxInitWindow auxInitWindow(Glbyte *cadenatitulo) Inicializa y muestra la ventana de generación de OpenGL.0.h> #include <gl\gl. glClear(GL_COLOR_BUFFER_BIT).

. es decir. int modo. auxWireTeapot(Gldouble tamaño) Dibuja una tetera alámbrica. auxReshapeFunc(AUXRESHAPEPROC func) Permite especificar la función que debe llamarse cuando se cambie de tamaño la ventana.?? Rellamada Estás funciones. Las principales son las siguientes: auxMainLoop(AUXMAINPROC func) Permite especificar la función que debe usarse para actualizar la ventana OpenGL. por ejemplo. cuando se pulse una tecla o un botón del ratón. son muy similares a las que tiene GLUT para el procesado de eventos. 25 . auxMouseFunc(int boton. El parámetro será la función que se llamará cuando hay que refrescar la ventana. Para declarar e implementar funciones que son llamadas por estas funciones de rellamada se debe poner delante la sentencia CALLBACK.. ?? Otras funciones Hay otras funciones útiles que se pueden utilizar como son. cuando se necesite redibujar la ventana. void (*funcion(void)) Permite especificar la función de rellamada cuando se pulse la tecla tecla que se le pasa como parámetro. auxKeyFunc(GLint tecla.. AUXMOUSEPROC func) Permite especificar la función de rellamada con la actividad de los botones del ratón. cuando se cambie de tamaño una ventana. auxIdleFuncion(AUXIDLEPROC func) Permite especificar la función de rellamada que debe llamarse cuando no hay otra actividad pendiente. son funciones que se propia librería llamará cuando se necesite. El parámetro especificar el tamaño de la tetera. auxSwapBuffers(void) Ocasiona el intercambio del buffer empleado para dibujar con el de pantalla.

0f.00). glVertex2f(30.0F. w. 75.0F). glLoadIdentity().0F. glBegin (GL_POLYGON). } void CALLBACK pintarventana(void) { glClearColor(1. auxSwapBuffers().0F. glViewport(0.auxSolidTeapot(Gldouble tamaño) Dibuja una tetera sólida.0F).0F. -100.1. glEnd (). glColor3f (1.0F).0. }. glVertex2f(30. 0. 0. 100.0f. void CALLBACK teclado (void) { exit (0).h> #include <gl\glaux.0f.0F. GLsizei h) { if(h == 0) h = 1.0F). 100.0.0f. 100.0f. if (w <= h) glOrtho (-100.0F).0f.0f. glColor3f (1. 1. 0. #include <windows. 100. 1.0f.75. 100*w/h. } void CALLBACK idle (void) { pintarventana(). else glOrtho (-100.0F.30. glVertex2f(75.0F). 26 .0f. glFlush().0f).0.0f. glColor3f (0. 1.30. 0. 100. El siguiente código nos muestra como crear y dibujar en una ventana. 1. h).h> void CALLBACK tamanoventana(GLsizei w. }. -100. glVertex2f(75.0F). 0.0F).0F. glRotatef(1.0f). 0. glClear(GL_COLOR_BUFFER_BIT).0. El parámetro especificar el tamaño de la tetera.0f.0F. -100.0F.0F.0F. glColor3f (0.0f. 1.h> #include <gl\gl. 0. -100.0F.0f*h/w.0).

auxMainLoop(pintarventana). Figura 2. Para todas estas tareas se pueden utilizar algunas librerias que son independientes de la plataforma como las explicadas en el apartado anterior. auxReshapeFunc(tamanoventana). } Listado 2. teclado).300). la asociación de comandos de dibujo de OpenGL a una ventana. selección del modo de buffer.void main(void) { auxInitDisplayMode(AUX_DOUBLE|AUX_RGBA). auxInitWindow("Ventana creada con la librería AUX"). auxIdleFunc(idle). utilizar las 27 .) (Sweet.) 2. que contiene un dibujo geométrico. o bien. WIGGLE Como ya se ha dicho anteriormente.300. (Neider. auxInitPosition(50.50. M. J.6. auxKeyFunc(81. auxKeyFunc(113. teclado).5: Crear y dibujar una ventana con la librería Aux Como se puede observar en la siguiente figura la ejecución del programa produce casi la misma salida que el ejemplo creado con la librería Glut. la gestión de la pantalla.11: Ventana creada con la librería Aux. etc. OpenGL no tiene funciones para la interacción con el usuario. Programación con OpenGL para Windows.

maximizada.propias funciones que nos da el sistema. pero en un entorno Windows. int nCmdShow) Esta función es igual que la función main. es una cadena para indicar todos los parámetros de la línea de comandos que se pasan al programa. Los parámetros que se le pasan serán: hInstance. minimizada). para es el handle del programa en uso. WNDPROC lpfnWndProc. 2. además de estas seis hay otras cinco añadidas al GDI de Windows. hPrevInstance. permite especificar como se mostrara la ventana inicial (normal. y por lo tanto tener funciones para todas esas tareas. crear la ventana y gestionar o controlar la ventana con WndProc. y será dentro de la función winMain donde se le darán valores a todos los atributos de la estructura WNDCLASS. 28 . es decir. el registro de las clases de windows. como son. el lenguaje de programación anfitrión es el que tiene que asumir. Para la creación y gestión de las ventanas Windows el programador deberá realizar algunas tareas. Por lo tanto es importante ver como se trabaja en un entorno Windows. Las características de una ventana Windows se indican mediante la estructura WNDCLASS. describir la ventana WinMain. Microsoft Windows ofrece seis funciones que son añadidas a OpenGL para realizar estas tareas. Función WinMain El prototipo de ésta función es: int WINAPI WinMain (HINSTANCE hInstance. Para esto se utilizaran dos funciones WinMain y WndProc. HINSTANCE hPrevInstance.6.1. nCmdShow. Typedef struct_WNDCLASSW{ UINT style. estas funciones son las llamadas funciones wiggle. LPSTR lpszCmdLine. indica el número de veces que se activa el mismo programa lpszCmdLine.

Después de dados los valores a la estructura tenemos que registrar la ventana con la función: RegisterClass(&wc) donde wc es de tipo WNDCLASS Posteriormente se crea la ventana con la función CreateWindow: hWnd CreateWindow( LPCTSTR lpszClassName. LPVOID lpvParam ).int cbClsExtra. HANDLE hinst. 29 . cbWndExtra: estos dos valores definen la clase y las extensiones de la ventana. int nX. hInstance: permite asociar la clase ventana al programa asociada. CbClsExtra . HICON hIcon. LPCTSTR lpzWindowName. hIcon: permite especificar el icono asociado a la aplicación hCursor: permite especificar el cursor asociado a la aplicación hbrBackground: para determinar el pincel de colores que se utilizara para el fondo de la ventana de aplicación. HBRUSH hbrBackground. int cbWndExtra. ipfnWndProc: puntero a una función que está relacionada con la clase ventana. DWORD dwStyle. lpszMenuName: para indicar la clase de menú que se va a utilizar con la ventana. } WNDCLASS Los campos o atributos de esta estructura son: style: permite especificar las características de redibujado de la ventana. HCURSOR hCursor. LPCWSTR lpszMenuName. int nHeight. int nWidth. HWND hwndParent. HMENU hmenu. int nY. LpszClassName: para asignar nombre a la ventana. HISTANCE hInstance. LPCWSTR lpszClassName.

2. WPARAM wParam. se pueden controlar y gestionar los eventos que se produzcan en el programa. lpzWindowName: es el título de la ventana dwStyle: permite especificar detalles de la ventana. es donde se especifica como debe actuar el programa según el tipo de evento que se produzca. LpvParam: siempre a NULL 2. nHeight : permite especificar el tamaño de la ventana. etc. si tiene scroll. Con esta función.. WM_CREATE (cuando se crea la ventana). hwndParent: para indicar el handler de la ventana padre. WM_DESTROY (cuando se cierra la ventana). nWidth . WM_SIZE (Cuando se cambia de tamaño). maximizar. menú: para indicar el handler del menú inst : para indicar el handler de la aplicación en uso. Función WndProc El prototipo de la función es: LONG WINAPI WndProc( HWND hWnd. El siguiente código mostrará el esqueleto para crear una ventana para una aplicación: 30 .6. nY: permite especificar la posición inicial de la ventana. UINT msg. (Si se puede minimizar. LPARAM lParam).) nX . Hay muchos eventos o mensajes que se pueden controlar. como pueden ser: WM_PAINT (para dibujar la ventana).Los parámetros que se le pasan a ésta función serían los siguientes: lpszClassName: es el nombre que se utilizó en la clase anterior para registrar la clase de ventana.

RECT rect. HWND hWnd. break. HINSTANCE hInst. wc. wc. static char szTitle[]="Ventana creada con GDI de Windows". int nCmdShow) { static char szAppName[] = "W1". &ps). HINSTANCE hPrevInstance. PAINTSTRUCT ps. WNDCLASS wc. wc. wc. wc.lpfnWndProc = (WNDPROC)WndProc. IDC_ARROW). wc. &ps). LONG WINAPI WndProc (HWND hWnd.hCursor = LoadCursor(NULL.lpszMenuName = NULL.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1). PostQuitMessage (0).cbWndExtra = 0. break.h> #include <gl\gl. } return lRet. LPARAM lParam) { LONG lRet = 1. break.lpszClassName = szAppName. LPSTR lpszCmdLine. } int WINAPI WinMain (HINSTANCE hInstance.h> #define WIDTH #define HEIGHT HDC ghDC.hIcon = LoadIcon (hInstance. static HINSTANCE hInstance.#include <windows.wParam. 600 500 31 . HDC hdc. if (!RegisterClass(&wc )) return (FALSE). MSG msg. WPARAM wParam. ghDC).hInstance = hInstance. HGLRC ghRC.IDI_APPLICATION). wc. wc.style = 0. wc. if (ghDC) ReleaseDC(hWnd. wc. switch (msg){ case WM_PAINT: BeginPaint(hWnd.cbClsExtra = 0.lParam). UINT msg. EndPaint(hWnd. default: lRet=DefWindowProc(hWnd.msg. case WM_DESTROY: if (ghRC) wglDeleteContext(ghRC).

HEIGHT. ShowWindow( hWnd. nCmdShow ). NULL ). } Listado 2. tener en cuenta el concepto de Contexto de Generación. habría que tener en cuenta el concepto de Contexto de Dispositivo. o bien. WS_OVERLAPPEDWINDOW. utilizar OpenGL y entonces hay que 32 . CW_USEDEFAULT. hInstance.3. CW_USEDEFAULT. pero ahora debemos aprender a dibujar en ella. NULL. NULL. en cuyo caso.NULL.6.hWnd = CreateWindow( szAppName. Dibujar en una ventana de Windows Hasta ahora se ha visto como crear una ventana Windows.0.0)) { TranslateMessage( &msg ). if (!hWnd) return(FALSE). WIDTH. while (GetMessage(&msg. DispatchMessage( &msg ). } return( msg.5: Esqueleto de un programa para con el sistema de ventanas propio de Windows 2. UpdateWindow( hWnd ).wParam ). szTitle. Para dibujar en una ventana se puede hacer sin usar OpenGL y por lo tanto se utilizarían las funciones del GDI (Interfaz Gráfica de Dispositivos) de Windows.

que no son funciones propias de la especificación de OpenGL. pero solo uno puede ser el actual. Contexto de Generación El concepto de contexto de generación no es de OpenGL sino de la API de Windows para soportar OpenGL. sino que se añadieron para soportar todo este tipo de cosas propias de Windows. Al activar un contexto de generación. se asocia con una ventana particular. Antes de ejecutar ningún comando de OpenGL hay que indicar la ventana de generación. esta función devuelve el contexto de dispositivo para la ventana que se e l pasa como parámetro. Para poder trabajar con el contexto de generación tenemos las funciones WIGGLE. pasándole como 33 . y posteriormente crear el contexto de generación con la función HGLRC wglCreateContext(HDC hDC) anteriormente expuesta.Contexto de Dispositivo Cada ventana. Puede haber varios contextos de generación. en que ventana se va dibujar. HGLRC hrc) Activa el contexto de generación que se le pasa como parámetro hrc y lo asocia con el contexto de dispositivo especificado también como parámetro hDC Para la creación de un contexto de generación debemos crear primero un contexto de dispositivo con la función GetDc(HWND hwnd). es decir. Podemos tener múltiples contextos de dispositivo. El contexto de generación se debe borrar después que la aplicación no lo necesita BOOL wglMakeCurrent(HDC hDC. Algunas de las funciones relacionadas con el contexto de generación que más se utilizan son: HGLRC wglCreateContext(HDC hDC) Crea un contexto de generación adecuado para dibujar en el contexto de dispositivo especificado en el parámetro hDC BOOL wglDeleteContext(HGLRC hrc) Borra un contexto de generación. tiene un contexto de dispositivo que recibe la salida de gráficos. y cada función GDI toma un contexto de dispositivo como argumento para indicar a que ventana queremos que afecte la función. pero sólo uno para cada ventana.

El contexto de generación debe borrarse y normalmente se borrará cuando se cierre la ventana. PIXELFORMATDESCRIPTOR *ppfd) Selecciona el formato de píxel para un contexto de dispositivo. uno de ellos es el estilo de la ventana y el otro es el formato de Píxel. y las funciones: int ChoosePixelFormat(HDC hDC. en el que le daremos valor a los campos de esta estructura dependiendo del tipo de ventana que se quiera. color. El formato de píxel debe seleccionarse para un contexto de dispositivo antes de que este se use en un contexto de generación. HGLRC hrc). Para seleccionar el formato de píxel utilizaremos la estructura PIXELFORMATDESCRIPTOR. El formato de píxel no viene con la especificación de OpenGL. es decir. cuando se produzca el mensaje WM_DESTROY. profundidad. si no que es una extensión a la API Win32 para soportar la funcionalidad de OpenGL. Para que OpenGL pueda dibujar en una ventana. int iPixelFormat. que es el momento de creación de la ventana. 34 . Para borrarlo se hará con la función anterior BOOL wglDeleteContext(HGLRC hrc) Para poder dibujar con OpenGL en una ventana hay que tener en cuenta otros dos aspectos. Estas operaciones normalmente se harán con el evento o mensaje WM_CREATE. PIXELFORMATDESCRIPTOR *ppfd) Esta función se usa para determinar el mejor formato de píxel disponible para el contexto de dispositivo hDC basado en las características deseadas descritas en la estructura ppfd. El formato de Píxel también hay que especificarlo a la hora de dibujar en una ventana con OpenGL. BOOL SetPixelFormat(HDC hDC. En el formato de píxel se seleccionan características tales como si la ventana tiene doble buffer. etc.parámetro el contexto de dispositivo creado y por último asignar el contexto de dispositivo con el contexto de generación mediante la función BOOL wglMakeCurrent(HDC hDC. la ventana no podrá tener el estilo CS_PARENTDC y deberá crearse con los estilos WS_CHIPCHILDREN y WS_CLIPSIBLINGS.

0. -100. 0. 0. 0. glColor3f (1. 0. 0. } void IdleFunction(void) { pintarventana(). GLsizei h) { if(h == 0) h = 1.0 }. w. glColor3f (0. glLoadIdentity(). glVertex2f(75. if (w <= h) glOrtho (-100.0f. } void SetDCPixelFormat(HDC hDC) { int nPixelFormat.0f.0.0F).00). 0.0f.0. 1. 1.0. glColor3f (1. static PIXELFORMATDESCRIPTOR pfd = { sizeof(PIXELFORMATDESCRIPTOR).0f. 0.0f.30. 0. -100.0. 100*w/h.0F). 100. glEnd ().0F. 16. 0.0F.0F. PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER.0. -100. h).0.0f.0f. glBegin (GL_POLYGON).0F.0F). glColor3f (0. glRotatef(1.0f.0. 1.0.0F). -100.0F). 0. PFD_MAIN_PLANE. 100. 0. 1.Ahora que ya se ha visto como crear ventanas y como dibujar en ellas.0F. glClear(GL_COLOR_BUFFER_BIT). glVertex2f(30. 1.0F).0f. 1.75. glFlush().0F. veamos un ejemplo: void tamanoventana(GLsizei w. 0.0F.0f). glVertex2f(30.0).30.0F.0F. } void pintarventana(void) { glClearColor(1.0F). else glOrtho (-100. 100.0.0. 75. glViewport(0.0f.0. 0.0.0F). 8.0f).0. 100.0.0f*h/w. 100.0f. 0. 35 .0F. glVertex2f(75.0F.0f.1.0F. PFD_TYPE_RGBA.

lpfnWndProc = (WNDPROC) WndProc. 0.101. wglMakeCurrent(hDC. WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS. WPARAM wParam. wc. } return msg. hWnd = CreateWindow( lpszAppName. while( GetMessage(&msg. hRC = wglCreateContext(hDC). UINT message.hbrBackground = NULL. SetTimer(hWnd. 0)) { TranslateMessage(&msg). HWND hWnd.1. 300. NULL). NULL. HINSTANCE hPrevInstance. WNDCLASS wc. wc. 36 . wc. ShowWindow(hWnd.lpszClassName = lpszAppName. SetDCPixelFormat(hDC). int nCmdShow) { MSG msg.lpszMenuName = NULL. static HDC hDC. wc. wc. lpszAppName. switch (message) { case WM_CREATE: hDC = GetDC(hWnd). 0. LPSTR lpCmdLine. 300. NULL.SW_SHOW).style = CS_HREDRAW | CS_VREDRAW. wc. hRC).cbWndExtra = 0. wc. wc. UpdateWindow(hWnd). IDC_ARROW).cbClsExtra = 0.hIcon = NULL. wc. break. LPARAM lParam) { static HGLRC hRC. 0.int APIENTRY WinMain( HINSTANCE hInstance.wParam. if(hWnd == NULL) return FALSE. wc. hInstance.hInstance = hInstance. DispatchMessage(&msg).NULL). NULL. } LRESULT CALLBACK WndProc( HWND hWnd. if(RegisterClass(&wc) == 0) return FALSE.hCursor = LoadCursor(NULL.

break. ValidateRect(hWnd. } return (0L). lParam)). HIWORD(lParam)). dibujar en la ventana y el procesado de eventos o mensajes es diferente como se puede apreciar en el código. wParam. SwapBuffers(hDC). pero la forma de crear. wglMakeCurrent(hDC.NULL. 1999) 37 .. case WM_PAINT: { pintarventana(). default: return (DefWindowProc(hWnd. InvalidateRect(hWnd.NULL). case WM_TIMER: { IdleFunction().101).6: Dibujar ventanas con el sistema de ventanas propio de Windows Lo que nos muestra este pequeño programa es el mismo objeto o dibujo que nos mostraba en los ejemplos anteriores con la librería Glut y Aux. } Listado 2.case WM_DESTROY: KillTimer(hWnd.FALSE).M.NULL). if(hPalette != NULL) DeleteObject(hPalette). message. case WM_SIZE: tamanoventana(LOWORD(lParam). (Huescar. break. J. wglDeleteContext(hRC). } break. } break. PostQuitMessage(0).

Ahora y de una forma rápida.1. Dibujar Objetos Después de definir el área de visualización.7. se pueden comenzar a dibujar objetos. Se pueden definir vértices en dos y tres dimensiones. tomando como referencia coordenadas posiciónales. indica que las coordenadas deben especificarse en valores double. f (float). se expondrá como usar OpenGL. 2.7. Dibujar con OpenGL es distinto a trabajar con otras librerías o funciones. El tipo especificado de coordenadas viene determinado a partir de los sufijos que siguen a la función glvertex. Los sufijos que pueden seguir a la función serán. 2. y. Usar OPENGL Hasta este momento se ha visto para que sirve OpenGL. 38 .1. ya que posteriormente se hará más hincapié en cada uno de las cuestiones. d (double). h). en tres dimensiones h coge el valor 1. ni en coordenadas físicas si no con lo que se denomina coordenadas posiciónales en el volumen de visualización.2. Por lo que para poder trabajar con OpenGL después de crear la ventana de la aplicación. (x. Para dibujar objetos las funciones que se utilizan son las siguientes: glVertexXX() Se usa para especificar las coordenadas de un vértice. por lo tanto cuando estamos definiendo puntos en dos dimensiones el valor z coge el valor 0 y h el valor 1. con OpenGL lo que se hace es definir un volumen de visualización y para dibujar objetos las c oordenadas no se indican en pixeles. que se puede hacer con esta librería y como trabajar y preparar las ventanas dependiendo del sistema y plataforma para visualizar escenas hechas con OpenGL.7. debemos definir la ventana de visualización o volumen de visualización donde dibujaremos los objetos geométricos. dependiendo del número de coordenadas que se pasen como parámetros a la función. OpenGL trabaja normalmente en coordenadas homogéneas representadas por cuatro componentes. z. Dibujar en 3D Antes de enumerar las diferentes primitivas para la creación de objetos hay que tener en cuenta como se comporta OpenGL a la hora de dibujar.1. que aplicaciones la utilizan.

glBegin(GLenum modo) glEnd() Estas funciones se utilizan juntas. El tamaño de los puntos a dibujar se puede cambiar utilizando la función. glVertex(x. Por lo que. donde modo es el identificador del tipo a dibujar en la pantalla y glVertex es la descripción de un punto de la pantalla.z). por lo tanto las coordenadas deberán indicarse con valores que correspondan al sufijo. 39 . ?? Dibujar Puntos La primitiva para dibujar puntos es GL_POINTS. glEnd(). . glVertex(x. Este es el parámetro que llevará la función glBegin() y posteriormente se indicarán los puntos mediante la función glVertex().z)..y..i (integer) y finalmente s (short). El formato para utilizar estas funciones será el siguiente: glBegin(modo). y permiten delimitar los vértices de la primitiva pasada como parámetro. para ello deberemos utilizar el sufijo v indicando que es un vector de coordenadas. entre los comandos glBegin y glEnd hay que especificar al menos dos vértices con glVertex .. glPointSize(GLfloat tamano) ?? Dibujar Líneas Para poder dibujar una línea hay que definir dos puntos en el área de visualización.. GL_LINES. GL_POLYGON. El valor de modo indicará la primitiva a dibujar y podrá tomar distinto valores como puede ser GL_POINTS.y. Existe la posibilidad de definir un punto mediante un vector que contenga las coordenadas.

líneas e incluso formas cerradas. a rayas. También se le podría cambiar el tipo de línea o patrón. es parecido al modo anterior pero este modo conecta automáticamente el punto inicial con el punto final. Las primitivas para polígonos serían las siguientes: GL_POLYGON Genera un simple polígono relleno con los vértices especificados 40 . Las líneas se definen mediante los pares de puntos sucesivos.A la hora de dibujar líneas tenemos varias opciones dependiendo de la primitiva indicada en la función glBegin Las primitivas disponibles para dibujar líneas son las siguientes: GL_LINES Genera una serie de líneas que no se conectan entre sí. es decir el punto final de una línea es el punto inicial de la siguiente. por lo tanto el número de vértices debe ser par. ?? Dibujar Polígonos posteriormente El dibujado de polígonos es la base de composición de objetos de OpenGL. puntos.. y habría que habilitar especificar el el patronaje patrón con con la la función función glEnable(GL_LINE_STIPPLE) glLineStipple(patron). pero no superficies sólidas. en el caso de que fuera impar se ignoraría GL_LINE_STRIP Genera una serie de líneas pero que se conectan entre sí. Para ello hay un conjunto de primitivas especificas. GL_LINE_LOOP Genera una serie de líneas conectadas entre sí. Para ello. Con lo visto hasta ahora se pueden dibujar. con puntos y rayas. Con este modo se pueden generar figuras cerradas si el punto inicial coincide con el final. para que sea punteada. etc.

El primer triángulo define el vértice común a todos los triángulos. es decir dos vértices de un cuadrado se utilizan para generar el siguiente cuadrilátero. GL_TRIANGLE_STRIP Genera una serie de triángulos rellenos conectados entre sí. El n úmero de vértices debe ser múltiplo de cuatro. De igual forma que anteriormente el número de vértices debe ser múltiplo de tres.GL_TRIANGLES Genera una serie de triángulos rellenos que no se conectan entre sí. De igual forma que los anteriores el número de vértices debe ser múltiplo de 3. Los polígonos deben ser convexos. OpenGL ignora los vértices que no forma un triángulo. GL_TRIANGLE_FAN Genera un conjunto de triángulos rellenos conectados entre sí. con la característica de que todos los triángulos tiene un vértice en común. si no lo es se ignora aquellos vértices que sobran. si no se verifica entonces los vértices que sobran son ignorados. El número de vértices que se requiere es múltiplo de cuatro. Hay que tener en cuenta que si tenemos un total de N vértices podremos obtener un total de N/2-1 cuadrados. si no lo es se ignora aquellos que sobran. si el total de vértices es menor de tres. A la hora de dibujar polígonos debemos tener en cuenta dos reglas: Todos los polígonos deben ser planares. Debemos saber que con N vértices se pueden crear N-2 triángulos. GL_QUADS Genera un conjunto de cuadriláteros rellenos sin conectar entre ellos. y dos de los vértices de un triángulo son los vértices del siguiente triángulo. 41 . si no se verifica esto entonces OpenGL ignora los vértices que sobran. Cada cuatro vértices se describe un cuadrilátero. El número de vértices debe ser múltiplo de 3. GL_QUAD_STRIP Genera un conjunto de cuadriláteros rellenos que se conectan entre sí.

0. glBegin(GL_LINES).0f.0f. glVertex2f(-80.0f).1f) { x = 15.5f. GLushort pattern = 0x5555. y += 5.0.0f.0f). glRotatef(yRot. -55.0f.0.0f.0).0. angle += 0.0f.0).0. glPopMatrix(). 0. glEnable(GL_LINE_STIPPLE).0). glClear(GL_COLOR_BUFFER_BIT). -55. glFlush(). void RenderScene(void) { GLfloat y. glBegin(GL_POLYGON). 0.0f. glVertex2f(-55.El siguiente código es un ejemplo muy sencillo que muestra como utilizar estas primitivas para crear dibujos u objetos.0f.7 : Uso de primitivas para crear objetos geométricos 42 . glRotatef(xRot. glVertex2f(-80. z). 1.0f*cos(angle). -y. z += 0. y). glEnd(). glVertex2f(40.z. glEnd(). } glBegin(GL_POINTS).0f. y < 60. GLfloat x.0f. z = 10. angle <= (2.0f*GL_PI)*3. y). glVertex2f(-55.pattern). GLint factor = 1.0f. -80. } glEnd(). for(y = 20.0). glVertex3f(-x. 1. glVertex2f(80. angle. factor++. y = 15. -80. for(angle = 0. } Listado 2. 0. glPushMatrix().0f*sin(angle).0f) { glLineStipple(factor.

es decir. Cuando se mueve el sistema de coordenadas el efecto que produce es que se mueve el objeto. Transformación de Coordenadas Los dibujos o gráficos están compuestos de las formas explicadas anteriormente. rotar o cambiar de tamaño los objetos. pero.7.12: Puntos. para que todas estas formas se conviertan en una escena coherente hay que colocarlas con relación a otras formas y al observador. Ésta transformación debe ser la primera en especificarse ya que será la que cambie el sistema de coordenadas oculares.2. Figura 2. el sistema de coordenadas.El código anterior producirá la siguiente salida. 43 . se vuelve a redibujar con el nuevo sistema de coordenadas. o mejor dicho. Hay varios tipos de transformación: Transformación del observador: especifica la localización del observador o de la cámara. Esto es lo que se denomina transformación. por esta razón habrá que saber m over. lineas y polígonos 2.

GLdouble arribax. GLdouble cerca. GLdouble y. GLdouble z) glScale(GLdouble x.Perspectiva.Ortogonal. Hay dos tipos: . GLdouble ojoy. Con este tipo de perspectiva la imagen parece más real. ya que se tienen en cuenta las distancias de los objetos.- Transformación del modelado: permite manipular tanto el modelo como los objetos que contiene. GL arriba. Es decir. GLdouble centroz. void glOrtho(GLdouble izquierda. Las funciones que nos permitirán este tipo de transformación serán: glTranslate(GLdouble x. GLdouble y. Con este tipo de perspectiva los objetos se dibujan con las dimensiones especificadas. - Transformaciones de la vista: esta transformación se refiere al mapeado de la escena a coordenadas físicas de la ventana. GLdouble centroy. GLdouble z) que permitirán respectivamente trasladar. GLdouble ojoz. GLdouble arribay. - Transformación del modelador: describe la dualidad de las transformaciones de m odelado y vista. rotar o escalar un objeto. Las funciones que permiten definir estas perspectivas son. GLdouble z) glRotatef(Gldouble angulo. Entre las dos transformaciones anteriores en realidad no hay ninguna diferencia ya que da igual que se mueva el objeto hacia arriba o que se desplace el eje de coordenadas hacia abajo. GLdouble x. GLdouble lejos) 44 . GLdouble arribaz) - Transformación de la proyección: define y dimensiona el volumen de visualización. . GLdouble centrox. GLdouble y. GLdouble abajo. rotar y escalar objetos. GLdouble derecha. La función que nos permite definir este tipo de transformación es: gluLookAt(GLdouble ojos. permitirá trasladar.

GLdouble aspecto. GLdouble lejos) Esta función se utiliza para definir una proyección perspectiva. GLdouble arriba. Hay que tener en cuenta que el objeto a visualizar debe encontrarse dentro de ambos planos. por lo que se debe definir una serie de planos de corte para detallar con exactitud el volumen de visualización. Esta función es muy parecida a la función glFrustum. Los seis argumentos definen la ventana de visualización y los planos de corte tanto cercano como lejano. el objeto a visualizar tiene un aspecto mucho más realista. Los valores de pcerca y plejos representan el plano cercano y el plano lejano. es decir. gluPerpespective GLdouble zlejos) (GLdouble angulo. con estos dos valores queda totalmente definida. si sobrepasan automáticamente. Para definir la ventana de visualización es suficiente definir las coordenadas de dos esquinas de la ventana. 45 . GLdouble cerca. La función glFrustum define los dos vértices necesarios de la ventana y en la sentencia glPerpestive solamente se definirá el ángulo de apertura de la cámara y la relación entre el largo y ancho del plano cercano de corte. la diferencia entre ambas está en la forma de definir la ventana de visualización. define un paralelepípedo de tamaño infinito. estos dos planos el objeto se recortará void glFrustum(GLdouble izquierda. que en este caso al ser una proyección perspectiva definirá un tronco piramidal. Igual que en la proyección ortogonal se definen los planos de corte para limitar el volumen de vista. GLdouble abajo.Esta función se utiliza para especificar una proyección ortográfica. GLdouble zCerca. y por tanto define como volumen de visualizacion una pirámide. Este tipo de proyección define un volumen de vista rectangular. GLdouble derecha.

si por ejemplo se rota un objeto y posteriormente se traslada. Si se forma un cubo a partir del espacio anterior. 46 . ésta traslación se hace sobre la posición que tomo después de la rotación. Por esta razón los monitores se fabrican para producir estos tres tipos de luz. Todos los cambios de perspectiva que se realicen son acumulativos. poder volver a la situación anterior. se obtiene un cubo con todos los colores posibles. verde y azul. o bien. De ésta forma se podría modelar los colores disponibles como un volumen llamado espacio de color. es decir. Para ello se pueden utilizar las siguientes funciones: glMatrixMode glLoadIdentity glPushMatrix glPopMatrix 2. Color y Sombras El aspecto de las aplicaciones gráficas tiene gran influencia a la hora de evaluar y decidirse por una aplicación concreta. entonces tendríamos ocho bits para cada componente y por tanto cada componente de color se podría especificar con valores entre 0 y 255. Para especificar un color utilizamos tres valores positivos (que serían las tres componentes). Por lo que. sí un ordenador utiliza 24 bits para el almacenamiento de este tipo de información. El color en los ordenadores se genera especificando intensidades separadas de las componentes roja.3.Cada una de las transformaciones explicadas puede describirse como la multiplicación de dos o más matrices. Pero habrá ocasiones que necesitemos hacer operaciones sobre la situación anterior. Por lo que el color es muy importante a la hora de realizar este tipo de aplicaciones.7.

Dentro de Color y Sombras otra cuestión importante sería la definición y creación de paletas de colores para ajustar o elegir los colores necesarios en un momento dado para una aplicación. que sería la transición suave entre un color y el siguiente. no se produce ninguna transición. verde y azul) Modo de color indexado. normalmente con este d egradado el color es el del último vértice especificado. . El sombreado puede ser de dos tipos: . el color de la línea que se dibujará irá variando.OpenGL soporta dos modos de color: RGBA.Suave. se produce una transición suave. si al dibujar una línea especificamos en un vértice un color y en el otro vértice otro color. se elige un color especificando un índice en una matriz de colores (paleta). verde y azul. ?? Sombreado Otro aspecto importante a la hora de dibujar es lo que se denomina sombreado. todos los objetos dibujados a partir de ese m omento tendrán el mismo color hasta que se especifique otro color. Para cambiar el sombreado se hará con .Plano. se expresa un color de forma precisa con sus tres componentes (roja. es decir. GLX azul) Cuando se utiliza este comando. En la paleta se especifica el color exacto que se quiere seleccionando las intensidades de las componentes roja. void glShadeModel (Glenum modo) donde modo puede tomar los valores GL_SMOOTH (suave) o GL_FLAT (plano). 47 . ?? Selección de un Color La función de selección de un color es: void glColorXT(GLX rojo. GLX verde.

Anteriormente.4. El cuarto p arámetro corresponde al valor alpha del color que se utiliza para determinar información referente a la transparencia del color. por lo que hay que tener en cuenta este aspecto a la hora de seleccionar el color. Para modificar el color de fondo de la ventana se utiliza la siguiente función: void glClearColor (GLclampf rojo. utiliza los valores de RGB. Luces y Lámparas Los objetos en el mundo real no aparecen como un color sólido y OpenGL permite hacer una aproximación de los objetos dibujados al mundo real utilizando las funciones de iluminación. GLclampf verde. pero el color de un objeto puede variar dependiendo de la luz que incida sobre él. Cada argumento corresponde a la intensidad del color. se ha visto como darle color a los objetos. excepto que emita su propia luz. GLclampf alfa) Define el color de fondo que se aplicará. pero es suavemente reflejada por una superficie (como ejemplo puede ser un fluorescente) 48 . el rango de estos valores debe ir comprendido entre el valor 0. Verde y Azul.7. Después de definido el color de fondo hay que utilizar la función glClear para borrar la pantalla con el color que se había definido 2. GLclampf azul. está iluminado por tres tipos de luz diferentes: Luz ambiente. es la luz que no viene de ninguna dirección particular.0.?? Cambiar el Color de Fondo Cuando se habla de color es importante explicar como se puede cambiar el color de fondo de una ventana. Un objeto. esta luz viene de alguna dirección particular. Según el tipo de aplicación que se quiera crear habrá que modificar el color de fondo de la ventana. Luz difusa. Rojo.

la localización de la fuente y la dirección. A la hora de especificar fuentes de luz habrá que definir además de la intensidad y color.- Luz especular. glEnable (GL_LIGHTTING) Posteriormente. pero para darle más realidad a una escena se deben especificar varias fuentes de luz. GLenum pnombre.0f} glLightModelfv(GL_LIGHT_MODEL_AMBIENT. GLenum modo) El uso de la luz ambiente es sencillo y tiene sus aplicaciones. pero no se refleja nítidamente es una dirección particular (como ejemplo se puede decir el sol) Al igual que un color esta compuesto por tres componentes. GLfloat param) En el siguiente ejemplo se ve el efecto que produce la luz que incide sobre el cilindro dibujado. Y así será la forma de especificar la luz. 1. calcular los efectos de la luz ambiente y los efectos de difusión y reflexión. Por lo tanto par añadir luz a la escena lo primero que hay que hacer es activar la iluminación con. una fuente de luz está compuesta por tres componentes de luz también: ambiente. Para indicar la posición y el color de la luz se utiliza la misma función y se cambiará el valor de los parámetros. glfloat luzambiente[]={1. Para implementar y especificar la iluminación en los objetos hay que tener en cuentas aspectos tales como que propiedades reflectivas tienen los materiales de los objetos. 49 . hay que configurar y seleccionar el modelo de iluminación.0f.0f. 1. es direccional. cara. La función es la siguiente: glLight(GLenum luz. luzambiente) Y por último especificar o definir las propiedades de los materiales mediante las funciones. 1. glEnable(GL_COLOR_MATERIAL) glColorMaterialfv(GLenum. difusa y especular.0f.

0.GL_DIFFUSE .500. // Luz direccional glEnable(GL_LIGHTING). char* argv[]) { auxInitDisplayMode(AUX_DOUBLE|AUX_RGBA|AUX_DEPTH).0. GLsizei h) { glViewport(0.0).0.0.0.1. glLoadIdentity().0.posicion_luz).0.0}.#include <windows.h).0.h> #include <GL/gl.1. inicializar().0. glMatrixMode(GL_PROJECTION).500). } int main(int argc.mat_difuso).h> void inicializar(void) // Inicializacion de los parametros de OpenGL { GLfloat mat_difuso[] = {1.0. } void CALLBACK dibujar(void) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT).1.0. glDepthFunc(GL_LEQUAL). gluLookAt(0. GLfloat posicion_luz[] = {1.0. auxInitWindow("LUCES").8: Efecto que produce una luz difusa sobre un objeto 50 . auxSolidCylinder(1.1.0.0. } Listado 2. auxReshapeFunc(cambiartamano). glLightfv(GL_LIGHT0.0.0.0. } void CALLBACK cambiartamano(GLsizei w.0.0.0). auxInitPosition(0.0.0. glMaterialfv(GL_FRONT.1.0.1. gluPerspective(60.GL_POSITION. glEnable(GL_LIGHT0).0). glMatrixMode(GL_MODELVIEW).w.0}.0*(GLfloat)w/(GLfloat)h. auxSwapBuffers().h> #include <GL/glu.0.200. auxMainLoop(dibujar).1.0.1.. return 0.0.5.0. glEnable(GL_DEPTH_TEST).h> #include <GL/glaux. glLoadIdentity(). glFlush().

GLfloat xorig. Gráficos Planos en Opengl Hasta ahora se ha visto que se pueden y como dibujar puntos. etc. Mapas de bits Los mapas de bits son imágenes bicolor y se representan mediante arrays de dos dimensiones rellenado con ceros y unos que permitirá crear la imagen deseada.. 51 . const GLubyte *bits) Permite dibujar el mapa de bits que vendrá dado por *bits.7.5. GLfloat yorig. Figura 2. formas geométricas. pero también es importante hablar de los mapas de bits y mapas de píxeles.5. que será la matriz que contiene el mapa de bits.7.5: Luces 2. líneas. GLsizei alto. glBitmap(GLsizei ancho. 2. GLfloat ymov. GLfloat xmov. Para crear mapas de bits se utilizará la función.1.La imagen que se produce con el código anterior es la siguiente. Los mapas de bits se suelen utilizar para crear fuentes.

auxReshapeFunc(cambiotamano).0. 0xff. 1. 0.0. auxMainLoop(dibujar). glMatrixMode(GL_PROJECTION). 0xc0. glFlush(). glBitmap(10. 0xc0. } void CALLBACK dibujar(void) { int i. 0x00. 1.h> GLubyte ees[24]= { 0xff. init(). i ++) { glRasterPos2i(pos+i*50. i < 10. 0x00. float pos=0.0. 1. 0x00. 0xc0 }. 12. 0x00. glLoadIdentity(). 500). 0. w.0. pos+i*50). auxInitWindow("Mapa de bits"). 0x00. glClearColor(1. }. 0xff. 500. } 52 . auxInitPosition(0.0. 0. 0xff.Antes de dibujar la imagen con glBitmap hay que indicar la posición donde colocarlo (posición raster) con la función glRasterPos() El siguiente trozo de código nos muestra como mostrar la letra E utilizando bitmaps. void init(void) { glPixelStorei(GL_UNPACK_ALIGNMENT. for (i = 0.0. h. #include <windows. 0. pos1-i*50). 12. 0.0. 0xc0. h). } void CALLBACK cambiotamano(GLsizei w. 12. 0xc0.0. 0xff. } void main(int arg. 0x00.0. w. 12. glMatrixMode(GL_MODELVIEW).0.0. ees). 1. 0xc0. ees). -1. 0.h> #include <GL/gl. glClear(GL_COLOR_BUFFER_BIT).0. 0x00. 0xc0. glOrtho(0. 0. 0xff. 0xc0. 0x00.0. 0. 1. GLsizei h) { glViewport(0.0). 0xc0.h> #include <GL/glaux. char** argv) { auxInitDisplayMode(AUX_SINGLE|AUX_RGBA).0.0.0). glRasterPos2i(pos+i*50.0. float pos1=500. 0. 0.1). 0xc0. glColor3f(1.0). glBitmap(10.

BMP al comienzo de éste.9: Uso de bitmaps El código anterior producirá la siguiente salida.6: Bitmaps 2. que se encuentran dentro de cualquier fichero . pero la imagen tendrá mas de dos colores. Después de estas dos estructuras vendran ya los datos de la imagen.7. La función utilizada para dibujar mapas de píxeles es: glDrawPixels(GLsizei ancho. o bien. imágenes RGB de 24 bits. GLsizei alto. En OpenGL los mapas de píxeles pueden ser imágenes de 8 bits indexadas. Trabajar con estos ficheros desde programas OpenGL es muy sencillo. Mapas de píxeles Los mapas de píxeles son como los mapa de bits.5. GLenum tipo. Para ello se utilizarán las estructuras BITMAPFILEHEADER y BITMAPINFOHEADER.2. Estos se utilizan como imágenes de fondo. GLenum formato.BMP de Windows.Listado 2. const GLvoid *píxeles) A la hora de trabajar con mapas de bits y de píxeles se puede hablar de los ficheros . 53 . Figura 2.

54 . GLenum formato. GLint borde. se puede observar que es muy potente y fácil de usar. Los pasos para utilizar el mapeado de texturas son. GLsizei ancho. - Definir una imagen para textura antes de que se puedan dibujar con polígonos con textura. dos y tres dimensiones. habrá que mapear la textura. además de tener las ventajas de portabilidad y estandarización. permite cubrir los polígonos que forman el dibujo con imágenes. El mapeado de texturas se utiliza para conseguir imágenes más reales.2. hay que indicar que posición de la textura la corresponde en cada vértice. cons GLvoid *píxeles) - Después hay que habilitar el mapeado de texturas con la función. es decir. cuando se dibuja el objeto. De hecho está librería se esta utilizando en gran cantidad de aplicaciones como ya se comento anteriormente y es muy probable que se siga utilizando en muchas otras. GLint componentes. GLint nivel.6. Texturas Poner texturas en los gráficos es uno de los avances más importantes en los gráficos 3D.7. Es decir. Conclusiones Depués de ver en ésta introducción las características de OpenGL y algunas de la operaciones que se pueden realizar con ésta librería. y por tanto OpenGL es una buena elección para producir efectos visuales y escenas e imágenes realistas. glEnable(GL_TEXTURE_?D) - Por último. GLenum tipo. glTextCoord??(Type *s) 2. El mapeado de texturas es como poner papel pintado en una pared. Se pueden mapear texturas en una.8. glTextImage?d(GLenum objetivo.

Bibliografía Neider J. Anaya Multimedia Kilgard M. (1988) ¿Qué es OpenGL? ...F.org/Castellano/March1998/article28.A..org/Castellano/January1998/article17.linuxfocus.html Sepúlveda M. Silicon Graphics.linuxfocus. Akely K (1999). Release 1. (1988) Programación OpenGL: Escenas 3D. Manual de OpenGL Sepúlveda M. Segal M. Inc.edu/at/software/scivis/Scientific OpenGL to Create 2D and 3D Graphics. The OpenGL Graphcis System: A Specification (Version 1. Addison-Wesley Publising Company.html Sepúlveda M.1).A. Inc. Programación en OpenGL. (http://www.html 55 . Silicon Graphics.2..ats.htm) Visualization Software Using Huescar J. (1999/2000). Sweet M. Programing Interface. Serra J.org/Castellano/May1998/article46. (1988) Programando OpenGL: Trazado de Polígonos Simples. (1996) The OpenGL Utility Toolkit (GLUT). (1993) OpenGL Programming Guide.C.M. Richard S. http://www...org/Castellano/January1998/article15. Silicon Graphics. Inc. The Design of the OpenGL Graphcis Interface. Bennasar A.9.A. The official guide to learning OpenGL. http://www. UCLA Academic Technology Services. Segal M.linuxfocus. API Version 3. Using OpenGl to Create 2D and 3D Graphics . Wright Jr.linuxfocus. http://www.html Sepúlveda M.2. (1988) Programando OpenGL: Más sobre líneas http://www.A.ucla.. Akely K (1994). Woo M. Davis T.

You're Reading a Free Preview

Descarga
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->