Sistemas Operativos

ndice

Universidad Politcnica de Juventino Rosas

INTRODUCCIN.......................................................................1
MARCO TERICO.....................................................................2
-

Qu es OpenGL?.....................................................................2

Desarrollo de aplicaciones OpenGL............................................2

GLUT o FreeGLUT......................................................................3
GLU Y GLUT..............................................................................3
Formato de las funciones..........................................................3
Funciones bsicas para definir objetos......................................3
Espacio 3D...............................................................................4
Instalacin...............................................................................5
Llamado de la librera...............................................................5
Compilacin.............................................................................5

DESARROLLO..........................................................................6
-

Cdigo y funciones...................................................................6

RESULTADOS.........................................................................11
CONCLUSIONES.....................................................................11
BIBLIOGRAFIA.......................................................................11

INTRODUCCIN
En este reporte se describe la realizacin de la prctica final de la materia de
Sistemas Operativos, la cual consiste en el desarrollo de un juego de ping-pong,
para dos jugadores desde computadoras individuales.
Para esta practica se aplicaran todos los conocimientos adquiridos durante el
curso, como es: el uso del lenguaje de programacin C++, la librera de grficos
OpenGL, implementacin de hilos y la comunicacin mediante sockets.
OpenGL es una librera grafica escrita originalmente en C, permite la manipulacin
de grficos 3D a todos los niveles. Se concibi para programar en mquinas
nativas Silicon Graphics bajo el nombre de GL (Graphics Library). Se extendi a
cualquier tipo de plataforma y asegurar as su portabilidad y extensibilidad de uso
con que se lleg al trmino Open Graphics Library (OpenGL).
La librera se ejecuta a Ia par con nuestro programa independientemente de Ia
capacidad grafica de Ia mquina que usamos. Esto significa que Ia ejecuci6n se
clara por software a no ser que contemos con hardware grafico especfico en
nuestra mquina. Si contamos con tarjetas aceleradoras de video, tecnologa
MMX, aceleradoras 3D, pipelines grficos implementados en placa, etc. por
supuesto gozaremos de una ejecucin ms rpida en tiempo real.
As la librera puede usarse bajo todo tipo de sistemas operativos e incluso una
gran variedad de lenguajes de programacin.

MARCO TERICO
-

Qu es OpenGL?

OpenGL significa Graphic Library, lo cual significa que es una librera que se utiliza
en lenguajes de programacin, consiste en aceptar primitivas tales como puntos,
lneas y polgonos y convertirlas en pixeles. Consiste, adems, en 150 comandos
diferentes para especificar los objetos y operaciones necesarias para crear
aplicaciones 3D interactivas. El proceso es realizado por una pipeline grfica
conocida como Maquina de estados de OpenGL.
Aunque OpenGL est concebido para disear aplicaciones interactivas y facilita al
usuario herramientas como la seleccin sus capacidades resultan insuficientes
para, entre otras cosas, crear interfaces grficas con un grado mayor de
interactividad. Estas limitaciones condujeron al desarrollo de las libreras AUX y
GLUT. Las libreras AUX presentan numerosas insuficiencias, y su aplicacin se
limita a programas de simple enseanza.
La librera GLUT en cambio, tiene mayor funcionalidad para la manipulacin
interactiva de objetos 3D.
GLUT es un interfaz de programacin con "C" ANSI y Fortran para escribir
programas en OpenGL que sean independientes del sistema operativo de
ventanas. Las libreras GLUT ofrecen algunas ventajas como, varios dispositivos
de entrada, mens desplegables, entre otras.

Desarrollo de aplicaciones OpenGL.

Cuando se desarrollan operaciones OpenGL bajo Linux, es necesario el uso

de las siguientes herramientas:
Los binarios de la librera OpenGL, ya sea Mesa (compilado e instalado a
partir del cdigo fuente), xlibmesa (incluido con Xfree86 4 y posteriores) o
drivers propios.
Los paquetes de desarrollo de estas libreras (xlibmesa-dev, en el caso de
xlibmesa, glutg3-dev... para drivers propios depender del fabricante, y para
Mesa, si se ha instalado compilando el cdigo fuente, no debera de haber
problemas).
Un compilador del lenguaje en el que vamos a programar, en este caso, en
C, para lo que usaremos el compilador gcc, y g++ si utilizamos C++.
Un editor de texto, ya sea en modo consola, o bajo el entorno X Windows (a
m me gusta el Kate de KDE, pero cada cual tiene sus preferencias).

GLUT o FreeGLUT

FreeGLUT es una librera que surgi en un principio para mejorar algunos

aspectos de GLUT. Actualmente es un reemplazo total de esta. FreeGLUT tiene
una versin ms estable desde el ao 2009.

GLU Y GLUT

La librera GLU contiene funciones graficas de ms alto nivel, que permiten

realizar operaciones ms complejas.
La librera GLUT es un paquete auxiliar para construir aplicaciones de ventanas,
adems de incluir algunas primitivas geomtricas auxiliares. La ventaja de este
paquete es que el mismo cdigo nos servir en Windows y en Linux, adems de
simplificar mucho el cdigo fuente del programa.

Formato de las funciones

Los nombres de las funciones en estas libreras siguen la siguiente convencin:

{gl, glu, glut} <un nombre> [{d, f, u, etc.}] [v]
El prefijo gl indica que se trata de una funcin de la librera de OpenGL, el prefijo
glu de una funcin de la librera GLU, y el prefijo glut es para las funciones de la
GLUT.

Funciones bsicas para definir objetos

Se pueden dibujar puntos, lneas y polgonos, para esto se define un punto en el

espacio 3D, utilizando la funcin glVertex3f(x,y,z).

Fig. 1
Operaciones bsicas para definir objetos.

Algunos objetos ya vienen definidos, as que disponemos de las siguientes

funciones:
glutWireSphere(radius, slices, stacks), glutSolidSphere(radius, slices,
stacks)
glutWireCube(size), glutSolidCube(size)
glutWireCone(base, height, slices, stacks), glutSolidCone(base, height,
slices, stacks)
glutWireDodecahedron(void), glutSolidDodecahedron(void)
glutWireOctahedron(void), glutSolidOctahedron(void)
glutWireTetrahedron(void), glutSolidTetrahedron(void)
glutWireIcosahedron(void), glutSolidIcosahedron(void)
glutWireTeapot(void), glutSolidTeapot(void)

Fig. 2
Ejemplos de las funciones.

En cuanto a la funcin de color se utiliza glColor3f(r, g, b). El valor de r, g y b

debe de estar entre 0 y 1.

Espacio 3D

OpenGL proporciona acceso a funciones de dibujado 2D y tambin en espacio 3D.

OpenGL trabaja a grandes rasgos en un espacio de tres dimensiones, aunque
realmente trabaja con coordenadas homogneas (de cuatro dimensiones). Las
tres dimensiones que nos interesan ahora son las especificadas por un sistema 3D
ortonormal. Es decir, sus ejes son perpendiculares, y las especificadas en uno de
ellos est representada por un vector de mdulo 1 (si nos alejamos una unidad,
nos alejamos la misma distancia del eje de coordenadas, da igual la direccin).

Fig. 3
Ejes de coordenadas en OpenGL.

Instalacin.

Para la instalacin de OpenGL se pueden seguir diversos caminos, tanto

descargar la carpeta para su instalacin, o como en el caso a continuacin y
desde el sistema operativo de Ubuntu, por medio de la terminal.
En el caso de MAC OSX la librera ya viene incluida.

Para la instalacin en Ubuntu es necesario abrir la terminal y escribir los siguientes

comandos, mediante la librera de FreeGLUT.
1. Es necesario instalar la librera para construir los paquetes a instalar.
sudo apt-get install build-essential
2. El siguiente es el comando para instalar FreeGLUT.
sudo apt-get install freeglut3 freeglut3-dev
3. Este comando instala la librera libglui2c2.
dpkg -i libglui2c2_2.36-4_amd64.deb

Llamado de la librera.

Al crear un programa nuevo es necesario llamar la librera de la siguiente manera:

#include <GL/glut.h>
#include <OpenGL/OpenGL.h>
Una manera de llamar la librera dependiendo el dispositivo que usemos puede
detectarse de la siguiente manera:
#ifdef __APPLE__
#include <OpenGL/OpenGL.h>
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif

Compilacin.

En diversas versiones de sistemas operativos o en diversos sistemas operativos la

compilacin de la librera OpenGL se realiza de forma diferente.

En el caso de MAC OSX, la compilacin se realiza de la siguiente manera:

g++ -o nombre nombre.cpp -framework OpenGL -framework GLUT
gcc -o nombre nombre.c -framework OpenGL -framework GLUT
En Ubuntu la compilacin se realiza de la siguiente manera:
g++ nombre.cpp lglut lGLU lGL o nombre
gcc nombre.c lglut lGLU lGL o nombre

DESARROLLO
Al comienzo del desarrollo del programa no resulto ser muy difcil pues con lo
estudiado previamente en clases y lo aprendido en tutoriales, facilito la tarea de
crear una interfaz, es decir, una pantalla en la cual podramos plasmar las
imgenes deseadas, as como darle las medidas deseadas.
Para el desarrollo de este programa primero se llev a cabo la realizacin de
pantalla la cual seria desplegada al usuario, posteriormente la creacin de las
figuras, animacin de las mismas y deteccin de obstculos, por ltimo
interconectar dos programas similares por medio de sockets que serian los
encargados de tener el juego en dos computadoras a la vez.

Ilustracin 1, diagrama de flujo del programa.

Cdigo y funciones

Dentro del cdigo algunas funciones que se tuvieron que investigar, fueron:
-

glOrtho();
glPushMatrix();
glPopMtrix();
glTranslatef();
glMatrixModel(GL_PROJECTION);
glMatrixModel(GL_MODELVIEW);

glLoadIdentity();
glutSolidSphere();

El primer comando lo que hace es colocar la posicin en que la cmara estar

observado las figuras dibujadas, la cual recibe 6 parmetros los cuales son
xmin,xmax,ymin,ymax,znear y zfar.

Ilustracin 2, representacin ortogonal.

El problema con este comando fue comprender como es que se hace la

proyeccin en la pantalla y sobre todo es como se dibujaban las figuras, pues al
colocarla no se proyectaba de manera correcta, esto debido a que en
coordenadas en Z colocaba un nmero con valor positivo, hasta despus leyendo
un poco comprendimos que la vista del observador se colocaba de valores
negativos, pues por defecto la cmara es colocada en la coordenada x=0,y=0 y
z=0, entonces la profundidad a la que se proyectan las figuras debera ser en
valores negativos para Z.
El funcionamiento de los comandos glPushMatrix y glPopMatrix, era colocar
una matriz donde se colocan ciertos efectos o se hacen varias modificaciones a
figuras, sobre todo es til cuando se tiene ms de una imagen dibujada,
posteriormente para aplicar estos cambios o en forma terica sacar la matriz de
proyeccin y que el usuario pueda observar los cambios.

Ilustracin 3, transformaciones de matrices.

En otras palabras estos comandos lo que hacen es guardar y restaurar los valores
aplicados a esa matriz, es decir, la figura en nuestro caso.
Los comandos de glMatrixModel, solo definen en que matriz se esta trabajando ya
se la de modelador o la de proyeccin, en la primera se define los objetos
utilizados y como se estn orientando, mientras que en la segunda, como su
nombre lo indica, es la visualizacin, definiendo el tamao y volumen. Otro
comando utilizado y que sirve para crear figuras, es el de glutSolidSphere();, con
este se crea una figura dndole tres parmetros, el primero es el valor del radio,
seguido de la divisiones dadas horizontalmente en x y las divisiones verticales en
x. Con esta funcin logramos crear nuestra esfera de manera uniforme.
Se comenz con la parte de programacin, para la venta se declaro una de
400x400, en la cual se colocaron un rectngulo, que hace la funcin de raqueta y
una pelota o esfera, que simulara ser la pelotita.
Hasta el momento de desarrollo de estas figuras y su colocacin en el plano, no
encontramos demasiados problemas, pues relativamente era algo que ya
habamos realizado anteriormente, donde se complico un fue al momento de hacer
mover la esfera de manera aleatoria y que rebotara en una direccin con grados,
simulando a como lo hara una pelota en la vida real. Posteriormente esto se logro
gracias a utilizacin de algunas condiciones y otras operaciones.
Lo anterior lo explicaremos mejor en el siguiente diagrama de flujo, teniendo en
cuenta que el limite de nuestra pantalla, que seria donde la pelota rebotara es de
1.16 en valor flotante, tambin se explica el proceso de movimiento de la raqueta
por medio de las teclas.

Ilustracin 4, movimiento de la raqueta.

En el diagrama de flujo se representa el proceso de movimiento de la barra o

raqueta, la cual depende del movimiento de las flechas del teclado para
funcionar, es decir, para moverse.

Ilustracin 5, movimiento de la pelota.

En este diagrama se representa lo utilizado para hacer el movimiento de la pelota y que

detecte el borde de la raqueta.
Con esto no hubo mayor problema, pero el detalle viene ya cuando se quiere hacer una
deteccin oportuna, pues fue un problema que encontramos, ya que no logramos hacer la
resta correcta de las coordenadas de la pelota y la raqueta, para que simule el choque y
el posterior rebote de la pelota.

RESULTADOS

Ilustracin 6, ventana del juego.

CONCLUSIONES
A pesar de lograr hacer la parte del movimiento de pelota y raqueta, de manera
satisfactoria, no se completo en un 100 por ciento la practica, ya que no fue
posible hacer la implementacin de los sockets y por tanto, no hay una
comunicacin entre computadoras, otro objetivo que no se logro cumplir fue
detectar de manera real las coaliciones que se dan entre la pelota y la raqueta en
el juego.
Pero a pesar de que no se logro terminar el juego completamente, teneos el
conocimiento de cmo se manejan grficos en 3D por medio de la librera de
OpenGL, tambin quedo clara la parte de los sockets, aunque no al nivel que se
esperaba, pero si somos capaces de enviar un mensaje sencillo como una hola,
del servidor de la comunicacin al cliente de la misma.

BIBLIOGRAFIA
-

Oscar Garca, Alex Guevara. Introduccin a la Programacin con OpenGL.

Escuela Tcnica Superior de Ingeniera Electrnica. Enero 2004.
Jorge Garca. Curso de introduccin a OpenGL(v1.0). 2003.