81,9(56,'$' 1$&,21$/ '(/ $/7,3/$12

)$&8/7$' '( ,1*(1,(5,$ (67$',67,&$ ( ,1)250$7,&$

Bloodshed Dev-C++ 4.9.9.1

  

Leonel Coyla Idme

Puno, Julio del 2009

&RPSXWDFLyQ *UDILFD

2SHQ*/ Estructura de un programa en OpenGL Tipos de datos Librerias Auxiliares Instalacin de librerias Mquinad e estados Definicin de Colores Limpiar la ventana Proyeccin ortogrfica Funciones necesarias de GLUT 35,0,7,9$6 *(20e75,&$6 %,',0(16,21$/(6 Formato para la definicin de las primitivas Estilos de lneas Transformacin Traslacin Rotacin Escalado Ejemplos Uso del Teclado Uso del Mouse (ratn) 75$16)250$&,21 *(20e75,&$ 75,',0(16,21$/ Sistema de Coordenadas Coordendas homogneas Transformacin de objetos Traslacin Escalado Rotacin Primitivas de dibujo en 3D Tipos y tamaos de letra Uso de menus den OpenGL ,/80,1$&,21 Implementacin de luces Fuentes de luz Definicin de las propiedades de luz Modelo de Iluminacin Definicin de las propiedades del material Transformacin de la Vista 7(;785$ Coordendas de textura Repeticin y fijacin de textura 'HY& Proyectos Creacin de un proyecto Configuracin de Proyectos Depuracin Como instalar librerias 8VDQGR 'HY3DN GH */87 2SHQ*/ \ 'HY&

,1',&(

 3 3 4 4 5 5 5 6 6  9 11 11 11 11 12 12 38 38  42 43 43 43 43 44 45 45 64  67 67 68 68 69 70  78 80  85 85 89 89 90 

/HRQHO &R\OD ,GPH

2SHQ*/
OpenGL es una interfaz de software de hardware grfico. La interfase se realiza a travs de varios procedimientos y funciones que permite al programador generar imgenes en color de alta calidad especialmente de objetos 2D y 3D. En la actualidad, es un estndar sobre grficos por computadora y uno de los ms utilizados en el mundo. Adems es compatible con cualquier plataforma hardware y muchos lenguajes de programacin. OpenGL.- 2pen *raphics /ibrary. OpenGL es una marca registrada de Silicon Graphics, Inc. (SGI) Adems OpenGL es independiente del Sistema Operativo. OpenGL realiza las siguientes operaciones: 1. Utiliza las primitivas bsicas para modelar figuras como lneas, puntos y fotografas. 2. Muestra el color de los objetos. 3. Los objetos se muestra en un espacio 3D. 4. Realiza la descripcin matemtica de los objetos. (6758&785$ '( 81 352*5$0$ (1 2SHQ*/ OpenGL considera las siguientes partes: o Realiza la Inicializacin de los estados, que se encargan de controlar el proceso de rendering. o Definir que objetos deben visualizarse, considerando su geometra y sus propiedades externas. 2EVHUYDFLyQ o 5HQGHULQJ.- Se dice as cuando la computadora genera una imagen sinttica, con sus luces y objetos, a partir de un modelo. o 0RGHOR GH XQ 2EMHWR.- Es la descripcin matemtica del objeto. 7,326 '( '$726 68),-2 B S I F D Ub Us Ui 7,32 '( '$72 Entero 8-bits Entero 16-bits Entero 32-bits Punto flotante 32-bits Punto flotante 64-bits Entero sin signo 8-bits Entero sin signo 16-bits Entero sin signo 32-bits '(),1,&,1 (1 23(1*/ '(/ 7,32 GLbyte GLshort GLint, GLsizei GLfloat, GLclampf GLdouble, GLclampd GLubyte, GLboolean GLushort GLuint,GLenum, GLbitfield

&RPSXWDFLyQ *UDILFD

(MHPSOR glVertex2i(): Define un vrtice en 2D en entero de 32 bits. glVertex2f(): Define un vrtice en 2D en float. glVertex3i(): Define un vrtice en 3D en entero de 32 bits. glColor3i(): Es la definicin de coordenadas color en entero de 32 bits. /,%5(5,$6 $8;,/,$5(6

*/8: (OpenGL Utility Library) Es el que contiene muchas rutinas se utiliza en OpenGL y es bajo nivel, adems en ella se realiza las transformaciones de matrices. */87: Es el que contiene rutinas para las ventanas, ratn, teclado, etc. *$/8; Esta realiza la misma funcin que GLUT y se realiza solo en Windows. ,167$/$&,21 '( /,%5(5,$6 3$5$ 'HY& o 8ELFDU ORV DUFKLYRV K HQ C:\Dev-Cpp\include\GL o 8ELFDU ORV DUFKLYRV OLE HQ C:\Dev-Cpp\lib o ([WUDHU ORV DUFKLYRV GOO HQ C:\Windows\system32 En la ventana que se observa, copiar en Linker lo siguiente: -lglu32 lglu32 lopengl32

/HRQHO &R\OD ,GPH

0$48,1$ '( (67$'26 Se dice as, porque cuando se activan o configuran varios estados de la mquina, sus efectos perduran hasta que sean desactivados. Sintaxis Las funciones en OpenGL comienzan con el prefijo gl y las constantes con GL. En algunas funcione, se tiene un sufijo compuesto por dos caracteres y son una cifra y una letra, donde la cifra representa el nmero de parmetros y la letra es el tipo de estos parmetros. (MHPSOR glColor3f() glVertex3i() '(),1,&,21 '( &2/25(6 )XQFLyQ JO&RORUI  glColor3f (0.0, 0.0, 0.0); glColor3f (1.0, 0.0, 0.0); glColor3f (0.0, 1.0, 0.0); glColor3f (1.0, 1.0, 0.0); glColor3f (0.0, 0.0, 1.0); glColor3f (1.0, 0.0, 1.0); glColor3f (0.0, 1.0, 1.0); glColor3f (1.0, 1.0, 1.0); /,03,$5 /$ 9(17$1$ Se utiliza para limpiar el buffer considerando el parmetro y los posibles buffers son las siguientes: %XIIHU Color Buffer Depth Buffer Accumulate Buffer Stencil Buffer 1RPEUH GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT GL_ACCUM_BUFFER_BIT GL_STENCIL_BUFFER_BIT &RORU negro rojo verde amarillo azul magenta cian blanco

JO&OHDU*/B&2/25B%8))(5B%,7 _ */B'(37+B%8))(5B%,7 Ejemplo YRLG 'LEXMD7HWHUDYRLG ^ JO&OHDU*/B&2/25B%8))(5B%,7 _ */B'(37+B%8))(5B%,7 5

&RPSXWDFLyQ *UDILFD

JOXW:LUH7HDSRW JO)OXVK JOXW6ZDS%XIIHUV `

352<(&&,21 2572*5$),&$

JO2UWKR.- Una proyeccin ortogrfica define una perspectiva ortonormal y se dice que es cuadrada en todas sus caras, por lo tanto esto genera una proyeccin paralela y es utilizado en aplicaciones de tipo CAD. )RUPDWR glOrtho(x_minima, x_maxima, y_minima, y_maxima, z_minima, z_maxima). glOrtho(GLdouble left, GLdouble right, GLdouble bottom, Gldouble topo, GLdouble Znear, GL double Zfar);

Ejemplo: glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0); )81&,21(6 1(&(6$5,$6 '( */87

Se debe inicializar el modo de desplegado con la funcin: JOXW,QLW'LVSOD\0RGH teniendo en cuenta sus argumentos. GLUT_SINGLE : Se utiliza un buffer de memoria GLUT_DOUBLE : Permite usar dos buffers de memoria GLUT_RGB : Se usa para cambiar al modo RGB GLUT_DEPTH : Permite usar buffer de profundidad GLUT_STENCIL : Nos permite cambiar a modo stencil. Ejemplo: JOXW,QLW'LVSOD\0RGH*/87B'28%/( _ */87B5*% JOXW,QLW DUJF DUJY Inicializa la librera auxiliar GLUT

JOXW'LVSOD\)XQFGLVSOD\ Se usa para definir el callback y consiste en redibujar la ventana. Cada vez que llama para redibujar utilizar la funcin display() u otra definida por el usuario. JOXW,QLW:LQGRZ6L]H DQFKXUD DOWXUD Define el tamao de la ventana en pxeles. JOXW,QLW:LQGRZ3RVLWLRQ[ \ Inicializa la posicin de la ventana en el escritorio. 6LQWD[LV z JOXW,QLW:LQGRZ6L]HDQFKR DOWR \

/HRQHO &R\OD ,GPH

z JOXW,QLW:LQGRZ3RVLWLRQHMH [ HMH \ Ejemplo: z JOXW,QLW:LQGRZ6L]H z JOXW,QLW:LQGRZ3RVLWLRQ &5($5 /$ 9(17$1$

JOXW&UHDWH:LQGRZFKDU WLWXOR Se utiliza para crear la ventana y es definida con el tamao y posicin declarada con los comandos anteriormente, adems en ella incluye el titulo de la ventana. z JOXW&UHDWH:LQGRZ7tWXOR GHO 3URJUDPD z JOXW&UHDWH:LQGRZDUJY>@

JOXW0DLQ/RRS Esta funcin hace que el bucle de eventos se ponga en marcha. JOXW6ZDS%XIIHUV Se encarga de pegar la imagen en la ventana definida. JO)OXVKFuerza la finalizacin de los comandos OpenGL

JO(QDEOH*/B'(37+B7(67 Se utiliza para activar el test de buffer de profundidad

JO&OHDU */B&2/25B%8))(5B%,7 _ */B'(37+B%8))(5B%,7 Se encarga de redibujar la escena, mientras borra el buffer de color y el buffer de profundidad. JO&RORUI (stablece el color actual con el que se va a dibujar una figura. JO&OHDU&RORU establece el color actual, JO&OHDU es la que realmente borra la pantalla con el color antes indicado.

0pWRGRV GH VRPEUHDGR Existen tres mtodos de sombreado: JO6KDGH0RGHO*/B)/$7 para caras planas y es considerado como la ms simple e ineficiente. JO6KDGH0RGHO*/B60227+ para la cara suave presenta escenas granuladas, incluye degadados en la geometra y su calidad de presentacin se nota. JO6KDGH0RGHO*/B3+21* presenta el color muy cercano a la realidad y su calidad de presentacin es mejor a las dos anteriores, pero requiere de ms proceso porque se usa una interpolacin bilineal para obtener la normal de cada punto de un polgono.

&RPSXWDFLyQ *UDILFD

JO(QDEOH*/B/,*+7,1* Activa la fuente de luz. JO(QDEOH*/B/,*+7 JO&OHDU&RORU5 * % $ Se utiliza para borrar el color de fondo y adems define el nuevo color, considerando los siguientes parmetros: 5 5HG URMR * *UHHQ YHUGH % %OXH D]XO $ DOSKD

JO/RDG,GHQWLW\) Se usa para acumular operaciones de inicializacin a la identidad de rotacin, traslacin, escalado. 3LOD R 6WDFN En una matriz de transformacin model-view se entiende como una pila, esto significa que cuando aadimos una transformacin a la pila o la ltima, esta ser el primero que sale de la pila, toda esta operacin se realiza mediante las siguientes funciones: o JO3XVK0DWUL[ Permite guardar la matriz DFWXDO en la pila.

o JO3RS0DWUL[ &oge la matriz que se encuentre en el WRS de la pila y la asigna a la matriz DFWXDO. Para activar una matriz de transformacin lo realizamos de la siguiente forma: glMatrixMode(GL_MODELVIEW); JOXW3RVW5HGLVSOD\. Esta funcin se encarga de redibujar la ventana actual. 3URSLHGDGHV HVFDODUHV */B6327B(;321(17. Define la focalizacin de la luz. */B6327B&872)) Define el angulo de apertura de la luz y acepta valores entre 0 y 90. */B&2167$17B$77(18$7,21 */B/,1($5B$77(18$7,21 */B48$'5$7,&B$77(18$7,21 Son los parmetros de atenuacin y deber mayor a 0 (cero).

/HRQHO &R\OD ,GPH

35,0,7,9$6 *(20e75,&$6 %,',0(16,21$/(6 Con estas primitivas de objetos podemos definir, lneas, puntos y polgonos. Adems para definir un punto en 2D utilizaremos la siguiente funcin: JO9HUWH[I[ \, en el siguiente cuadro se presenta las primitivas Geomtricas:

PRIMITIVAS GL_POINTS GL_LINES GL_LINE_STRIP GL_LINE_LOOP GL_TRIANGLES GL_QUADS GL_POLYGON

DESCRIPCION Define un punto aislado Dos puntos definen una lnea recta Unin de segmentos de recta Unin de segmentos de recta y cerrados Cada tres puntos es un tringulo Cada cuatro puntos un cuadrado Define un polgono

Grficos en 2D
v1 v0 v2 v3 v4 v5 v6 GL_QUAD S v0 v3 v0 v2 v2 GL_TRIANGLE_STRIP v3 GL_TRIANGLES v4 v5 v5 vo v4 GL_POLYGON v1 v2 v1 v5 v4 GL_TRIANGLE_FAN v0 v2 v3 v7 v4 v0 v3 v2 v1 v1

GL_QUAD_STRIP v1

)250$72 3$5$ /$ '(),1,&,1 '( /$6 35,0,7,9$6 glBegin(<tipo de primitiva>); glVertex(...); glVertex(...); ... glVertex(...); glEnd();

&RPSXWDFLyQ *UDILFD

(MHPSORV: 'LEXMD 3XQWRV glBegin(GL_POINTS); glVertex3f(0.0, 0.0, 0.0); glVertex3f(10.0, 10.0, 10.0); glEnd(); 'LEXMD XQ 7ULiQJXOR glBegin(GL_TRIANGLES); glVertex2i(0, 0,); glVertex2i(0, 0,); glVertex2i(0, 3,); glVertex2i(3, 0,); glEnd(); 3ROL OtQHD FHUUDGD glBegin(GL_LINE_LOOP); glVertex2i(0, 0); glVertex2i(0, 3); glVertex2i(3, 3); glVertex2i(3, 0); glEnd(); 'LEXMD /tQHDV glBegin(GL_LINES); glVertex2i(0, 0,); glVertex2f(5, 5); glVertex2f(1, 1); glEnd(); 8%,&$&,1 '(/ &2/25 '( 5(//(12 (1 81$ 35,0,7,9$ glBegin(GL_TRIANGLES); glColor3f (0.0, 1.0, 0.0); glVertex3f(0.0, 0.0, 0.0); glVertex3f(2.0, 0.0, 0.0); glVertex3f(1.0, 1.0, 0.0); glEnd();

10

/HRQHO &R\OD ,GPH

(67,/26 '( /1($6 Grosor de la lnea. void JO/LQH:LGWK(GLfloatZLGWK); Patrn de lnea void JO/LQH6WLSSOH(Glint IDFWRU, GlshortSDWWHUQ); Es necesario activarlo/desactivarlo z JO(QDEOH*/B/,1(B67,33/( z JO'LVDEOH*/B/,1(B67,33/( 75$16)250$&,1 Las transformaciones geomtricas se encargan de modificar la posicin y orientacin de los objetos y esto se realiza a travs de la matriz modelador en donde OpenGL nos proporciona funciones de alto nivel, para generar matrices de traslacin, rotacin y escalado. 7UDVODFLyQ En OpenGL la traslacin no modifica la geometra del objeto solo su posicin en el espacio y esta operacin consiste en sumar a las coordenadas de cada punto, los valores de desplazamiento en las dos direcciones X e Y. Formato: glTranslatef(GLfloat x, GLfloat y GLfloat z); glTranslatef(GLdouble x, GLdouble y GLdouble z); 5RWDFLyQ Para rotar un objeto es necesario aplicar la transformacin a sus vrtices y unir los puntos transformados. Adems los ngulos positivos se miden en sentido contrario al giro de las agujas del reloj. Formato: glRotatef(GLfloat angle, GLfloat y GLfloat y, GLfloat z); glRotatef(GLdouble angle, GLdouble y GLdouble y, GLdouble z); (VFDODGR En OpenGL modifica la distancia de los puntos donde se aplica, teniendo en cuenta el punto de referencia. Formato: glScalef(GLfloat x, GLfloat y GLfloat z); glScalef(GLdouble x, GLdouble y GLdouble z);

11

&RPSXWDFLyQ *UDILFD

(-(03/26 //Mi primer programa #include <gl/glut.h> #include <stdio.h> #include <stdlib.h> void display(void) { glClearColor(1.0,1.0,1.0,1.0); glClear(GL_COLOR_BUFFER_BIT); glColor3f(0.0,0.0,0.0); glOrtho(-4.0,4.0,-4.0,4.0,-1.0,1.0); glBegin(GL_LINE_LOOP); glVertex2i(0,3); glVertex2i(1,1); glVertex2i(3,0); glVertex2i(1,-1); glVertex2i(0,-3); glVertex2i(-1,-1); glVertex2i(-3,0); glVertex2i(-1,1); glVertex2i(0,3); glEnd(); glFlush(); glutSwapBuffers(); } int main(int argc, char** argv) { glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(400, 400); glutInitWindowPosition(100, 100); glutCreateWindow("Mi Primer Dibujo"); glutDisplayFunc(display); glutMainLoop(); }

12

/HRQHO &R\OD ,GPH

(MHPSOR //Programado por: Ing Leonel Coyla Idme //Dibuja Lneas con estilos de lnea #include <GL/glut.h> void display(void) { glClearColor(1.0,1.0,1.0,1.0); //Fondo blanco glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0,0.0,0.0); // rojo glOrtho(-5.0,5.0,-5.0,5.0,-5.0,5.0); glEnable(GL_LINE_STIPPLE); //Se activa el patron de lneas glLineWidth(2.0); //Grosor de lnea glLineStipple(2,0xAAAA); //Estilo de Linea glBegin(GL_LINE_STRIP); glVertex2i(0,3); glVertex2i(1,2); glVertex2i(2,2); glVertex2i(2,1); glVertex2i(3,0); glVertex2i(2,-1); glVertex2i(2,-1); glVertex2i(2,-2); glVertex2i(1,-2); glVertex2i(0,-3); glVertex2i(-1,-2); glVertex2i(-2,-2); glVertex2i(-2,-1); glVertex2i(-3,0); glVertex2i(-2,1); glVertex2i(-2,1); glVertex2i(-2,2); glVertex2i(-1,2); glVertex2i(0,3); glEnd(); glFlush(); glutSwapBuffers(); } int main(int argc, char *argv[]) { glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(400, 400); glutInitWindowPosition(100, 100); glutCreateWindow("Estilos de Lnea"); glutDisplayFunc(display); glutMainLoop(); }

13

&RPSXWDFLyQ *UDILFD

Ejemplo: //Programado Por el Ing. Leonel Coyla Idme //Dibuja lneas de color verde #include<gl/glut.h> void display(void) { glClearColor(0.0,0.0,0.0,0.0); glClear(GL_COLOR_BUFFER_BIT); glOrtho(-5.0,5.0,-5.0,5.0,-5.0,5.0); glEnable(GL_LINE_STIPPLE); glLineWidth(1.0); glLineStipple(1,0xAAAA); glBegin(GL_LINE_STRIP); glColor3f(0.0,1.0,1.0); glVertex2f(4.0,0.0); glVertex2f(2.0,1.0); glVertex2f(2.0,2.0); glVertex2f(1.0,2.0); glVertex2f(0.0,4.0); glVertex2f(-1.0,2.0); glVertex2f(-2.0,2.0); glVertex2f(-2.0,1.0); glVertex2f(-4.0,0.0); glVertex2f(-2.0,-1.0); glVertex2f(-2.0,-2.0);

14

/HRQHO &R\OD ,GPH

glVertex2f(-1.0,-2.0); glVertex2f(0.0,-4.0); glVertex2f(1.0,-2.0); glVertex2f(2.0,-2.0); glVertex2f(2.0,-1.0); glVertex2f(4.0,0.0); glEnd(); glFlush(); glutSwapBuffers(); } int main(int argc, char *argv[]) { glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(400, 400); glutInitWindowPosition(200, 200); glutCreateWindow("Estilos de Lineas"); glutDisplayFunc(display); glutMainLoop(); }

15

&RPSXWDFLyQ *UDILFD

//Dibuja un Poligono #include <gl/glut.h> #include <stdio.h> #include <stdlib.h> void display(void) { glClearColor(1.0,1.0,1.0,1.0); glClear(GL_COLOR_BUFFER_BIT); glColor3f(0.0, 0.0, 1.0); glOrtho(-3.0,3.0,-3.0,3.0,-3.0,3.0);

glBegin(GL_POLYGON); glVertex2f(2.0, 2.0); glVertex2f(0.0, 3.0); glVertex2f(-2.0, 2.0); glVertex2f(-3.0, 0.0); glVertex2f(-2.0, -2.0); glVertex2f(0.0, -3.0); glVertex2f(2.0, -2.0); glVertex2f(3.0, 0.0); glEnd(); glFlush(); glutSwapBuffers(); } int main(int argc, char *argv[]){ glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(400, 400); glutInitWindowPosition(200, 200); glutCreateWindow("Lineas"); glutDisplayFunc(display); glutMainLoop(); }

16

/HRQHO &R\OD ,GPH

//Dibuja Tringulos #include <gl/glut.h> #include <stdio.h> #include <stdlib.h> void display(void) { glClearColor(1.0,1.0,1.0,1.0); glClear(GL_COLOR_BUFFER_BIT); glOrtho(-2.0,2.0,-2.0,2.0,-2.0,2.0); glBegin(GL_TRIANGLES); glColor3f(0.0, 0.0,1.0); glVertex2f(0.0, 0.0); glVertex2f(1.5, 0.0); glVertex2f(1.5, 1.5); glVertex2f(0.0, 0.0); glVertex2f(-1.5, 0.0); glVertex2f(-1.5, -1.5); glEnd(); glFlush(); glutSwapBuffers(); } int main(int argc, char *argv[]){ glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(400, 400);

17

&RPSXWDFLyQ *UDILFD

glutInitWindowPosition(100, 100); glutCreateWindow("Dibuja Triangulos"); glutDisplayFunc(display); glutMainLoop(); }

(MHPSOR //Dibuja un triangulo, cada vrtice con diferentes colores #include <gl/glut.h> #include <stdio.h> #include <stdlib.h> void display(void) { glClearColor(0.0,0.0,0.0,0.0); glClear(GL_COLOR_BUFFER_BIT); glOrtho(-1.0,1.0,-1.0,1.0,-1.0,1.0); glBegin(GL_TRIANGLES); glColor3f(1.0f,0.0f,0.0f); glVertex2f(-0.5,-0.5); glColor3f(0.0f,1.0f,0.0f); glVertex2f(0.5,-0.5);

18

/HRQHO &R\OD ,GPH

glColor3f(0.0f,0.0f,1.0f); glVertex2f(0.0,0.5); glEnd(); glFlush(); glutSwapBuffers(); } int main(int argc, char *argv[]){ glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(400, 400); glutInitWindowPosition(100, 100); glutCreateWindow("Triangulo"); glutDisplayFunc(display); glutMainLoop(); }

(MHPSOR: // Dibuja Un polgono cerrado (Cuadrado) //Dibuja Polyline (cerrada) #include <gl/glut.h> #include <stdio.h> #include <stdlib.h> void display(void) { glClearColor(0.0,0.0,0.0,0.0); glClear(GL_COLOR_BUFFER_BIT); glOrtho(-1.0,1.0,-1.0,1.0,-1.0,1.0); glColor3f(1.0,1.0,1.0); glBegin(GL_LINE_LOOP); glVertex2f(0.0,0.0);

19

&RPSXWDFLyQ *UDILFD

glVertex2f(0.0,0.5); glVertex2f(0.5,0.5); glVertex2f(0.5,0.0); glEnd(); glFlush(); glutSwapBuffers(); } int main(int argc, char *argv[]) { glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(400, 400); glutInitWindowPosition(100, 100); glutCreateWindow("Dibuja Polylinea Cerrada"); glutDisplayFunc(display); glutMainLoop(); }

20

/HRQHO &R\OD ,GPH

//Dibuja un cuadrado, cada vrtice con diferentes colores. #include <gl/glut.h> #include <stdio.h> #include <stdlib.h> void display(void) { glClearColor(1.0,1.0,1.0,0.0); glClear(GL_COLOR_BUFFER_BIT); glOrtho(-1.0,1.0,-1.0,1.0,-1.0,1.0); glBegin(GL_QUADS); glColor3f(1.0f,0.0f,0.0f); glVertex2f(-0.5,-0.5); glColor3f(0.0f,1.0f,0.0f); glVertex2f(0.5,-0.5); glColor3f(0.0f,0.0f,1.0f); glVertex2f(0.5,0.5); glColor3f(0.0f,1.0f,1.0f); glVertex2f(-0.5,0.5); glEnd(); glFlush(); glutSwapBuffers(); } int main(int argc, char *argv[]) { glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(400, 400); glutInitWindowPosition(100, 100); glutCreateWindow("Cuadrado"); glutDisplayFunc(display); glutMainLoop(); }

21

&RPSXWDFLyQ *UDILFD

// Dibuja el Sistema de Coordenadas y un cuadrado #include <GL/glut.h> #define ancho 320 #define alto 240 #define profundidad 500 void dibuja(); int main(int argc, char** argv) { glutInitDisplayMode(GLUT_RGBA | GLUT_SINGLE); glutInitWindowPosition(100, 0); glutInitWindowSize(ancho, alto); glutCreateWindow("Sistema de Coordenadas"); glOrtho(-(ancho/2), (ancho/2), -(alto/2), (alto/2), -profundidad, profundidad); glClearColor(1, 1, 1, 0); glutDisplayFunc(dibuja); glutMainLoop(); return 0; } void dibuja() { glClear(GL_COLOR_BUFFER_BIT); glColor3f(0, 0, 0); glBegin(GL_LINES); glVertex2f(-ancho/2, 0); glVertex2f(ancho/2, 0); glVertex2f(0, alto/2); glVertex2f(0, -alto/2); glEnd(); glColor3f(1, 0, 0); glBegin(GL_QUADS); glVertex2f(50,-50); glVertex2f(-50,-50); glVertex2f(-50,50); glVertex2f(50,50); glEnd(); glFlush(); }

22

/HRQHO &R\OD ,GPH

Ejemplo: //Programado por Ing Leonel Coyla Idme //Tamao de Puntos #include <GL/glut.h> void display(void) { glClearColor(1.0,1.0,1.0,0.0); //Fondo plomo glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0,0.0,1.0); // magenta glOrtho(-7.0,7.0,-7.0,7.0,-7.0,7.0); glPointSize(3.0); glBegin(GL_POINTS); glVertex2i(0,0); glVertex2i(0,3); glVertex2i(3,0); glVertex2i(3,3); glEnd(); glFlush(); glutSwapBuffers(); } int main(int argc, char *argv[]) { glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(400, 400); glutInitWindowPosition(100, 100); glutCreateWindow("TamaoDePuntos"); glutDisplayFunc(display); glutMainLoop(); }

23

&RPSXWDFLyQ *UDILFD

(MHPSOR //Dibuja Estilos de Lneas #include <gl/glut.h> #include <stdio.h> #include <stdlib.h> void display(void) { glClearColor(0.0,0.0,0.0,0.0); glClear(GL_COLOR_BUFFER_BIT); glOrtho(-1.0,1.0,-1.0,1.0,-1.0,1.0); glEnable(GL_LINE_STIPPLE); glLineWidth(1.0); //Ancho de linea glLineStipple(1,0x00FF); //guion glBegin(GL_LINES); glColor3f(0.0,1.0,0.0); glVertex2f(-0.7,-0.5); glVertex2f(-0.7,0.5); glEnd(); glLineStipple(1,0x1C47); //Linea Punto Linea glBegin(GL_LINES); glColor3f(0.0,1.0,1.0); glVertex2f(-0.5,-0.5); glVertex2f(-0.5,0.5); glEnd(); glLineStipple(1,0x0101); //Puntos glBegin(GL_LINES); glColor3f(1.0,1.0,0.0); glVertex2f(-0.3,-0.5); glVertex2f(-0.3,0.5); glEnd(); glLineStipple(2,0xAAAA); // glBegin(GL_LINES); glColor3f(1.0,0.0,1.0); glVertex2f(0.3,-0.5); glVertex2f(0.3,0.5); glEnd(); glLineStipple(2,0x0C0F); // glBegin(GL_LINES); glColor3f(0.0,0.0,1.0); glVertex2f(0.5,-0.5); glVertex2f(0.5,0.5); glEnd(); glLineStipple(2,0x00FF); //

24

/HRQHO &R\OD ,GPH

glBegin(GL_LINES); glColor3f(1.0,0.0,0.0); glVertex2f(0.7,-0.5); glVertex2f(0.7,0.5); glEnd(); glLineStipple(3,0x00FF); // glBegin(GL_LINES); glColor3f(1.0,1.0,0.0); glVertex2f(0.0,-0.5); glVertex2f(0.0,0.5); glTexCoord1d (15); glEnd(); glFlush(); glutSwapBuffers(); } int main(int argc, char *argv[]) { glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(400, 400); glutInitWindowPosition(100, 100); glutCreateWindow("Dibuja Estilos de Lneas"); glutDisplayFunc(display); glutMainLoop(); }

25

&RPSXWDFLyQ *UDILFD

//Dibuja lineas formando un crculo # include<GL/glut.h> # include<stdio.h> # include<stdlib.h> # include<math.h> void display(void){ glClearColor(0.0,0.0,0.0,0.0); glClear(GL_COLOR_BUFFER_BIT); glOrtho(-1.0,1.0,-1.0,1.0,-1.0,1.0); glColor3f(1.0f,0.0f,0.0f); GLfloat angulo; int i; glBegin(GL_LINES); for(i=1;i<360;i+=3) { angulo=(GLfloat)i*3.14159f/180.0f; glVertex3f(0.0f,0.0f,0.0f); glVertex3f(cos(angulo),sin(angulo),0.0f); } glEnd(); glFlush(); glutSwapBuffers(); } int main(int argc, char argv[]) { glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(400,400); glutInitWindowPosition(100,100); glutCreateWindow("Lineas en Forma Circular"); glutDisplayFunc(display); glutMainLoop(); }

26

/HRQHO &R\OD ,GPH

//Dibuja un Circulo # include<GL/glut.h> # include<stdio.h> # include<stdlib.h> # include<math.h> void display(void){ glClearColor(0.0,0.0,0.0,0.0); glClear(GL_COLOR_BUFFER_BIT); glOrtho(-1.0,1.0,-1.0,1.0,-1.0,1.0); glColor3f(1.0f,0.0f,0.0f); GLfloat angulo; int i; glBegin(GL_LINE_LOOP); for(i=0;i<360;i++) { angulo=2*3.14159*i/360; glVertex2f(cos(angulo),sin(angulo)); } glEnd(); glFlush(); glutSwapBuffers(); } int main(int argc, char * argv[]) { glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(500,500); glutInitWindowPosition(100,100); glutCreateWindow("Lineas en Forma Circular"); glutDisplayFunc(display); glutMainLoop(); }

27

&RPSXWDFLyQ *UDILFD

//Traslacin //Dibuja un cuadrado y avanza a la Derecha, Izquierda, Arriba y Abajo #include <GL/glut.h> #define ancho 320 #define altura 240 #define profundidad 500 void DibujaCuadrado(); void ejesxy(); void TecladoMovimiento(int tecla, int x, int y); int posx=0, posy=0; int main(int argc, char** argv) { glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowPosition(100, 0); glutInitWindowSize(ancho, altura); glutCreateWindow("Traslacin 2D "); glOrtho(-(ancho/2), (ancho/2), -(altura/2), (altura/2), -profundidad, profundidad); glClearColor(1, 1, 1, 0); glutDisplayFunc(DibujaCuadrado); glutSpecialFunc(TecladoMovimiento); glutMainLoop(); return 0; } void DibujaCuadrado() { glClear(GL_COLOR_BUFFER_BIT); ejesxy(); glPushMatrix(); glTranslatef(posx, posy,0); glBegin(GL_QUADS); glColor3f(1, 0, 0);glVertex2f(-50,-50); glColor3f(0, 1, 1);glVertex2f(-50,50); glColor3f(1, 1, 0);glVertex2f(50,50); glColor3f(0, 0, 1);glVertex2f(50, -50); glEnd(); glPopMatrix(); glutSwapBuffers(); } void ejesxy() { glColor3f(1.0, 0.0, 0.0); glBegin(GL_LINES); glVertex2f(-ancho/2, 0);

28

/HRQHO &R\OD ,GPH

glVertex2f(ancho/2, 0); glVertex2f(0, altura/2); glVertex2f(0, -altura/2); glEnd(); } void TecladoMovimiento(int tecla, int x, int y) { switch(tecla) { case GLUT_KEY_UP : posy++;break; case GLUT_KEY_DOWN : posy--;break; case GLUT_KEY_RIGHT : posx++;break; case GLUT_KEY_LEFT : posx--;break; } glutPostRedisplay(); }

29

&RPSXWDFLyQ *UDILFD

//Rotacion de un cuadrado en su mismo eje, en 2D #include <GL/glut.h> #define ancho 320 #define altura 240 #define profundidad 500 void DibujaCuadrado(); void EjesXY(); void Teclado(unsigned char tecla, int x, int y); int angulo=0; int main(int argc, char** argv) { glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowPosition(100, 0); glutInitWindowSize(ancho, altura); glutCreateWindow("Rotacin de un Cuadrado en 2D"); glOrtho(-(ancho/2), (ancho/2), -(altura/2), (altura/2), -profundidad, profundidad); glClearColor(1, 1, 1, 0); glutDisplayFunc(DibujaCuadrado); glutKeyboardFunc(Teclado); glutMainLoop(); return 0; } void DibujaCuadrado() { glClear(GL_COLOR_BUFFER_BIT); EjesXY(); glPushMatrix(); glRotatef(angulo, 0, 0, 1); glBegin(GL_QUADS); glColor3f(1, 0, 0);glVertex2i(50,50); glColor3f(1, 1, 0);glVertex2i(-50, 50); glColor3f(1, 0, 0);glVertex2i(-50, -50); glColor3f(1, 1, 0);glVertex2i(50, -50); glEnd(); glPopMatrix(); glutSwapBuffers(); } void EjesXY() { glColor3f(1.0, 0.0, 1.0); glBegin(GL_LINES); glVertex2i(-ancho/2, 0); glVertex2i(ancho/2, 0);

30

/HRQHO &R\OD ,GPH

glVertex2i(0, altura/2); glVertex2i(0, -altura/2); glEnd(); } void Teclado(unsigned char tecla, int x, int y) { switch(tecla) { case s: case S: case 27: exit(0);break; case l: case L: angulo++; break; case r: case R: angulo--; break; } glutPostRedisplay(); }

31

&RPSXWDFLyQ *UDILFD

//Escalado //Amplia y reduce el tamao de un cuadrado en 2D #include <GL/glut.h> #define ancho 320 #define altura 240 #define profundidad 500 void DibujaCuadrado(); void EjesXY(); void TecladoScala(int tecla, int x, int y); float esc=1; int main(int argc, char** argv) { glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowPosition(100, 0); glutInitWindowSize(ancho, altura); glutCreateWindow("Amplia y Reduce el Tamao de un Cuadrado"); glOrtho(-(ancho/2), (ancho/2), -(altura/2), (altura/2), -profundidad, profundidad); glClearColor(0, 0, 1, 0); glutDisplayFunc(DibujaCuadrado); glutSpecialFunc(TecladoScala); glutMainLoop(); return 0; } void DibujaCuadrado() { glClear(GL_COLOR_BUFFER_BIT); EjesXY(); glPushMatrix(); glScalef(esc, esc, esc); glBegin(GL_QUADS); glColor3f(1, 0, 0);glVertex2i(50,50); glColor3f(1, 1, 0);glVertex2i(-50, 50); glColor3f(1, 0, 0);glVertex2i(-50, -50); glColor3f(1, 1, 0);glVertex2i(50, -50); glEnd(); glPopMatrix(); glutSwapBuffers(); } void EjesXY() { glColor3f(1, 1, 1); glBegin(GL_LINES); glVertex2i(-ancho/2, 0);

32

/HRQHO &R\OD ,GPH

glVertex2i(ancho/2, 0); glVertex2i(0, altura/2); glVertex2i(0, -altura/2); glEnd(); } void TecladoScala(int tecla, int x, int y) { switch(tecla) { case GLUT_KEY_PAGE_UP : esc=esc*1.01; break; case GLUT_KEY_PAGE_DOWN : esc=esc*0.99; break; } glutPostRedisplay(); }

33

&RPSXWDFLyQ *UDILFD

// Dibuja triangulo en 2D (Escalado, Traslacin y Rotacin), con colores diferentes en cada vrtice #include <GL/glut.h> #define ancho 320 #define alto 240 #define profundidad 500 void dibuja(); void ejes(); void tecladoNormal(unsigned char tecla, int x, int y); void tecladoEspecial(int tecla, int x, int y); int posx=0, posy=0; int angulo=0; float esc=1; int main(int argc, char** argv) { glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowPosition(100, 0); glutInitWindowSize(ancho, alto); glutCreateWindow("Transformaciones Geometricas"); glOrtho(-(ancho/2), (ancho/2), -(alto/2), (alto/2), -profundidad, profundidad); glClearColor(1, 1, 1, 0); glutDisplayFunc(dibuja); glutKeyboardFunc(tecladoNormal); glutSpecialFunc(tecladoEspecial); glutMainLoop(); return 0; } void dibuja() { glClear(GL_COLOR_BUFFER_BIT); ejes(); glPushMatrix(); glTranslatef(posx, posy, 0); glRotatef(angulo, 0, 0, 1); glScalef(esc, esc, esc); glBegin(GL_POLYGON); glColor3f(1, 0, 0);glVertex3f(0, 100, 0); glColor3f(1, 1, 0);glVertex3f(50, -50, 0); glColor3f(0, 0, 1);glVertex3f(-50, -50, 0); glEnd(); glPopMatrix(); glutSwapBuffers(); } void ejes() {

34

/HRQHO &R\OD ,GPH

glColor3f(0.9, 0.9, 0.9); glBegin(GL_LINES); glVertex3f(-ancho/2, 0, 0); glVertex3f(ancho/2, 0, 0); glVertex3f(0, alto/2, 0); glVertex3f(0, -alto/2, 0); glEnd(); } void tecladoNormal(unsigned char tecla, int x, int y) { switch(tecla) { case s: case S: case 27: exit(0);break; case g: case G: angulo++;break; } glutPostRedisplay(); } void tecladoEspecial(int tecla, int x, int y) { switch(tecla) { case GLUT_KEY_UP : posy++;break; case GLUT_KEY_DOWN : posy--;break; case GLUT_KEY_RIGHT : posx++;break; case GLUT_KEY_LEFT : posx--;break; case GLUT_KEY_PAGE_UP : esc=esc*1.01;break; case GLUT_KEY_PAGE_DOWN: esc=esc*0.99;break; } glutPostRedisplay(); }

35

&RPSXWDFLyQ *UDILFD

(MHPSOR //Dibuja la funcion seno #include <GL/glut.h> #include <math.h> GLfloat angulo; void inicioOpenGL(void){ glEnable(GL_DEPTH_TEST); glClearColor(1.0, 1.0, 1.0, 1.0); } void DibujaFuncionSeno(void){ int k; float anguloFuncion,xanterior,yanterior,x,y; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix(); glTranslatef(0.0,0.0,-6.0); glColor3f(1.0,0.0,0.0); //Linea de color rojo glRotatef(angulo,0.0,1.0,0.0); anguloFuncion=2*3.14159/300; xanterior=0; yanterior=sin(xanterior); for (k=0;k<300;k++){ glBegin(GL_LINES); glVertex3f(xanterior,yanterior,0.0); x=anguloFuncion*k; y=sin(x); glVertex3f(x,y,0.0); xanterior=x; yanterior=y; glEnd(); } glPopMatrix(); glutSwapBuffers (); } void reshape(int w, int h) { glViewport(0, 0, w, h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-7.0, 7.0, -2.0, 2.0, -10.0, 10.0); glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); } void UsoTeclado(unsigned char tecla, int x, int y){ switch (tecla) { case 27: /* ESC */ exit(0); break; case f: glutFullScreen(); break; case w: glutReshapeWindow(300,300); break; } } int main (int argc, char** argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE); glutInitWindowSize(300,300); glutInitWindowPosition(150,150); glutCreateWindow("Funcion Seno");

36

/HRQHO &R\OD ,GPH

inicioOpenGL(); glutReshapeFunc(reshape); glutKeyboardFunc(UsoTeclado); glutDisplayFunc(DibujaFuncionSeno); glutMainLoop(); return 0; }

37

&RPSXWDFLyQ *UDILFD

862 '(/ 7(&/$'2 El control del teclado se realiza mediante: glutKeyboardFunc(ControlTeclado); esto lo aadimos a nuestra funcin main y entonces definimos a parte la funcin de control propiamente dicha de la siguiente forma: void ControlTeclado(unsigned char key, int x, int y) { < cdigo fuente del que se desea ejecutar> } A continuacin de tiene una lista de teclas de Funcin que acepta OpenGL: # define GLUT_KEY_F1 # define GLUT_KEY_F2 # define GLUT_KEY_F3 # define GLUT_KEY_F4 # define GLUT_KEY_F5 # define GLUT_KEY_F6 # define GLUT_KEY_F7 # define GLUT_KEY_F8 # define GLUT_KEY_F9 # define GLUT_KEY_F10 # define GLUT_KEY_F11 # define GLUT_KEY_F12 Teclado de direccin # define GLUT_KEY_LEFT 100 # define GLUT_KEY_UP 101 # define GLUT_KEY_RIGHT 102 # define GLUT_KEY_DOWN 103 # define GLUT_KEY_PAGE_UP 104 # define GLUT_KEY_PAGE_DOWN 105 # define GLUT_KEY_HOME 106 # define GLUT_KEY_END 107 # define GLUT_KEY_INSERT 108 862 '(/ 0286( UDWyQ OpenGL, reconoce que cada vez que pulse uno de los tres botones del ratn debe ejecutar una orden formada por sentencias, a este se le denomina ControlRaton y apara que esto pueda ejecutarse debemos crear una funcin de la forma: void ControlRatn(int button, int state, int x, int y) { < Cdigo fuente del que se desea ejecutar> } 1 2 3 4 5 6 7 8 9 10 11 12

38

/HRQHO &R\OD ,GPH

Los parmetros que tiene esta funcin son: EXWWRQ.- Si el usuario pulsa los botones izquierdo, derecho y medio, estas en OpenGL se encuentran definidas de la siguiente forma: GLUT_LEFT_BUTTON, GLUT_RIGHT_BUTTON y GLUT_MIDDLE_BUTTON. 6WDWH.- El estado de los botones del ratn son GLU_UP o GLUT_DOWN, de acuerdo como se ha pulsado/soltado el botn. ; H <.- Estos parmetros son las coordenadas, con respecto a la ventana de visualizacin. El control del ratn se realiza mediante: glutMouseFunc(ControlRaton); (MHPSOR //Programado por Ing Leonel Coyla Idme //Dibuja un objeto de color azul #include <GL/glut.h> #include<stdio.h> void ControlRaton(int button, int state, int x, int y); void display(void) { glClearColor(1.0,1.0,1.0,0.0); glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0,0.0,0.0); // rojo glOrtho(-5.0,5.0,-5.0,5.0,-5.0,5.0); glBegin(GL_LINE_LOOP); glVertex2i(0,3); glVertex2i(1,2); glVertex2i(2,2); glVertex2i(2,1); glVertex2i(3,0); glVertex2i(2,-1); glVertex2i(2,-2); glVertex2i(1,-2); glVertex2i(0,-3); glVertex2i(-1,-2); glVertex2i(-2,-2); glVertex2i(-2,-1); glVertex2i(-3,0); glVertex2i(-2,1); glVertex2i(-2,2); glVertex2i(-1,2); glVertex2i(0,3); glEnd(); glutSwapBuffers();

39

&RPSXWDFLyQ *UDILFD

} void ControlRaton(int button, int state, int x, int y) { if(button==GLUT_LEFT_BUTTON && state==GLUT_DOWN) { printf("Pulso el boton Izquierdo del raton...\n"); } if(button==GLUT_RIGHT_BUTTON && state==GLUT_DOWN) { printf("Pulso el boton derecho del raton...\n"); } if(button==GLUT_MIDDLE_BUTTON && state==GLUT_DOWN) { printf("Pulso el boton del medio...\n"); } } int main(int argc, char *argv[]) { glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(400, 400); glutInitWindowPosition(100, 100); glutCreateWindow("Uso del Raton"); glutDisplayFunc(display); glutMouseFunc(ControlRaton); glutMainLoop(); }

Cada vez que pulsa uno de los tres botones del ratn aparecera un mensaje en la ventana de consola de la siguiente forma:

40

/HRQHO &R\OD ,GPH

41

&RPSXWDFLyQ *UDILFD

75$16)250$&,21 *(20(75,&$ 75,',0(16,21$/ OpenGL trabaja en un espacio de 3 dimensiones, pero internamente utiliza las coordenadas homogneas que consiste en un espacio de cuatro dimensiones, que representa matrices de 4x4. Cada uno de los puntos se debe identificar mediante una terna de coordenadas (x,y,z). Sin embargo en una en coordenada homognea se representa por 4 coordenadas (x,y,z,W). La cuarta coordenada se utiliza para representar la perspectiva. 6,67(0$ '( &225'(1$'$6

Toda transformacin en 3D se realiza mediante una matriz de cuatro dimensiones y esta se multiplica por una matriz de transformacin inicial. Ejemplo: Si se desea trasladar un objeto de 2 unidades en el eje x, debemos generar una matriz de transformacin de la siguiente forma: 1 0 0 0 0 0 2 1 0 0 0 1 0 0 0 1

La nueva matriz de transformacin se obtiene multiplicando la matriz identidad por la matriz que se desea trasladar un objeto 2 unidades en el eje x, de la siguiente forma: 1 0 0 0 0 0 0 1 1 0 0 0 ; 0 1 0 0 0 0 1 0 0 0 2 1 1 0 0 0 = 0 1 0 0 0 0 1 0 0 0 2 1 0 0 0 1 0 0 0 1

Si se desea dibujar el punto (1,0,0), considerando que se desea trasladar dos unidades en el eje x, se debe realizar la siguiente multiplicacin de matrices:

42

/HRQHO &R\OD ,GPH

1 0 0 0

0 0 2 1 3 1 0 0 0 0 ; = 0 1 0 0 0 0 0 1 1 1

Esta multiplicacin de matrices nos permite ubicar el punto en la posicin (3,0,0), al realizar esta multiplicacin se a convertido a coordenadas homogneas, esto se consigue agregando el valor 1, para cumplir con la matriz de 4x4. &225'(1$'$6 +202*e1($6.- Todas las coordenadas que se utiliza en OpenGL, ya sea en 2D o 3D, son convertidas en coordenadas homogneas, esto se realiza para uniformizar la operacin con matrices y la representacin de la profundidad. Ejemplo: El punto 2D (3, 2) OpenGL lo convierte al punto (3, 2, 0.0, 1.0) El punto 3D (1, 2, 4) OpenGL lo convierte al punto (1, 2, 4, 1.0) 75$16)250$&,21 '( 2%-(726 Las transformaciones en 3D son aquellos que se encargan de visualizar un objeto en el espacio y estas son traslacin, rotacin y escalado. 7UDVODFLyQ.- La operacin de traslacin responde a la siguiente matriz: 1 0 7 (G[, G\, G] ) = 0 0 0 1 0 0 0 G[ 0 G\ 1 G] 0 1

Donde dx, dy y dz son las distancias de traslacin, estas pueden ser nmeros reales positivos o negativos.

(VFDODGR.- La operacin de escalado responde a la siguiente matriz:

43

&RPSXWDFLyQ *UDILFD

6 [ 0 6 (6 [ , 6 \ , 6 ] ) = 0 0

6\ 0 0

0 6] 0 0

0 0 0 1

Donde Sx, Sy y Sz son los factores de direccin x, y, z y un punto de referencia.

5RWDFLyQ.- La operacin de rotacin responde a las siguientes matrices: 0 1 0 cos 5[ ( ) = 0 VHQ 0 0 VHQ cos 0 0 0 0 0 1 cos 0 5 \ ( ) = VHQ 0 VHQ cos 0 0 0 0 0 1 0 VHQ 1 0 0 cos 0 0 0 0 0 1

cos VHQ 5 ] ( ) = 0 0

0 0 1 0

44

/HRQHO &R\OD ,GPH

35,0,7,9$6 '( ',%8-2 (1 '

void glutSolidSphere(GLdouble radius,GLint slices, GLint stacks); void glutWireSphere(GLdouble radius,GLint slices, GLint stacks); void glutSolidCube(GLdouble size); void glutWireCube(GLdouble size); void glutSolidCone(GLdouble base, GLdouble height, GLint slices, GLint stacks); void glutWireCone(GLdouble base, GLdouble height,GLint slices, GLint stacks); void glutSolidTorus(GLdouble innerRadius,GLdouble outerRadius, GLint nsides, GLint rings); void glutWireTorus(GLdouble innerRadius,GLdouble outerRadius, GLint nsides, GLint rings); void glutSolidDodecahedron(void); void glutWireDodecahedron(void); void glutSolidOctahedron(void); void glutWireOctahedron(void); void glutSolidTetrahedron(void); void glutWireTetrahedron(void); void glutSolidIcosahedron(void); void glutWireIcosahedron(void); void glutSolidTeapot(GLdouble size); void glutWireTeapot(GLdouble size);

(MHPSOR

JO(QDEOH*/B&8//B)$&( Se utiliza para activar el mtodo de ocultacin que consiste en ocultar cara que son se dibujan porque formaran parte de la parte trasera del objeto. 7,326 < 7$0$f26 '( /(75$ JOXW%LWPDS&KDUDFWHU )RUPDWR void glutBitmapCharacter(void *font, int character); Donde: Font = Tipos de letra a usar en Bitmap. Character = Tipos de caracteres a usar.

glutBitmapCharacter, Caracteres de bitmap que se usa en OpenGL

45

&RPSXWDFLyQ *UDILFD

Tipos de caracteres disponibles: GLUT_BITMAP_8_BY_13 GLUT_BITMAP_9_BY_15 GLUT_BITMAP_TIMES_ROMAN_10 GLUT_BITMAP_TIMES_ROMAN_24 GLUT_BITMAP_HELVETICA_10 GLUT_BITMAP_HELVETICA_12 GLUT_BITMAP_HELVETICA_18 JOXW%LWPDS:LGWK Retorna el ancho de un caracter de tipo bitmap en pixeles )RUPDWR  int glutBitmapWidth(GLUTbitmapFont font, int character); Donde: Font = Tipos de letra a usar en Bitmap. Character = Tipos de caracteres a usar. JOXW6WURNH&KDUDFWHU glutStrokeCharacter entraga un character de golpe que utiliza OpenGL. )RUPDWR void glutStrokeCharacter(void *font, int character); Font = Tipos de letra a usar en Bitmap. Character = Tipos de caracteres a usar. Los tipos de caracteres disponibles son: GLUT_STROKE_ROMAN GLUT_STROKE_MONO_ROMAN JOXW6WURNH:LGWK glutStrokeWidth retorna el ancho de un character en pixels. )RUPDWR int glutStrokeWidth(GLUTstrokeFont font, int character); font = Tipos de letra a usar en Stroke. Character = Retorna el ancho de un caracater.

46

/HRQHO &R\OD ,GPH

(MHPSOR // Traslacion de un Objeto en 3 Dimensiones #include <GL/glut.h> #define ancho 500 #define alto 375 #define profundidad 400 void DibujaObjeto3D(); void EjesXYZ(); void tecladoEspecial(int tecla, int x, int y); int posx=0, posy=0; int angulo=15; float colorr=1, colorg=0, colorb=0; int main(int argc, char** argv) { glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowPosition(100, 0); glutInitWindowSize(ancho, alto); glutCreateWindow("Figuras GLUT"); glOrtho(-(ancho/2), (ancho/2), -(alto/2), (alto/2), -profundidad, profundidad); glClearColor(1, 1, 1, 0); glutDisplayFunc(DibujaObjeto3D); glutSpecialFunc(tecladoEspecial); glutMainLoop(); return 0; } void DibujaObjeto3D() { glClear(GL_COLOR_BUFFER_BIT); EjesXYZ(); glPushMatrix(); glTranslatef(posx, posy, 0); //glRotatef(angulo, 1, 1, 1); //glRotatef(0, 1, 1, 1); glColor3f(0,0,1); //glutWireCone(50, 200, 18, 18); glutWireTeapot(100); glPopMatrix(); glutSwapBuffers(); } void EjesXYZ() { glColor3f(1.0, 0.0, 0.0); glBegin(GL_LINES); glVertex3f(-ancho/2, 0, 0);

47

&RPSXWDFLyQ *UDILFD

glVertex3f(ancho/2, 0, 0); glVertex3f(0, alto/2, 0); glVertex3f(0, -alto/2, 0); glEnd(); } void tecladoEspecial(int tecla, int x, int y) { switch(tecla) { case GLUT_KEY_UP : posy++;break; case GLUT_KEY_DOWN : posy--;break; case GLUT_KEY_RIGHT : posx++;break; case GLUT_KEY_LEFT : posx--;break; } glutPostRedisplay(); }

48

/HRQHO &R\OD ,GPH

// Escalado de un Objeto3D #include <GL/glut.h> #define ancho 500 #define alto 375 #define profundidad 400 void DibujaObjeto3D(); void EjesXYZ(); void tecladoEspecial(int tecla, int x, int y); float esc=1; int main(int argc, char** argv) { glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowPosition(100, 0); glutInitWindowSize(ancho, alto); glutCreateWindow("Escala de un Objeto 3D"); glOrtho(-(ancho/2), (ancho/2), -(alto/2), (alto/2), -profundidad, profundidad); glClearColor(1, 1, 1, 0); glutDisplayFunc(DibujaObjeto3D); glutSpecialFunc(tecladoEspecial); glutMainLoop(); return 0; } void DibujaObjeto3D() { glClear(GL_COLOR_BUFFER_BIT); EjesXYZ(); glPushMatrix(); glScalef(esc, esc, esc); glColor3f(1,0,0); glutWireTorus(20, 80, 18, 18); glPopMatrix(); glutSwapBuffers(); } void EjesXYZ() { glColor3f(0.9, 0.9, 0.9); glBegin(GL_LINES); glVertex3f(-ancho/2, 0, 0); glVertex3f(ancho/2, 0, 0); glVertex3f(0, alto/2, 0); glVertex3f(0, -alto/2, 0); glEnd(); }

49

&RPSXWDFLyQ *UDILFD

void tecladoEspecial(int tecla, int x, int y) { switch(tecla) { case GLUT_KEY_PAGE_UP : esc=esc*1.01;break; case GLUT_KEY_PAGE_DOWN : esc=esc*0.99;break; } glutPostRedisplay(); }

50

/HRQHO &R\OD ,GPH

// Rota un objeto 3d (esferera) #include <GL/glut.h> #define ancho 500 #define alto 375 #define p 400 void DibujaObjeto3D(); void EjesXYZ(); void tecladoNormal(unsigned char tecla, int x, int y); void texto(int x, int y, char *palabra); int angulo=35;

int main(int argc, char** argv) { glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowPosition(100, 0); glutInitWindowSize(ancho, alto); glutCreateWindow("Dibuja un objeto en 3D"); glOrtho(-(ancho/2), (ancho/2), -(alto/2), (alto/2), -p, p); glClearColor(1, 1, 1, 0); glutDisplayFunc(DibujaObjeto3D); glutKeyboardFunc(tecladoNormal); glutMainLoop(); return 0; } void DibujaObjeto3D() { glClear(GL_COLOR_BUFFER_BIT); EjesXYZ(); glPushMatrix(); glRotatef(angulo, 1, 1, 1); glRotatef(45, 1, 1, 1); glColor3f(0, 0, 1); glutWireSphere(100, 18, 18); glPopMatrix(); texto(-ancho/2+82,alto/2-20,"FACULTAD DE INGENIERIA ESTADISTICA E INFORMATICA"); glutSwapBuffers(); } void EjesXYZ() { glColor3f(0.9, 0.9, 0.9); glBegin(GL_LINES); glVertex3f(-ancho/2, 0, 0);

51

&RPSXWDFLyQ *UDILFD

glVertex3f(ancho/2, 0, 0); glVertex3f(0, alto/2, 0); glVertex3f(0, -alto/2, 0); glEnd(); } void tecladoNormal(unsigned char tecla, int x, int y) { switch(tecla) { case s: case S: case 27: exit(0);break; case r: case R: angulo++;break; } glutPostRedisplay(); } void texto(int x, int y, char *palabra) { int i; glColor3f(0,0,1); glRasterPos2f(x, y); for (i = 0; palabra[i]; i++) glutBitmapCharacter(GLUT_BITMAP_HELVETICA_12, palabra[i]); }

52

/HRQHO &R\OD ,GPH

Ejemplo: //Escalado de un objeto con teclado y ratn #include <gl/glut.h> #include <stdio.h> #include <math.h> #define ancho 300 #define alto 300 #define profundidad 200 float esc=1; void dibujarEscala() { glClear(GL_COLOR_BUFFER_BIT); glPushMatrix(); glScalef( esc, esc, esc ); glutWireTeapot( 50.0 ); glPopMatrix(); glutSwapBuffers(); } void TecladoEspecial(int tecla, int X, int Y) { switch(tecla) { case GLUT_KEY_PAGE_UP : esc = esc * 1.01; break; case GLUT_KEY_PAGE_DOWN: esc = esc * 0.99; break; } glutPostRedisplay(); }

void ratonEscala(int Button, int State, int x, int y ) { glutPostRedisplay(); } void moverEscala( int x, int y ) { if( y > (alto/2) ) { esc = esc * 1.01; } else { esc = esc * 0.99; }

53

&RPSXWDFLyQ *UDILFD

glutPostRedisplay(); } int main(int argc, char **argv[]) { glutInitDisplayMode( GLUT_RGBA|GLUT_DOUBLE ); glutInitWindowPosition(0,0); glutInitWindowSize(ancho,alto); glutCreateWindow("Escalado de un Objeto 3D Raton - Teclado"); glOrtho(-(ancho/2),(ancho/2),-(alto/2),(alto/2),-profundidad,profundidad); glutDisplayFunc( dibujarEscala ); glutSpecialFunc(TecladoEspecial); glutMouseFunc( ratonEscala ); glutMotionFunc( moverEscala ); glutMainLoop(); return 0; }

54

/HRQHO &R\OD ,GPH

(MHPSOR

//Dibuja Figuras como Icosahedron, Tetrahedron, Octahedron y Dodecahedron en forma de malla //Para cambiar de figura pulse F1,F2,F3 y F4

#include <GL/glut.h> void DibujaFiguras(); void RotacionFigura(unsigned char tecla, int x, int y); void SeleccionFiguras(int tecla, int x, int y); int angulo=35; unsigned int figura=1; int main(int argc, char** argv) { glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowPosition(100, 0); glutInitWindowSize(500, 380); glutCreateWindow("Figuras"); glOrtho(-2.0, 2.0, -2.0, 2.0, -2.0, 2.0); glClearColor(1, 1, 1, 0); glutDisplayFunc(DibujaFiguras); glutKeyboardFunc(RotacionFigura); glutSpecialFunc(SeleccionFiguras); glutMainLoop(); return 0; } void DibujaFiguras() { glClear(GL_COLOR_BUFFER_BIT); glPushMatrix(); glRotatef(angulo, 1, 1, 1); glRotatef(45, 1, 1, 1); glColor3f(0.0,0.0,1.0);//Color de Figura switch(figura) { case 1: glutWireIcosahedron();break; case 2: glutWireTetrahedron();break; case 3: glutWireOctahedron();break; case 4: glutWireDodecahedron();break; } glPopMatrix(); glutSwapBuffers(); } void RotacionFigura(unsigned char tecla, int x, int y) { switch(tecla) { case s: case S: case 27: exit(0);break; case p: case P: angulo++;break; case n: case N: angulo--;break; 55

&RPSXWDFLyQ *UDILFD

} glutPostRedisplay(); } void SeleccionFiguras(int tecla, int x, int y) { switch(tecla) { case GLUT_KEY_F1 : figura=1;break; case GLUT_KEY_F2 : figura=2;break; case GLUT_KEY_F3 : figura=3;break; case GLUT_KEY_F4 : figura=4;break; } glutPostRedisplay(); }

56

/HRQHO &R\OD ,GPH

(MHPSOR //Rotacion de un Objeto 3D con ratn #include<GL/glut.h> #include<GL/glu.h> #include<GL/gl.h> #include<stdio.h> #include<stdlib.h> #define checkImageWidth 64 #define checkImageHeight 64 static GLubyte checkImage [checkImageHeight][checkImageWidth][4]; static GLuint texName; float angulo=0; int angulox=0,anguloy=0,x,y,xold,yold; char presionado; void mouse(int bouton,int estado,int x,int y); void texto(int x, int y, char *palabra); void makeCheckImage(void) { int i,j,c; glColor3f(1.0,1.0,1.0); for(i=0;i<checkImageHeight;i++){ for(j=0;j<checkImageWidth;j++){ c=((((i&0x8)==0)^((j&0x8))==0))*255; checkImage[i][j][0]=(GLubyte)c; checkImage[i][j][1]=(GLubyte)c; checkImage[i][j][2]=(GLubyte)c; checkImage[i][j][3]=(GLubyte)255; } } } void InicioOpenGL(void) { glClearColor(1.0,0.0,0.0,1.0); glShadeModel(GL_FLAT); glEnable(GL_DEPTH_TEST); glColor3f(1.0,0.0,1.0); makeCheckImage(); glPixelStorei(GL_UNPACK_ALIGNMENT,1); glGenTextures(1,&texName); glBindTexture(GL_TEXTURE_2D,texName); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST); glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,checkImageWidth,checkImageHeight,0,GL_ RGBA,GL_UNSIGNED_BYTE,checkImage);

} void Display(void) { 57

&RPSXWDFLyQ *UDILFD

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glRotatef(anguloy,1.0,0.0,0.0); glRotatef(angulox,0.0,1.0,0.0); glRotatef(angulo, 1, 0, 0); glRotatef(angulo, 0, 1, 0); glRotatef(angulo, 0, 0, 1); glEnable(GL_TEXTURE_2D); glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_DECAL); glBindTexture(GL_TEXTURE_2D,texName); glutSolidTeapot(1); glFlush(); glutSwapBuffers(); glDisable(GL_TEXTURE_2D); } void reshape(int w, int h) { glColor3f(1.0,1.0,0.0); glViewport(0,0,(GLsizei)w,(GLsizei)h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(60.0,(GLfloat)w/(GLfloat)h,1.0,30.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(0.0,0.0,-3.6); } void mouse(int button, int estado,int x,int y) { if (button == GLUT_LEFT_BUTTON && estado == GLUT_DOWN) { glutSetCursor(GLUT_CURSOR_CROSSHAIR); presionado = 1; xold = x; yold=y; } if (button == GLUT_LEFT_BUTTON && estado == GLUT_UP) { glutSetCursor(GLUT_CURSOR_INHERIT); presionado=0; } } void movimiento_mouse(int x,int y) { if (presionado) { angulox=angulox+(x-xold); anguloy=anguloy+(y-yold); glutPostRedisplay(); } xold=x; yold=y; } void texto(int x, int y,char *palabra){ int i;

58

/HRQHO &R\OD ,GPH

glColor3f(0,0,1); glRasterPos2f(x,y); for(i=0;palabra[i];i++) glutBitmapCharacter(GLUT_BITMAP_HELVETICA_12, palabra[i]); } int main(int argc, char **argv) { glutInit(&argc,argv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize(250,250); glutInitWindowPosition(100,100); glutCreateWindow(argv[0]); InicioOpenGL(); glutDisplayFunc(Display); glutReshapeFunc(reshape); glutMouseFunc(mouse); glutMotionFunc(movimiento_mouse); glutMainLoop(); return 0; }

59

&RPSXWDFLyQ *UDILFD

(MHPSOR // Tipos y tamaos de letra: glutBitmapCharacter #include <string.h> #include <stdio.h> #include <GL/glut.h> void bitmap_output(int x, int y, char *cadena, void *fuente) { int len, i; glRasterPos2f(x, y); len = (int) strlen(cadena); for (i = 0; i < len; i++) { glutBitmapCharacter(fuente, cadena[i]); } } void display(void) { glClear(GL_COLOR_BUFFER_BIT); glColor3f(0.0,0.0,0.0); bitmap_output(40, 40, "Universidad Nacional del Altiplano", GLUT_BITMAP_TIMES_ROMAN_24); glColor3f(0.0,0.0,1.0); bitmap_output(30, 140, "Facultad de Ingenieria Estadistica e Informatica", GLUT_BITMAP_9_BY_15); glColor3f(0.0,0.0,0.0); bitmap_output(70, 210, "Computacion Grafica.", GLUT_BITMAP_HELVETICA_18);

glFlush(); } void reshape(int w, int h) { glViewport(0, 0, w, h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0, w, 0, h); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); } int main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(580, 250);

60

/HRQHO &R\OD ,GPH

glutCreateWindow("Tipos de Letra"); glClearColor(1.0, 1.0, 1.0, 1.0); glutDisplayFunc(display); glutReshapeFunc(reshape); glutMainLoop(); return 0; }

Ejemplo: // Tipos de Letra glutStrokeCharacter #include <string.h> #include <stdio.h> #include <GL/glut.h> void stroke_output(GLfloat x, GLfloat y, char *cadena) { int len, i; glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(x, y, 0); glScalef(0.15, 0.15, 0.15); len = (int) strlen(cadena); for (i = 0; i < len; i++) { glutStrokeCharacter(GLUT_STROKE_ROMAN, cadena[i]); } } void display(void) { glClear(GL_COLOR_BUFFER_BIT); glColor3f(0.0,0.0,1.0); //Color de letras azul stroke_output(5, 10, "Universidad Nacional del Altiplano"); stroke_output(10, 90, "Computacion Grafica"); stroke_output(15, 180, "Universidad Nacional del Altiplano");

61

&RPSXWDFLyQ *UDILFD

glFlush(); } void reshape(int w, int h) { glViewport(0, 0, w, h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0, w, 0, h); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); } int main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(580, 250); glutInitWindowPosition(50, 100); glutCreateWindow("Tipos de Letra"); glClearColor(1.0, 1.0, 1.0, 1.0); glLineWidth(1.0); //grosor de letra de letra glutDisplayFunc(display); glutReshapeFunc(reshape); glutMainLoop(); return 0; }

62

/HRQHO &R\OD ,GPH

(MHPSOR //Escribe Texto utilizando glutBitmapCharacter #include <GL/glut.h> #define ancho 500 #define alto 375 #define profundidad 400 void EscribeTexto(); void texto(int x, int y, char *palabra); int main(int argc, char** argv) { glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowPosition(100, 0); glutInitWindowSize(500, 200); glutCreateWindow("Escribe Texto"); glOrtho(-80, 80, -80, 80, -2, 2); glClearColor(1, 1, 1, 0); glutDisplayFunc(EscribeTexto); glutMainLoop(); return 0; } void EscribeTexto() { glClear(GL_COLOR_BUFFER_BIT); texto(-70,50,"UNIVERSIDAD NACIONAL DEL ALTIPLANO - PUNO"); texto(-70,20,"Facultad de Ingenieria Estadistica e Informatica"); glutSwapBuffers(); } void texto(int x, int y, char *palabra) { int i; glColor3f(0.0,0.0,0.0); glRasterPos2f(x, y); for (i = 0; palabra[i]; i++) glutBitmapCharacter(GLUT_BITMAP_9_BY_15, palabra[i]); // glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18, palabra[i]); }

63

&RPSXWDFLyQ *UDILFD

862 '( 0(186 (1 2SHQ*/ OpenGL crea menus de tipo jerarquico y son activados cuando pulsamos uno de los botones del ratn (izquierdo, derecho y centro). glutCreateMenu(), se utiliza para crear un men y en ella es posible asociar una rutina cuando se llama.

glutAddMenuEntry(), se encarga de asociar ms opciones al men de primer nivel. glutAddSubMenu(), crea men de segundo nivel y se encar de conectar al primer nivel. glutAttachMenu(), se encarga de asociar al pulsar uno de los botones del ratn, mediante: GLUT_RIGHT_BUTTON GLUT_MIDDLE_BUTTON GLUT_CENTER_BUTTON

Ejemplo: #include <stdio.h > #include <stdlib.h > #include <GL/glut.h > enum { MENU_CHANGE = 1, MENU_EXIT }; static int color = 0; void MenuPrincipal(int identificador) { switch (identificador) { case MENU_CHANGE: color = (color == 0) ? 1: 0; glutPostRedisplay(); break; case MENU_EXIT: exit(0); break; } glutPostRedisplay(); } void Keyboard(unsigned char key, int x, int y) {

64

/HRQHO &R\OD ,GPH

switch (key) { case 27: exit(0); break; case c: case C: MenuPrincipal(MENU_CHANGE); break; } } int buildPopupMenu(void) { int menu = glutCreateMenu(MenuPrincipal); glutAddMenuEntry("Cambiar Color", MENU_CHANGE); glutAddMenuEntry("Salir", MENU_EXIT); return menu; } void DibujaTetera () { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); glTranslatef(0.0, 0.0, -4.0); if(color == 0) { glColor3f (1.0, 0.0, 0.0); //Color rojo glutWireTeapot(1.0); } else { glColor3f (0.0, 1.0, 0.0); //Color verde glutWireTeapot(1.0); } glutSwapBuffers(); } void resize (int w, int h) { glViewport(0, 0, w, h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(50., w/(double)h, 1., 10.); glMatrixMode(GL_MODELVIEW); } void InicioOpenGL (void) {

65

&RPSXWDFLyQ *UDILFD

glEnable(GL_DEPTH_TEST); } int main(int argc, char *argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(350, 350); glutInitWindowPosition(400, 300); glutCreateWindow("Aplicacion Menu"); InicioOpenGL(); glTranslatef(0.0, 0.0, -4.0); glutDisplayFunc(DibujaTetera); glutReshapeFunc(resize); glutKeyboardFunc(Keyboard); buildPopupMenu(); glutAttachMenu(GLUT_LEFT_BUTTON); glutMainLoop(); return 0; }

Cambiar el color de la tetera use el boton izquierdo del ratn o pulse la tecla c.

66

/HRQHO &R\OD ,GPH

,/80,1$&,21 La luz de escena que se realiza en OpenGL, proviene de varias fuentes de luz y estas son capaces de apagarse o encenderse. Se tiene los siguientes componentes: $PELHQWDO: La luz se dispersa en todas las direcciones. 'LIXVD Se encarga de reflejar la luz que le llega en todas las direcciones. (VSHFXODU Crea un brillo en una direccin definida. (PLWLGD: Simula luz emitida por un objeto. ,03/(0(17$&,1 '( /8&(6 GLfloat mat_specular[] = {1.0, 1.0, 1.0, 1.0} ; GLfloat mat_diffuse[] = {0.0, 1.0, 0.0, 1.0 } ; GLfloat mat_shininess[] = {50.0 }; GLfloat light_position[] = {1.0, 1.0, 1.0, 0.0 } ; glClearColor(0.0 , 0 . 0 , 0 . 0 , 0 . 0 ) ; glShadeModel (GL_SMOOTH) ; glMaterialfv(LFRONT, GL_SPECULAR , mat_specular ) ; glMaterialfv(GL_FRONT, GL_DIFFUSE , mat_diffuse) ; glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess) ; glLightfv(GL_LIGHT0, GL_POSITION , light_position) ; GLfloatlightcolor[] = {0.33, 0.33, 1.0, 1.0}; glLightfv(GL_LIGHT0, GL_DIFFUSE, light_color) ; glLightfv(GL_LIGHT0, GL_SPECULAR, light_color) ; glEnable(GL_LIGHTING ); //Activa el modelo de iluminacin. glEnable(GL_LIGHT0); //Activa la fuente de luz 0. )8(17(6 '( /8= Se tiene las siguientes propiedades: o Color o Posicin y o Direccin La funcin que usa estas propiedades es glLight*. El formato que usa este comando es: void glLight{if}[v](GLenum light, GLenum pname, TYPE param);

67

&RPSXWDFLyQ *UDILFD

en este formato existe la posibilidad de crear 8 fuentes de luz como mximo considerando la definicin estndar de la librera y estos son: */B/,*+7 */B/,*+7 */B/,*+7  */B/,*+7 '(),1,&,1 '( /$6 3523,('$'(6 '( /8=
120%5( '(/ 3$50(752 GL_AMBIENT GL_DIFFUSE GL_SPECULAR GL_POSITION GL_SPOT_DIRECTION GL_SPOT_EXPONENT GL_SPOT_CUTOFF GL_CONSTANT_ATTENUATION GL_LINEAR_ATTENUATION GL_QUADRATIC_ATTENUATION 9$/25 325 '()(&72 (0.0, 0.0, 0.0, 1.0) (1.0, 1.0, 1.0, 1.0) (1.0, 1.0, 1.0, 1.0) (0.0, 0.0, 1.0, 0.0) (0.0, 0.0, -1.0) 0.0 180.0 1.0 0.0 0.0 6,*1,),&$'2 Intensidad ambiente RGBA de la luz Intensidad difusa RGBA de la luz Intensidad especular RGBA de la luz Posicin (x,y,z,w) de la luz Direccin (x,y,z) del foco de luz Exponente del foco de luz Angulo del foco de luz Factor de atenuacin constante Factor de atenuacin lineal Factor de atenuacin cuadrtico

02'(/2 '( ,/80,1$&,1 OpenGL define tres componentes de iluminacin: o La intensidad de la luz en el ambiente global. o La posicin local del observador. o La forma de iluminar los objetos o polgonos. La intensidad de la luz ambiente se define mediante la siguiente funcin: Funcin JO/LJKW0RGHO con un parmetro */B/,*+7B02'(/B$0%,(17: GLfloat lmodel_ambiente [] = {0.2, 0.2, 0.2, 1.0}; glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambiente); La ubicacin o posicin del observador vara en los clculos de iluminacin especular y se ubica en el infinito. Para cambiar el observador y ubicarlo como local se utiliza la siguiente funcin: glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); Con sta funcin ubicamos el punto de vista para la iluminacin (0, 0, 0) y GL_FALSE se usa para colocar el observador en el infinito.

68

/HRQHO &R\OD ,GPH

'(),1,&,1 '( /$6 3523,('$'(6 '(/ 0$7(5,$/ En OpenGL antes de definir las luces debemos activar nuestros materiales, es ms se realiza esta operacin para cada polgono de la escena de tal forma que su respuesta incida sobre las superficies de los objetos. En OpenGL se definen estas propiedades mediante la funcin JO0DWHULDO* void glMaterial{if}[v](GLenum face, GLenum pname, TYPE param); El argumento GLenum face se usa para determinar la cara del objeto y en ella se aplica el material, y toma los siguientes valores */B)5217 */B%$&. o */B)5217B$1'B%$&.. El argumento GLenum pname se usa para asignar la propiedad del material que va a determinar estos valores se encuentra en la tabla. El argumento TYPE SDUDP se usa para asignar los valores a la caracterstica que vamos a definir en concreto en SQDPH. 120%5( '(/ 3$50(752 GL_AMBIENT GL_DIFFUSE GL_AMBIENT_AND_DIFFUSE GL_SPECULAR GL_SHININESS GL_EMISSION GL_COLOR_INDEXES (0.0, 0.0, 0.0, 1.0) 0.0 (0.0, 0.0, 0.0, 1.0) (0, 1, 1) 9$/25 325 '()(&72 (0.2, 0.2, 0.2, 1.0) (0.8, 0.8, 0.8, 1.0) 6,*1,),&$'2 Color ambiente del material Color difuso del material Color ambiente y difuso del material Color especular del material Exponente especular. Color de emisin del material ndices de color ambiente, difuso y especular

5HIOH[LyQ GLIXVD La reflexin difusa se utiliza para determinar el color del objeto.

5HIOH[LyQ DPELHQWH /a reflexin ambiente se utiliza para redistribuir la luz ambiente que recibe el objeto. 5HIOH[LyQ DPELHQWH \ GLIXVD Ambas reflexiones se usa para tener el mismo color en el objeto. 5HIOH[LyQ HVSHFXODU Se usa para determinar el color de los brillos del objeto y esto se controla con el parmetro. */B6+,1,1(66. 5HIOH[LyQ (PLVLyQ.- Se utiliza para asignar a los objetos un color de emisin y estas emiten luz de ese color.

69

&RPSXWDFLyQ *UDILFD

JO0DWUL[0RGH(modo): Esta funcin encarga de realizar transformaciones basadas en multiplicacin de matrices. GL_MODELVIEW: Define la matriz modelo-vista. GL_PROJECTION: Define la matriz de proyeccin. GL_TEXTURE: Define la matriz textura. JO9LHZSRUW[ \ DQFKR DOWR 'efine la porcin de ventana donde OpenGL podr dibujar una fugura. Donde: (x, y) es la esquina superior izquierda del viewport en coordenadas pantalla. (ancho, alto) corresponden a la anchura y altura del viewport deseado. &UHDFLyQ GH IXHQWHV GH OX] glEnable(GL_LIGHT0); Activa las fuentes de luz. glEnable(GL_LIGHTING); Activa los calculos de iluminacin

75$16)250$&,21(6 '( /$ 9,67$

void JOX/RRN$t( GLdouble eyex, eyey, eyez, GLdouble centerx, centery, centerz, GLdouble upx, upy, upz ); Donde: o Se usa para definir la matriz de vista y la multiplica por la derecha con la matriz actual. o La posicin del punto del ojo se especifica por eyex, eyey y eyez. o Para ubicar el centro de la escena se especifica por centerx, centery y centerz. o La direccin hacia arriba se indica por upx, upy y upz.

70

/HRQHO &R\OD ,GPH

//Iluminacion de una esfera #include <stdio.h> #include <stdlib.h> #include <GL/glut.h> GLfloat mat_diffuse [] = {0.5, 0.5, 0.5, 1.0}; GLfloat mat_specular [] = {0.5, 0.5, 0.5, 1.0}; GLfloat mat_shininess [] = {50}; void init (void) { GLfloat light_position[] = {1.0, 1.0, 1.0, 0.0}; glLightfv(GL_LIGHT0,GL_POSITION, light_position); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess); glEnable (GL_LIGHTING); glEnable (GL_LIGHT0); glDepthFunc(GL_LEQUAL); glEnable (GL_DEPTH_TEST); } void display (void) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glutSolidSphere(4.0,50,50); glutSwapBuffers(); } void reshape(int w, int h) { glViewport ( 0, 0, w, h ); glMatrixMode ( GL_PROJECTION ); glLoadIdentity ( ); if ( h==0 ) gluPerspective ( 60, ( float ) w, 1.0, 20.0 ); else gluPerspective ( 60, ( float ) w / ( float ) h, 1.0, 20.0 ); glMatrixMode ( GL_MODELVIEW ); glLoadIdentity ( ); gluLookAt(0.0,0.0,10.0,0.0,0.0,0.0,0.0,1.0,0.0); } void keyboard (unsigned char key, int x, int y) { switch (key) { case 27: exit (0); break;

71

&RPSXWDFLyQ *UDILFD

case f: case F: glutFullScreen (); break; case w: case W: glutReshapeWindow (250,250); break; default: break; } glutPostRedisplay(); } int main (int argc, char** argv) { glutInitDisplayMode (GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); glutInitWindowSize (250,250); glutInitWindowPosition (300,300); glutCreateWindow("Iluminacion Esfera"); init (); glutReshapeFunc(reshape); glutKeyboardFunc(keyboard); glutDisplayFunc(display); glutMainLoop(); return 0; }

72

/HRQHO &R\OD ,GPH

Funciones necesarias: JO0DWUL[0RGH(modo): Esta funcin encarga de realizar transformaciones basadas en multiplicacin de matrices. GL_MODELVIEW: Define la matriz modelo-vista. GL_PROJECTION: Define la matriz de proyeccin. GL_TEXTURE: Define la matriz textura. JO9LHZSRUW[ \ DQFKR DOWR 'efine la porcin de ventana donde OpenGL podr dibujar una figura. Donde: (x, y) es la esquina superior izquierda del viewport en coordenadas pantalla. (ancho, alto) corresponden a la anchura y altura del viewport deseado. &UHDFLyQ GH IXHQWHV GH OX] glEnable(GL_LIGHT0); Activa las fuentes de luz. glEnable(GL_LIGHTING); Activa los calculos de iluminacin

Ejemplo: //Dibuja una Tetera //Incluye proyeccion ortografica //Crea una fuente de luz y un material //Ubicamos la fuente de luz #include <stdlib.h> #include <GL/glut.h> void InicioOpenGL(void) { glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glDepthFunc(GL_LESS); glEnable(GL_DEPTH_TEST); glPolygonMode(GL_FRONT, GL_FILL); } void reshape(int w, int h) { if (!h) return; glViewport(0, 0, (GLsizei) w, (GLsizei) h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-100, 100, -100, 100, -100, 100); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); } void DibujaTetera(void) {

73

&RPSXWDFLyQ *UDILFD

//Ubicamos la fuente de luz GLfloat light_position[] = { 1.0, 1.0, 200.0, 0.0 }; glLightfv(GL_LIGHT0,GL_POSITION, light_position); //Propiedades del material GLfloat mat_ambient[] = { 0.25, 0.25, 0.25, 1.0 }; //Iluminacin global GLfloat mat_diffuse[] = { 1.0, 0.2, 0.2, 1.0 }; //Color de la tetera //Luz que incide hacia el objeto, se reflejado con un angulo GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat mat_shininess[] = { 20.0 }; //Aplicamos el material glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode( GL_MODELVIEW_MATRIX ); glLoadIdentity();

// Realiza la Rotacion en el eje x 30 grados glRotated(25.0, 1.0, 0.0, 0.0); // Realiza la Rotacion en el eje y -25 grados glRotated(-25.0, 0.0, 1.0, 0.0); // Realiza la Rotacion en el eje z -25 grados glRotated(-25.0, 0.0, 0.0, 1.0); glutSolidTeapot(60.0); glFlush(); } int main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); glutInitWindowSize (350, 350); glutInitWindowPosition (50, 50); glutCreateWindow ("Tetera"); InicioOpenGL(); glutDisplayFunc(DibujaTetera); glutReshapeFunc(reshape); glutMainLoop(); return 0; }

74

/HRQHO &R\OD ,GPH

En el ejemplo Ud. Puede manipular la posicin de la luz con las siguientes rdenes o de acuerdo a su necesidad: GLfloat light_position[] GLfloat light_position[] GLfloat light_position[] GLfloat light_position[] GLfloat light_position[] = {5.5, 0.5, 0.5, 1.0}; = {0.0, 0.0, 200.0, 1.0}; = {200.0, 0.0, 0.0, 1.0}; = {0.0, -200, 200.0, 1.0}; = {-200, 0.0, 200.0, 1.0};

Las ordenas mostraran el siguiente resultado:

75

&RPSXWDFLyQ *UDILFD

Para manipular el color del objeto podemos realizarlo con las siguientes rdenes: GLfloat mat_diffuse [] = {0.2, 0.2, 1.0, 1.0}; // azul GLfloat mat_diffuse [] = {0.2, 1.0, 0.2, 1.0}; //verder GLfloat mat_diffuse [] = {1.0, 0.2, 1.0, 1.0};// cian GLfloat mat_diffuse [] = {1.0, 0.2, 0.2, 1.0}; //rojo Teniendo los siguientes resultados:

76

/HRQHO &R\OD ,GPH

Para ver el tamao de luz podemos manipular las siguientes rdenes: GLfloat mat_shininess [] = {50}; GLfloat mat_shininess [] = {20}; GLfloat mat_shininess [] = {10}; GLfloat mat_shininess [] = {0};

77

&RPSXWDFLyQ *UDILFD

7(;785$ Una textura consiste en asignar una imagen de tipo bitmap (BMP), a un determinado polgono, de tal manera que se pueda ver una imagen dentro de este. Una textura puede ser tipo unidimensional, bidimensional y tridimensional. Se puede aplicar diferentes formas, como cubrir una superficie, modular el color de la superficie y mezclar el color de la textura. Por ejemplo, podemos construir una pared de ladrillo, y esto se realiza en un polgono y recubierto por una textura, de la siguiente forma:

&225'(1$'$6 '( 7(;785$ Una coordenada de textura se utiliza para saber el tamao de una imagen que se ubicara en un polgono, y estas se encuentran representadas por nmeros reales de 0 a 1, que lo representamos de la siguiente forma:

78

/HRQHO &R\OD ,GPH

(0,0)

(1,0)

(0,1) (0,0)

(1,1) (1,0)

(0,1)

(1,1)

Mapeado de textura

Para definir las coordenadas de texturas se utiliza: void JO7H[&RRUG{1234}{sifd}(TYPEcoords); void JO7H[&RRUG{1234}{sifd}Y(TYPE *coords); Para un rectngulo 2D las Coordinas de Textura son (0,0), (1,0), (1,1), (0,1).

Ejemplo: glBegin(GL_QUADS); glTexCoord2f(0.0, 0.0); glVertex3f(0.0, 0.0, 0.0); glTexCoord2f(1.0, 0.0); glVertex3f(5.0, 0.0, 0.0); glTexCoord2f(1.0, 1.0); glVertex3f(5.0, 5.0, 0.0); glTexCoord2f(0.0, 1.0); glVertex3f(0.0, 5.0, 0.0); glEnd();

79

&RPSXWDFLyQ *UDILFD

5(3(7,&,1 < ),-$&,1 '( 7(;785$6 Una textura es posible fijar haciendo un cambio en la propiedad GL_REPEAT por GL_CLAMP y lo mostramos en el siguiente cuadro:

80

/HRQHO &R\OD ,GPH

Ejemplo: #include<GL/glut.h> #include<GL/glu.h> #include<GL/gl.h> #include<stdio.h> #include<stdlib.h> #define checkImageWidth 64 #define checkImageHeight 64 static GLubyte checkImage [checkImageHeight][checkImageWidth][4]; static GLuint texName; float angulo=0; int angulox=0,anguloy=0,x,y,xanterior,yanterior; char presionado; void mouse(int bouton,int estado,int x,int y); void texto(int x, int y, char *palabra); void makeCheckImage(void) { int i,j,c; glColor3f(1.0,1.0,1.0); for(i=0;i<checkImageHeight;i++){ for(j=0;j<checkImageWidth;j++){ c=((((i&0x8)==0)^((j&0x8))==0))*255; checkImage[i][j][0]=(GLubyte)c; checkImage[i][j][1]=(GLubyte)c; checkImage[i][j][2]=(GLubyte)c; checkImage[i][j][3]=(GLubyte)255; } } } void InicioOpenGL(void) { glClearColor(1.0,0.0,0.0,1.0); glShadeModel(GL_FLAT); glEnable(GL_DEPTH_TEST); glColor3f(1.0,0.0,1.0); makeCheckImage(); glPixelStorei(GL_UNPACK_ALIGNMENT,1); glGenTextures(1,&texName); glBindTexture(GL_TEXTURE_2D,texName); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST) ; glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST); glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,checkImageWidth,checkImageHeigh t,0,GL_RGBA,GL_UNSIGNED_BYTE,checkImage);

81

&RPSXWDFLyQ *UDILFD

} void Display(void) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glRotatef(anguloy,1.0,0.0,0.0); glRotatef(angulox,0.0,1.0,0.0); glRotatef(angulo, 1, 0, 0); glRotatef(angulo, 0, 1, 0); glRotatef(angulo, 0, 0, 1); glEnable(GL_TEXTURE_2D); glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_DECAL); glBindTexture(GL_TEXTURE_2D,texName); glBegin(GL_QUADS); glTexCoord2f(0.0, 0.0); glVertex3f(-1.0, -1.0, glTexCoord2f(1.0, 0.0); glVertex3f( 1.0, -1.0, glTexCoord2f(1.0, 1.0); glVertex3f( 1.0, 1.0, glTexCoord2f(0.0, 1.0); glVertex3f(-1.0, 1.0,

1.0); 1.0); 1.0); 1.0);

glTexCoord2f(1.0, 0.0); glVertex3f(-1.0, -1.0, -1.0); glTexCoord2f(1.0, 1.0); glVertex3f(-1.0, 1.0, -1.0); glTexCoord2f(0.0, 1.0); glVertex3f( 1.0, 1.0, -1.0); glTexCoord2f(0.0, 0.0); glVertex3f( 1.0, -1.0, -1.0); glTexCoord2f(0.0, 1.0); glVertex3f(-1.0, glTexCoord2f(0.0, 0.0); glVertex3f(-1.0, glTexCoord2f(1.0, 0.0); glVertex3f( 1.0, glTexCoord2f(1.0, 1.0); glVertex3f( 1.0, 1.0, -1.0); 1.0, 1.0); 1.0, 1.0); 1.0, -1.0);

glTexCoord2f(1.0, 1.0); glVertex3f(-1.0, -1.0, -1.0); glTexCoord2f(0.0, 1.0); glVertex3f( 1.0, -1.0, -1.0); glTexCoord2f(0.0, 0.0); glVertex3f( 1.0, -1.0, 1.0); glTexCoord2f(1.0, 0.0); glVertex3f(-1.0, -1.0, 1.0); glTexCoord2f(1.0, 0.0); glVertex3f( 1.0, -1.0, -1.0); glTexCoord2f(1.0, 1.0); glVertex3f( 1.0, 1.0, -1.0); glTexCoord2f(0.0, 1.0); glVertex3f( 1.0, 1.0, 1.0); glTexCoord2f(0.0, 0.0); glVertex3f( 1.0, -1.0, 1.0); glTexCoord2f(0.0, 0.0); glVertex3f(-1.0, -1.0, -1.0); glTexCoord2f(1.0, 0.0); glVertex3f(-1.0, -1.0, 1.0); glTexCoord2f(1.0, 1.0); glVertex3f(-1.0, 1.0, 1.0); glTexCoord2f(0.0, 1.0); glVertex3f(-1.0, 1.0, -1.0); glEnd(); glFlush(); texto(-1,2,"Presion el Boton izquierdo del Mouse y mover"); glutSwapBuffers(); glDisable(GL_TEXTURE_2D); }

82

/HRQHO &R\OD ,GPH

void reshape(int w, int h) { glColor3f(1.0,1.0,0.0); glViewport(0,0,(GLsizei)w,(GLsizei)h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(60.0,(GLfloat)w/(GLfloat)h,1.0,30.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(0.0,0.0,-3.6); } void keyboard(unsigned char key, int x, int y){ switch(key) { case s: case S: case 27: exit(0); break; casef: caseF: glutFullScreen(); break; case w: case W: glutReshapeWindow(250,250); break; default: break; } glutPostRedisplay(); } void mouse(int button, int estado,int x,int y) { if (button == GLUT_LEFT_BUTTON && estado == GLUT_DOWN) { glutSetCursor(GLUT_CURSOR_CROSSHAIR); presionado = 1; xanterior = x; yanterior=y; } if (button == GLUT_LEFT_BUTTON && estado == GLUT_UP) { glutSetCursor(GLUT_CURSOR_INHERIT); presionado=0; } } void movimiento_mouse(int x,int y) { if (presionado) { angulox=angulox+(x-xanterior); anguloy=anguloy+(y-yanterior); glutPostRedisplay();

83

&RPSXWDFLyQ *UDILFD

} xanterior=x; yanterior=y; } void texto(int x, int y,char *palabra){ int i; glColor3f(0,0,1); glRasterPos2f(x,y); for(i=0;palabra[i];i++) glutBitmapCharacter(GLUT_BITMAP_HELVETICA_12, palabra[i]); } int main(int argc, char **argv) { printf( "\n\nUNIVERSIDAD NACIONAL DEL ALTIPLANO" ); printf( "\nCurso: Computacion Grafica"); glutInit(&argc,argv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize(300,300); glutInitWindowPosition(150,150); glutCreateWindow(argv[0]); InicioOpenGL(); glutDisplayFunc(Display); glutReshapeFunc(reshape); glutMouseFunc(mouse); glutMotionFunc(movimiento_mouse); glutKeyboardFunc(keyboard); glutMainLoop(); return 0; }

84

/HRQHO &R\OD ,GPH

'HY&
Es un Software libre y es conocido como un entorno integrado de desarrollo (IDE) y es utilizado en los lenguajes de programacin C y C++. Caractersticas Principales: o Administrador de proyectos. o Incluye un editor con marcador de sintaxis. o Adems tiene un soporte de compiladores en GCC. 352<(&726 Dev-C++, en un proyecto agrupa todos los archivos que son de tipo cdigo fuente y que pertenezcan a una aplicacin. Por ejemplo: proyecto.dev, en ella se encuentra el archivo de configuracin de nuestro proyecto. main.cpp llamado tambin como el archivo proyecto.cpp &5($&,1 '( 81 352<(&72 Utilizamos como ejemplo la siguiente ventana:

85

&RPSXWDFLyQ *UDILFD

En esta ventana se observa varias plantillas de aplicacin y con ellas podemos crear un proyecto. Para nuestro caso seleccionamos &RQVROH $SSOLFDWLRQ y Ok

Escribimos el nombre del proyecto, lo ubicamos en el disco y en la carpeta deseada. Como respuesta tendremos la siguiente ventana:

86

/HRQHO &R\OD ,GPH

Se muestra en la ventana derecha un pequeo cdigo para iniciar con el trabajo de aplicacin.

Luego seleccionamos la opcin Nuevo Cdigo Fuente o New File y esto lo mostramos en el siguiente grafico:

87

&RPSXWDFLyQ *UDILFD

Una vez escrito el cdigo fuente de cualquier programa con aplicacin de tipo OpenGL, de la forma:

88

/HRQHO &R\OD ,GPH

&21),*85$&,21 '( 352<(&726 Se utiliza para cambiar la configuracin del compilador, agregando en ella las libreras graficas a utilizar y otras opciones necesarias para el funcionamiento de OpenGL.

En el grafico que se muestra a continuacin escriba el contenido de la opcin /LQNHU

89

&RPSXWDFLyQ *UDILFD

'(385$&,21 Con finalidad de generar la informacin de depuracin, es necesario cambiar la configuracin del proyecto de la forma:

Con esta configuracin, no creamos una ventana de consola y adems generamos la ventana de depuracin.

&202 ,167$/$5 /$6 /,%5(5,$6 (1 'HYF"

Headers: (glut.h; glu.h; gl.h; glaux.h) En: C:\ C:\Dev-Cpp\include\GL DLLs: (glut.dll; glu.dll; glut32-dll; glu32.dll) En: C:\WINDOWS\system32 LIBs: (glu.lib; glu32.lib, glut32.lib, glaux.lib) En: C:\Dev-Cpp\lib

90

/HRQHO &R\OD ,GPH

86$1'2 'HY3DN GH */87 2SHQ*/ \ 'HY&

Para tener una mejor respuesta con las librerias de OpenGL en Dev-C++ debemos realizar la instalacin del DevPak de GLUT. Para ello debemos tener instalado el DevC++, utilizando como sistema operativo el Windows. Adems debemos tener archivo DevPack de GLUT o bajarlo de www.nigels.com, para luego instalarlo de la siguiente forma: 1. Como se muestra en el grfico es necesrio ir al al men Tools y seleccionar Package Manager.

En la ventana que se muestra a continuacin, seleccione install y luego DevPack

91

&RPSXWDFLyQ *UDILFD

Luego de abrir, seleccione install de la ventana que se muestra:

Finalmente haga clic en Finish:

92

/HRQHO &R\OD ,GPH

Una vez instalado el Dev-C++ Pack Podemos realizar la configuracin necesaria para que pueda funcionar correctamente el Dev-C++ con OpenGL y para ello es necesario hacer una configuracin en opciones del compilador:

Aadir estos comandos en la ventana de linker: -lglut32 -lglu32 -lopengl32 -lwinmm lgdi32 -lm

93

&RPSXWDFLyQ *UDILFD

Una vez realizado todas estas operaciones ya estamos listos para trabajar con GLUT.

Podemos hacer una prueba con el siguiente ejemplo:

#include <GL/glut.h> void MiPrimerEjemplo(){ glClear(GL_COLOR_BUFFER_BIT); glBegin(GL_TRIANGLES); glVertex2f(-0.5, -0.5); glVertex2f(-0.5, 0.5); glVertex2f(0.5, 0.5); glEnd(); glFlush(); } int main(int argc, char** argv){ glutCreateWindow("Triangulo"); glutDisplayFunc(MiPrimerEjemplo); glutMainLoop(); } Como resultado tendremos la siguiente ventana:

94

/HRQHO &R\OD ,GPH

(MHPSOR //Geometra Fractal #include <windows.h> #include <GL/glut.h> void InicioOpenGL(void) { glClearColor(1.0, 1.0, 1.0, 1.0); glColor3f(0.0, 0.0, 1.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(-100.0, 600.0, -100.0, 600.0); glMatrixMode(GL_MODELVIEW); } void display( void ) { typedef GLfloat punto2d[2]; punto2d vertices[3]={{0.0,500.0},{500.0,500.0},{250.0,0.0}}; int i, h; punto2d p ={50.0,75.0}; glClear(GL_COLOR_BUFFER_BIT); for(h = 0; h < 4000; h++) { i = rand() % 3; p[0] = (p[0] + vertices[i][0])/ 2.0; p[1] = (p[1] + vertices[i][1])/ 2.0;

//Triangulo

95

&RPSXWDFLyQ *UDILFD

glBegin(GL_POINTS); glVertex2fv(p); glEnd(); } glFlush(); } int main(int argc, char** argv) { glutInit(&argc,argv); glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(500,500); glutInitWindowPosition(300,200); glutCreateWindow("Geometra Fractal"); glutDisplayFunc(display); InicioOpenGL(); glutMainLoop(); }

96

/HRQHO &R\OD ,GPH

OpenGL EN UBUNTU

GNU/linux y Ubuntu

97

&RPSXWDFLyQ *UDILFD

PRACTICAS: 1.- Escriba la descripcin de cada una de las siguientes ordenes: Parmetro Descripcin GLUT_DEPTH GLUT_DOUBLE GLUT_RGB 2.- Escriba dos comando equivalentes de OpenGL

3.- Escriba el formato y escriba un ejemplo del comando Ortho()

4.- Escriba la orden para dibujar 4 puntos en forma de un cuadrado. Utilice primitivas, considerando el formato Ortho de la pregunta anterior.

5.- Escriba la orden de los siguientes colores: Color Funcin Amarillo Azul Blanco Cian 6.- Escriba las rdenes que debe tener la ventana de Linker Dev-C++

7.- Describa los parmetros del mandato glutInitWindowSize() Parmetro Descripcin

8.-Qu entiende por Rendering?

9.- Que realiza la siguiente orden glutMainLoop(); 10.- Escriba el formato de dos lneas: Estilo de lnea

Descripcin

98

/HRQHO &R\OD ,GPH

Practica
1.- Escriba el formato general del mandato glTranslatef.

2.- Escriba la definicin de los siguientes mandatos: glVertex3i glColor3i 3.- Cual es la matriz que al trasladar un objeto dos unidades en el eje X se genera una matriz de transformacin:

4.- El punto (1,2,3) es traducido en OpenGL al punto:

5.- Cuales son los mandatos principales en OpenGl, para que se pueda cumplir una transformacin 3D Parmetro Descripcin

6.- Escriba 4 primitivas de objetos en 3D

7.- Escriba el formato de proyeccin ortogrfica y escriba un ejemplo con datos reales:

8.- Con que tipo de coordenadas trabaja OpenGL para desarrollar grficos.

9.- Que funcin cumple la siguiente orden glLineWidth(3.0);

10.- Realice un programa para graficar la funcin seno.

99

&RPSXWDFLyQ *UDILFD

100