Está en la página 1de 12

LABORATORIO DE SINTEXIS DE GRAFICOS POR ORDENADOR

PRACTICA 1:

INTRODUCCION A OPENGL Y SUS PRIMITIVAS.

Profesor: Atilano Belinchn Serrano

INDICE 1. OBJETIVO.......................................................................3 2. CONCEPTOS PREVIOS.....................................................3 2.1. Introduccin a un contexto OpenGL..............................3 2.2. Primitivas: Puntos, lneas y polgonos...........................5 3. DESARROLLO DE LA PRACTICA.......................................11 3.1. Definicin del eje de coordenadas..............................11 3.2. Dibujo de polgonos bsicos.......................................11 3.3. Asignacin de colores e interceptacin de eventos de teclado.......................................................................11 3.4. Interceptacin de eventos de ratn............................12 4. DURACION....................................................................12 5. DOCUMENTACION DE ENTREGA......................................12

Pgina 2 de 12

1. OBJETIVO
El objetivo de esta prctica, es que el alumno se familiarice con OpenGL y sus primitivas, as como con el entorno de desarrollo de este laboratorio (Linux, GLUT, gcc, ).

2. CONCEPTOS PREVIOS.
Esta seccin servir como introduccin de los conceptos fundamentales para el desarrollo de programas en OpenGL, y nos permitir obtener un marco de trabajo til para las secciones posteriores.

2.1. Introduccin a un contexto OpenGL.


La primera parte puede parecer trivial, pero cmo es posible tener un programa en OpenGL sin abrir una ventana que lo contenga?. Sabemos que OpenGL contiene comandos para dibujo pero se dise para tener independencia de los sistemas operativos, por lo que no tiene comandos para abrir ventanas, ni para leer eventos de teclado y/o mouse. Para ello, se usa a GLUT (GL Utility Toolkit), cuyas instrucciones comienzan con el prefijo glut. La inicializacin de una ventana en OpenGL requiere 5 rutinas bsicas: glutInit(int *argc, char **argv) se encarga de inicializar a GLUT, y debe ser llamada antes de cualquier otra rutina GLUT. glutInitDisplayMode(unsigned int mode) especifica si se usar un modelo RGB o uno basado en ndices; se puede tambin especificar si se trata de modelos de buffer sencillo o doble, y finalmente puede asociarse a otros buffers como son el stencil o la profundidad. glutInitWindowPosition(int x, int y) especifica la ubicacin en la pantalla de la esquina superior izquierda de nuestra ventana. glutInitWindowSize(int x, int y) especifica el tamao (en pxeles) de nuestra ventana. glutCreateWindow (char *string) se encarga de crear la ventana con un contexto OpenGL. Nota: hasta que la funcin glutMainLoop() es llamada, la pantalla no se despliega.

Ej: /* Ejemplo1: Creacin un contexto OpenGL con GLUT */

Pgina 3 de 12

#include <GL/glut.h> /* glut.h garantiza que gl.h y glu.h se incluyan */ #include <stdio.h> /* Ya que muchas aplicaciones en OpenGL hacen uso de C, es comn incluir estos headers */ #include <stdlib.h> void init (void) { glEnable (GL_DEPTH_TEST); glClearColor (0.0, 0.0, 0.0, 0.0); } void display (void) { glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); } void reshape(int w, int h) { glViewport ( 0, 0, w, h ); glMatrixMode ( GL_PROJECTION ); glLoadIdentity ( ); if ( h==0 ) gluPerspective ( 80, ( float ) w, 1.0, 5000.0 ); else gluPerspective ( 80, ( float ) w / ( float ) h, 1.0, 5000.0 ); glMatrixMode ( GL_MODELVIEW ); glLoadIdentity ( ); } void keyboard (unsigned char key, int x, int y) { switch (key) { case 27: /* tecla de Escape */ exit (0); break; case 'f': glutFullScreen (); break; case 'w': glutReshapeWindow (250,250); break; default: break; } } /* Ciclo principal * Abre una ventana con tamao inicial definido, barra de titulo, * modo RGB, y control de eventos */ int main (int argc, char** argv) { glutInit (&argc, argv); glutInitDisplayMode (GLUT_RGB | GLUT_DOUBLE); glutInitWindowSize (250,250); glutInitWindowPosition (100,100); glutCreateWindow ("Mi primera ventana de OpenGL"); init (); /* llamada a inicializacion*/ glutReshapeFunc (reshape); /* llamada para eventos de reshape de ventana*/
Pgina 4 de 12

glutKeyboardFunc (keyboard); glutDisplayFunc (display); glutMainLoop (); return 0; }

/* llamada para eventos de kbd*/ /* llamada para dibujar...*/ /* Crea la ventana y dibuja...*/

2.2. Primitivas: Puntos, lneas y polgonos.


En OpenGL, las primitivas geomtricas son usadas para realizar los dibujos que deseamos. Las primitivas son: puntos, lneas y polgonos. Estas primitivas se describen bsicamente a partir de sus vrtices -las coordenadas que definen al punto como tal, los extremos de los segmentos de lnea y las esquinas de los polgonos-. En un sentido matemtico, la definicin de las primitivas mencionadas es relativamente simple, y en OpenGL se trabaja en un contexto similar, siendo diferente en slo lo relativo a la implementacin como tal. Las diferencias incluyen la precisin de los valores y error de redondeo, factores que influyen en las coordenadas en OpenGL, y las limitaciones del raster graphics display, cuya unidad mnima (pxel) es mucho mayor del concepto de matemtico de infinitamente pequeo (para un punto) o infinitamente delgado (para una lnea). OpenGL se refiere a los puntos como un vector, manejado como un nmero de punto flotante, pero ello no implica que la precisin sea de un 100% en el momento de dibujar. Puntos: Se trata de nmeros de punto flotante llamados vertex. Todos los clculos que se involucran se realizan con vectores tridimensionales, y si no se define la coordenada Z (como en un dibujo de 2D), se asume un valor de cero. Lneas: Las lneas en OpenGL son en realidad segmentos de recta, y no el concepto de una extensin al infinito como ocurre en matemticas. Los vrtices definen los puntos extremos de cada segmento. Polgonos: Son las reas encerradas por un lazo cerrado de segmentos de recta, con los vrtices indicando los extremos de los segmentos que le forman. Por omisin, los polgonos se dibujan rellenos al interior. Nota: Hay funciones avanzadas, que no se vern por el momento, que permiten tener polgonos "huecos", o definidos slo como vrtices en sus esquinas, colores distintos para una cara que para la otra, etc. Es importante comprender que debido a la complejidad posible de los polgonos, es necesario definir restricciones: Las orillas no pueden intersectar Slo es vlido tener polgonos convexos, es decir, polgonos que cumplen la norma de regiones convexas (una regin es convexa si dados cualesquiera dos puntos en sus interior, el segmento que los une est tambin en el interior).
Pgina 5 de 12

El no respetar las restricciones no garantiza que el dibujo resulte como se espera. La restriccin se debe a que es ms sencillo tener hardware rpido para polgonos simples. Nota: debido a que se trata de vrtices 3D, es necesario tener cuidado ya que despus de algunas operaciones, si algn vrtice no est en el mismo plano, puede llegarse a resultados inesperados. El usar tringulos garantiza que siempre se trabaja en un mismo plano. Definicin de los vrtices: glVertex{1234}{sifd}[v](TYPE coords) Donde las coordenadas posibles son 1,2,3 4, y los tipos de datos son sufijos de tipo:

Sufi Tipo de datos jo b s i f d Ub Us Ui Entero 8 bits Entero 16 bits Entero 32 bits Real 32 bits Real 64 bits

Tipo de Datos Definicin de tipo en C OpenGL signed char short long float double GLbyte GLshort GLint, GLsizei GLfloat, GLclampf GLdouble, GLclampd GLubyte,GLboolean

Entero sin signo 8 unsigned char bits

Entero sin signo 16 unsigned short GLushort bits Entero sin signo 32 unsigned long bits GLuint,GLenum,GLbitf ield

Ejemplos: glVertex2s (2, 3); glVertex3d (0.0, 0.0, 3.1415926536898) GLdouble dvect[3] = {5.0, 9.0, 1992.0); glVertex3dv (dvect);

Pgina 6 de 12

EJ2:
/* Ejemplo 2. Primitivas en OpenGL */ #include <GL/glut.h> #include <stdio.h> #include <stdlib.h> void init ( void ) { glEnable ( GL_DEPTH_TEST ); glClearColor ( 0.0, 0.0, 0.0, 0.0 ); } void display ( void ) { glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glPushMatrix ( ); glColor4f ( 1.0, 1.0, 1.0, 1.0 ); glTranslatef(-1.5f,0.0f,-7.0f); glBegin(GL_TRIANGLES); // Dibujar usando tringulos glVertex3f( 0.0f, 1.0f, 0.0f); // Arriba glVertex3f(-1.0f,-1.0f, 0.0f); // Abajo Izq. glVertex3f( 1.0f,-1.0f, 0.0f); // Abajo Der.
Pgina 7 de 12

glEnd(); glTranslatef(3.0f,0.0f,0.0f); glBegin(GL_QUADS); glVertex3f(-1.0f, 1.0f, 0.0f); glVertex3f( 1.0f, 1.0f, 0.0f); glVertex3f( 1.0f,-1.0f, 0.0f); glVertex3f(-1.0f,-1.0f, 0.0f); glEnd(); glPopMatrix ( ); glutSwapBuffers ( ); } void reshape(int w, int h) { glViewport ( 0, 0, w, h ); glMatrixMode ( GL_PROJECTION ); glLoadIdentity ( ); if ( h==0 ) gluPerspective ( 80, ( float ) w, 1.0, 5000.0 ); else gluPerspective ( 80, ( float ) w / ( float ) h, 1.0, 5000.0 ); glMatrixMode ( GL_MODELVIEW ); glLoadIdentity ( ); } void keyboard ( unsigned char key, int x, int y ) { switch ( key ) { case 27: /* tecla de Escape */ exit ( 0 ); break; case 'f': glutFullScreen ( ); break; case 'w': glutReshapeWindow ( 250,250 ); break; default: break; } } /* Ciclo principal * Abre una ventana con tamao inicial definido, barra de titulo, * modo RGBA, y control de eventos. */ int main ( int argc, char** argv ) { glutInit (&argc, argv); glutInitDisplayMode (GLUT_RGB | GLUT_DOUBLE); glutInitWindowSize (250,250); glutInitWindowPosition (100,100); glutCreateWindow ("Primitivas en OpenGL"); init ( ); glutReshapeFunc ( reshape ); glutKeyboardFunc ( keyboard ); glutDisplayFunc ( display );

// Termina de dibujar tringulo // Dibuja cuadrado // Arriba Izq. // Arriba Der. // abajo Der. // Abajo Izq.

Pgina 8 de 12

glutMainLoop return 0; }

( );

Obteniendo como resultado del programa anterior

Realizando unas pequeas modificaciones sobre el cdigo anterior, asignaremos color a los poligonos representados en la anterior ventana

EJ3:
/* Ejemplo 3. Primitivas en OpenGL */ #include <GL/glut.h> #include <stdio.h> #include <stdlib.h> void init ( void ) { glEnable ( GL_DEPTH_TEST ); glClearColor ( 0.0, 0.0, 0.0, 0.0 ); } void display ( void ) { glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glPushMatrix ( ); glTranslatef(-1.5f,0.0f,-7.0f); glBegin(GL_TRIANGLES); // Dibujar usando tringulos glColor3f(1.0f,0.0f,0.0f); // Color Rojo glVertex3f( 0.0f, 1.0f, 0.0f); // Arriba glColor3f(0.0f,1.0f,0.0f); // Color Verde glVertex3f(-1.0f,-1.0f, 0.0f); // Abajo Izq.
Pgina 9 de 12

glColor3f(0.0f,0.0f,1.0f); glVertex3f( 1.0f,-1.0f, 0.0f); glEnd(); glTranslatef(3.0f,0.0f,0.0f); glBegin(GL_QUADS); glColor3f(0.2f,0.2f,1.0f); glVertex3f(-1.0f, 1.0f, 0.0f); glVertex3f( 1.0f, 1.0f, 0.0f); glVertex3f( 1.0f,-1.0f, 0.0f); glVertex3f(-1.0f,-1.0f, 0.0f); glEnd(); glPopMatrix ( ); glutSwapBuffers ( ); } void reshape(int w, int h) { glViewport ( 0, 0, w, h ); glMatrixMode ( GL_PROJECTION ); glLoadIdentity ( ); if ( h==0 ) gluPerspective ( 80, ( float ) w, 1.0, 5000.0 ); else gluPerspective ( 80, ( float ) w / ( float ) h, 1.0, 5000.0 ); glMatrixMode ( GL_MODELVIEW ); glLoadIdentity ( ); } void keyboard ( unsigned char key, int x, int y ) { switch ( key ) { case 27: /* tecla de Escape */ exit ( 0 ); break; case 'f': glutFullScreen ( ); break; case 'w': glutReshapeWindow ( 250,250 ); break; default: break; } } /* Ciclo principal * Abre una ventana con tamao inicial definido, barra de titulo, * modo RGBA, y control de eventos. */ int main ( int argc, char** argv ) { glutInit (&argc, argv); glutInitDisplayMode (GLUT_RGB | GLUT_DOUBLE); glutInitWindowSize (250,250); glutInitWindowPosition (100,100); glutCreateWindow ("Primitivas en OpenGL"); init ( );

// Color Azul // Abajo Der. // Termina de dibujar tringulo // Dibuja cuadrado // Azul.. una sola vez // Arriba Izq. // Arriba Der. // abajo Der. // Abajo Izq.

Pgina 10 de 12

glutReshapeFunc ( reshape ); glutKeyboardFunc ( keyboard ); glutDisplayFunc ( display ); glutMainLoop ( ); return 0; }

El resultado del cdigo anterior.

3. DESARROLLO DE LA PRACTICA. 3.1. Definicin del eje de coordenadas.


En la ventana del rea de trabajo, dibujar los ejes de coordenadas X, Y, Z con lneas discontinuas.

3.2. Dibujo de polgonos bsicos


En el espacio tridimensional creado, dibujar un tringulo, un cuadrado y un circulo utilizando primitivas de OpenGL.

3.3. Asignacin de colores e interceptacin de eventos de teclado.


Asignar colores a los polgonos y modificar estos al pulsar en el teclado los caracteres: 1 Modificar el color asignado al crculo.
Pgina 11 de 12

2 3

Modificar el color del tringulo. Modificar el color del cuadrado.

3.4. Interceptacin de eventos de ratn.


Modificar el tamao de los polgonos creados de forma que aumenten su tamao al pulsar el botn derecho y disminuyan su tamao al pulsar el botn izquierdo.

4. DURACION.
La duracin de la prctica 1, ser de tres sesiones de laboratorio.

5. DOCUMENTACION DE ENTREGA.
Se entregar una memoria sobre la prctica, donde se comenten las principales funciones utilizadas en la prctica y su funcionamiento. As mismo, se entregar un disquete con los cdigos fuentes C de la practica y los makefiles utilizados para la compilacin de estos.

Pgina 12 de 12