Este documento presenta un manual de prácticas de OpenGL con 15 ejercicios que incluyen: 1) la creación de un tablero de ajedrez, 2) una estrella, 3) un cubo con líneas, 4) un cubo delineado, 5) un muñeco con triángulos, 6) una casita, 7) un oso, 8) un cubo con cubitos, 9) un muñeco con formas, 10) una animación de círculo rotando, 11) un sistema solar, 12) un movimiento en ocho, 13) un semáfor
1. Cecytem Plantel Tecámac
Alejandra Martínez Valero
Sandy Moreno Rosas
Manual de prácticas
Grupo: 303
René Domínguez Escalona
2. Introducción
OpenGL es una interface de software para el hardware grafico, esta interface consiste de
una larga serie de comandos para manipulacion de objetos y operaciones sobre estos los
cuales permiten controlar la implentacion realizada en la forma de una maquina de
estados finitos, donde cada una de las variables que determinan el estado se aplican a
partir de ese punto hasta que se indique explicitmanete el cambio, asi las variables de
estado de OpenGL que vamos a utilizar mas comunmente son:
• Color (de dibujo y de borrado).
• Matrices de Transformacion (GL_MODELVIEW, GL_PROYECTION).
• Patrones (de lineas y de relleno).
• Modo de dibujo de poligonos.
• Buffers de dibujo.
• Buffer de Stencil.
• Buffer de profundidad (z-Buffer).
• Buffer de acumulacion.
Funcionamiento de OpenGL:
Para poder trabajar con OpenGL, primero se debe crear un contexto de trabajo, este
contexto contiene el estado actual de maquina finita, asi como las referencias a los
diferentes buffers de trabajo, estos buffers se pueden ver como zonas de memoria
correspondiendo a la pantalla en las cuales OpenGL va a dibujar, en general a parte del
buffer de color (GL_COLOR_BUFFER) que es el buffer en el cual se van a dibujar las
primitivas, existen otro tipo de buffers mas especializados. La configuracion en memoria
de estos buffers (cuantos bits representan un pixel, etc) depende de la manera como fue
creado el contexto OpenGL y de las limitaciones del hardware, por esto no se puede
acceder directamente sino solo a traves de las primitivas OpenGL.
OpenGL puede funcionar adicionalmente de dos maneras, de modo directo o indirecto:
• Modo directo: las primitivas se van dibujando a medida que se van definiendo.
Instruccion -> Buffer de Color = Pantalla
3. • Modo indirecto: las primitivas se guardan en una lista y solo se dibujan cuando el
usuario decida o la
lista este llena, esto permite optimizar la fase de dibujo.
Instruccion-> Pila de instrucciones-> flush -> Buffer de Color = Pantalla
En este modo cuando se desea que OpenGL pinte lo que esta en la lista se utiliza la
instruccion glFlush(): esta instruccion obliga a pintar y no espera a que el hardawre
termine para continuar con el programa, analogamente la glFinish() obliga a pintar pero
espera a que el hw termine antes de continuar con el programa.
En el modo indirecto, OpenGL permite definir dos buffers de colores (doublebuffer), asi un
buffer corresponde a lo que se ve en pantalla y otro a el buffer donde se esta pintando, de
esta manera una vez que se ha pintado todo lo deseado y se quiere que esto aparezca en
pantalla se intercambian los buffers, esta instruccion depende del sistema operativo para
esto se utilizara la instruccion de la libreria portable glut:
glutSwapBuffers() (esta ejecuta implicitamente glFlush o glFinish), en este modo glFlush y
glFinish
obligan a pintar en el buffer de dibujo pero esto NO sera visible hasta intercambiar buffers.
Primitivas de dibujo :
En OpenGL solo se pueden dibujar primitivas muy simples, tales como puntos lineas,
cuadrados, triangulos y polygonos, a partir de estas primitivas es posible construir
primitivas mas complejas como arcos y circulos aproximandolos por poligonos.
Toda primitiva de dibujo se construye con un par: glBegin(tipo_de_primitiva); glVertex2f();
... glEnd();
donde tipo_de_primitiva puede ser cualquiera de las siguientes:
GL_POINTS: Cada vertice es un punto
GL_LINES: Cada par de vertices sucesivos es una linea
GL_LINE_STRIP: lineas conectadas.
GL_LINE_LOOP: lineas conectadas donde el ultimo y el primer vertice indican una linea
cerrando el poligono.
GL_POLYGON: poligono (relleno o no) donde los vertices sucesivos componiendolo se
dan el sentido contrario de las manecillas del reloj.
GL_QUADS: cuadrilateros separados, cada 4 vertices hacen un quad.
4. GL_QUAD_STRIP: tira de cuadrados unidos, cada par de vertices sucesivos forman un
cuadrado con el par anterior.
GL_TRIANGLES: Triangulos separados, cada 3 vertices hacen un triangulo.
GL_TRIANGLE_STRIP: tira de triangulos unidos (similara quad_strip).
GL_TRIANGLE_FAN: Grupo de triangulos con un unico vertice comun a todos.
5. INDICE
1. Tablero de Ajedrez
2. Estrella
3. Cubo con Líneas
4. Cubo Delineado
5. Muñeco con Triángulos
6. Casita
7. Oso
8. Cubo con Cubitos
9. Muñeco con formas
10.Animación de Circulo rotando
11.Sistema Solar
12.Movimiento en Ocho
13.Semáforo
14.Cubo 3D con Líneas
15.Pirámide
16.Nombre 3D
6. 1. Tablero de Ajedrez
En esta práctica aprendimos a colocar cuadros con coordenadas un cuadro
sobre otro y le cambiamos el color a modo de que pareciera un tablero de
ajedrez.
CODIGO:
//mi primer ventana
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
void inicializa(void)
{
glClearColor(1.0,1.0,0.0,0.0); //color de fondo
glMatrixMode(GL_PROJECTION); //Modo de proyeccion
glLoadIdentity(); //Establece los parametros de proyeccion
gluOrtho2D(0.0, 1050.0, 0.0, 1000.0); //vista ortogonal
}
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(0.0 , 0.0 , 0.0);
glPointSize(60);
glBegin(GL_POINTS);
glVertex2i(100,100);
glVertex2i(347,100);
glVertex2i(597,100);
glVertex2i(848,100);
glVertex2i(220,220);
glVertex2i(473,220);
glVertex2i(723,220);
glVertex2i(970,220);
glVertex2i(100,340);
glVertex2i(347,340);
glVertex2i(597,340);
glVertex2i(848,340);
glVertex2i(220,460);
glVertex2i(473,460);
glVertex2i(723,460);
glVertex2i(970,460);
glVertex2i(100,580);
glVertex2i(347,580);
glVertex2i(597,580);
7. glVertex2i(848,580);
glVertex2i(220,700);
glVertex2i(473,700);
glVertex2i(723,700);
glVertex2i(970,700);
glVertex2i(100,820);
glVertex2i(347,820);
glVertex2i(597,820);
glVertex2i(848,820);
glEnd();
glColor3f(1.0 , 1.0 , 1.0);
glPointSize(60);
glBegin(GL_POINTS);
glVertex2i(220,100);
glVertex2i(473,100);
glVertex2i(723,100);
glVertex2i(970,100);
glVertex2i(100,220);
glVertex2i(347,220);
glVertex2i(597,220);
glVertex2i(848,220);
glVertex2i(220,340);
glVertex2i(473,340);
glVertex2i(723,340);
glVertex2i(970,340);
glVertex2i(100,460);
glVertex2i(347,460);
glVertex2i(597,460);
glVertex2i(848,460);
glVertex2i(220,580);
glVertex2i(473,580);
glVertex2i(723,580);
glVertex2i(970,580);
glVertex2i(100,700);
glVertex2i(347,700);
glVertex2i(597,700);
glVertex2i(848,700);
glVertex2i(220,820);
glVertex2i(473,820);
glVertex2i(723,820);
glVertex2i(970,820);
glEnd();
glFlush(); //forza dibujo
}
int main (int argc, char** argv) //metodo main
{
glutInit(&argc, argv); //incializa GLUT
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización
glutInitWindowSize(500,500); //tamaño de la ventana
glutInitWindowPosition(0,0); //posicion inicial de la ventana
glutCreateWindow("MI primer ventana"); //nombre de la ventana
inicializa();
glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización
glutMainLoop(); //muestra todo y espera
return 0; //retorna un valor de cero
}
8.
9. 2. Estrella
En esta practica vimos como juntar puntos para realizar una figura en este
caso una estrella.
CODIGO:
//mi primer ventana
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
void inicializa(void)
{
glClearColor(1.0,0.0,1.0,0.0); //color de fondo
glMatrixMode(GL_PROJECTION); //Modo de proyeccion
glLoadIdentity(); //Establece los parametros de proyeccion
gluOrtho2D(0.0, 1000.0, 0.0, 1000.0); //vista ortogonal
}
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_LINES);
glVertex2i(400,700);
glVertex2i(700,100);
glVertex2i(700,100);
glVertex2i(100,500);
glVertex2i(100,500);
glVertex2i(800,500);
glVertex2i(800,500);
glVertex2i(200,100);
glVertex2i(200,100);
glVertex2i(400,700);
glEnd();
glFlush(); //forza dibujo
}
int main (int argc, char** argv) //metodo main
{
glutInit(&argc, argv); //incializa GLUT
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización
glutInitWindowSize(500,500); //tamaño de la ventana
glutInitWindowPosition(0,0); //posicion inicial de la ventana
glutCreateWindow("MI primer ventana"); //nombre de la ventana
inicializa();
glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización
glutMainLoop(); //muestra todo y espera
return 0; //retorna un valor de cero
10.
11. 3. Cubo con líneas
En esta practica veremos como realizar un cubo con líneas de tal modo de que se
vean todas las líneas sin delineado ni clores que obstruyan la vista de todas las
líneas que componen el cubo.
CODIGO:
//CUBO CON LINEAS
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
void inicializa(void)
{
glClearColor(0.0,0.0,1.0,0.0); //color de fondo
glMatrixMode(GL_PROJECTION); //Modo de proyeccion
glLoadIdentity(); //Establece los parametros de proyeccion
gluOrtho2D(0.0, 1000.0, 0.0, 1000.0); //vista ortogonal
}
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0 ,0.0 ,1.0 );
glBegin(GL_LINES);
glVertex2i(100,100);
glVertex2i(100,400);
glVertex2i(100,100);
glVertex2i(400,100);
glVertex2i(400,100);
glVertex2i(400,400);
glVertex2i(400,400);
glVertex2i(100,400);
glVertex2i(100,100);
glVertex2i(300,300);
glVertex2i(100,400);
glVertex2i(300,600);
glVertex2i(300,300);
glVertex2i(300,600);
glVertex2i(300,300);
glVertex2i(600,300);
glVertex2i(600,600);
glVertex2i(600,300);
glVertex2i(600,600);
glVertex2i(300,600);
glVertex2i(600,600);
glVertex2i(400,400);
glVertex2i(600,300);
glVertex2i(400,100);
12. glEnd();
glFlush(); //forza dibujo
}
int main (int argc, char** argv) //metodo main
{
glutInit(&argc, argv); //incializa GLUT
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización
glutInitWindowSize(500,500); //tamaño de la ventana
glutInitWindowPosition(0,0); //posicion inicial de la ventana
glutCreateWindow("MI primer ventana"); //nombre de la ventana
inicializa();
glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización
glutMainLoop(); //muestra todo y espera
return 0; //retorna un valor de cero
}
13. 4. Cubo Delineado
En esta practica aprendimos a hacer un cubo con colores es decir que solo se ven
tres partes del cubo y bien marcadas sus líneas.
CODIGO:
//cubo delineado
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
void inicializa(void)
{
glClearColor(0.0,0.0,1.0,0.0); //color de fondo
glMatrixMode(GL_PROJECTION); //Modo de proyeccion
15. glFlush(); //forza dibujo
}
int main (int argc, char** argv) //metodo main
{
glutInit(&argc, argv); //incializa GLUT
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización
glutInitWindowSize(500,500); //tamaño de la ventana
glutInitWindowPosition(0,0); //posicion inicial de la ventana
glutCreateWindow("MI primer ventana"); //nombre de la ventana
inicializa();
glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización
glutMainLoop(); //muestra todo y espera
return 0; //retorna un valor de cero
}
16. 5. Muñeco con triángulos
En esta practica utilizamos varias figuras geométricas como lo que son triángulos,
círculos, cuadrados, rectángulos para crear un muñeco utilizando dichas figuras.
CODIGO:
#include <GL/glut.h>
23. glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización
glutInitWindowSize(900,900); //tamaño de la ventana
glutInitWindowPosition(0,0); //posicion inicial de la ventana
glutCreateWindow("Muñeco con triangulos"); //nombre de la ventana
inicializa();
glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización
glutMainLoop(); //muestra todo y espera
return 0; //retorna un valor de cero
}
24. 6. Oso
En esta practica realizamos un oso con círculos y una línea es muy fácil sabiendo
acomodar correctamente los círculos.
CODIGO:
25. #include <GL/glut.h>
#include <GL/gl.h>
#include <math.h>
void inicializa(void)
{
glClearColor(1.0,1.0,1.0,0.0); //color de fondo
glMatrixMode(GL_PROJECTION); //Modo de proyeccion
glLoadIdentity(); //Establece los parametros de proyeccion
gluOrtho2D(0.0, 500.0, 0.0, 500.0); //vista ortogonal
}
void circuloc(int x, int y, int t, int radio)
{
int angulo=0;
glPointSize(t);
glBegin(GL_POINTS);
//glColor3f (1.0, 0.0, 1.0);
glVertex2f(x,y);
//glColor3f(0,0.0,0.0);
for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}
glEnd();
}
void circulo(int x, int y, int radio)
{
int angulo=0;
glBegin(GL_TRIANGLE_FAN);
// glColor3f (1.0, 0.0, 1.0);
glVertex2f(x,y);
for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}
27. glColor3f(0.0,0.0,0.0);
glVertex2i(200,325);
glVertex2i(350,325);
glEnd();
glFlush(); //forza dibujo
}
int main (int argc, char** argv) //metodo main
{
glutInit(&argc, argv); //incializa GLUT
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización
glutInitWindowSize(500,500); //tamaño de la ventana
glutInitWindowPosition(50,50); //posicion inicial de la ventana
glutCreateWindow("Ventana"); //nombre de la ventana
inicializa();
glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización
glutMainLoop(); //muestra todo y espera
return 0; //retorna un valor de cero
}
28. 7. Cubo con cubitos
Para esta practica se necesita el cubo delineado de la practica anterior ya que lo
tienes en necesario saber acomodar bien los demás cubos ya que en esta practica
ya es necesaria la combinación de formulas para poder hacer el cubo. También es
necesario definir las instrucciones al principio del programa de lo contrario no
compilara.
29. CODIGO:
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
void inicializa(void)
{
glClearColor(0.5,0.0,.6,0.0); //color de fondo
glMatrixMode(GL_PROJECTION); //Modo de proyeccion
glLoadIdentity(); //Establece los parametros de proyeccion
gluOrtho2D(0.0, 4000.0, 0.0,4000.0); //vista ortogonal
}
void dibuja(void) //funcion dibuja
{
int i,a=100;
glClear(GL_COLOR_BUFFER_BIT);
////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
for(i=0;i<=10;i++){
glColor3f(1.0 ,0.0 ,1.0 );
glLineWidth(8);
glBegin(GL_QUADS);
68. 8. Animación circulo
En esta practica aprendimos a que una pelota se mueva y pase por las 4 partes de
la ventana. También es importante que no se olvide definir nueva instrucción al
principio ya que de lo contrario el programa no compilara.
CODIGO:
#include <unistd.h>
#include <GL/glut.h>
#include <GL/gl.h>
#include <math.h>
int x=1,z=1,w=1, y=1;
void inicializa(void)
{
glClearColor(1.0,0.2,1.0,0.5);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, 1200.0, 0.0, 800.0);// el ancho y largo de nuestra pantalla
}
void circulo(int x, int y, int radio)
{
int angulo=0;
glBegin(GL_TRIANGLE_FAN); glColor3f (2.0, 0.1, 3.0);
glVertex2f(x,y);
71. 9. Animación sistema solar
En esta practica del sistema solar hicimos una representación de dicho sistema
haciendo que los planetas de movieran alrededor del sol. Es importante definir
nuevas instrucciones al inicio.
CODIGO:
#include <unistd.h>
#include <GL/glut.h>
#include <GL/gl.h>
#include <math.h>
int rad=100;
double ang=0,a=0,b=0,c=0,d=0,e=0,f=0,g=0,h=0;
72. void inicializa(void)
{
glClearColor(0.0,0.0,0.0,0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, 1000.0, 0.0, 1000.0);// el ancho y largo de nuestra pantalla
}
void circuloc(int x, int y, int t, int radio)
{
int angulo=0;
glPointSize(t);
glBegin(GL_POINTS);
//glColor3f (1.0, 0.0, 1.0);
glVertex2f(x,y);
//glColor3f(0,0.0,0.0);
for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}
glEnd();
}
void circulo(int x, int y, int radio)
{
int angulo=0;
glBegin(GL_TRIANGLE_FAN);
glVertex2f(x,y);
for (angulo=0;angulo<=360; angulo++){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}
glEnd();
}
void dibuja(void)
{
74. circulo( 500 + sin(e) * 300,500 + cos(e) * 300,30);
//saturno
circuloc(500,500,2,300);
glColor3f(1.0,0.3,0.5);
circulo( 500+ sin(f) * 350,500 + cos(f) * 350,25);
//urano
circuloc(500,500,2,350);
glColor3f(1.0,0.9,0.0);
circulo( 500+ sin(g) * 400,500 + cos(g) * 400,13);
//neptuno
circuloc(500,500,2,400);
glColor3f(1.5,0.0,0.5);
circulo( 500 + sin(h) * 450,500 + cos(h) * 450,7);
circuloc(500,500,2,450);
a=a+0.01;
b=b+0.02;
c=c+0.08;
d=d+0.07;
e=e+0.04;
f=f+0.06;
g=g+0.03;
h=h+0.05;
ang=ang+0.01; //velocidad entre mas grande mas rapido y entre menos mas lento
for(int j=1;j<=10000000;j++){}//pausa
if(ang==360){ang=0;}// se repite idefinidamente
glFlush(); //forzar dibujado
75. glutSwapBuffers(); //y esto
}
int main (int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA| GLUT_DEPTH);//esto tambien
glutInitWindowSize(1000,1000);
glutInitWindowPosition(10,10);
glutCreateWindow("Ventana");
inicializa();
glutDisplayFunc(dibuja);
glutIdleFunc(dibuja);//esto es lo que cambia
glutMainLoop();
return 0;
}
76. 10. Movimiento en ocho
En esta práctica veremos como podemos hacer que un circulo se mueva
alrededor de otros dos haciendo un movimiento circular en forma de un ocho.
CODIGO:
#include <unistd.h>
#include <GL/glut.h>
77. #include <GL/gl.h>
#include <math.h>
int x=1, x2=1,y=1;
double a=6.15, b=6.15;
void inicializa(void){
glClearColor(0.0,0.0,0.0,0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, 700.0, 0.0, 700.0);// el ancho y largo de nuestra pantalla
}
void circulo(int x, int y, int radio){
int angulo=0;
glBegin(GL_TRIANGLE_FAN);
glVertex2f(x,y);
for (angulo=0;angulo<=360; angulo+=6){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}
glEnd();}
void dibuja(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(1.0, 0.5, 1.0);
circulo(300, 300, 70);
circulo(300,180,70);
glColor3f(0.1,2.0,0.5);
circulo(300,300,50);
circulo(300,180,50);
glColor3f(0.0,1.0,3.0);
if(a>=6.15 && a<=12.41){
circulo(300+ sin (a)*60,300- cos(a)*60,10);
a=a+0.01;
79. 15. Piramide
En esta practica realizamos una pirámide que vista desde arriba se ve en 3D Se
realiza con puras líneas.
CODIGO:
#include <GL/glut.h>
80. #include <GL/gl.h>
#include <GL/glu.h>
void inicializa(void)
{
glClearColor(0.0,0.0,1.0,0.0); //color de fondo
glMatrixMode(GL_PROJECTION); //Modo de proyeccion
glLoadIdentity(); //Establece los parametros de proyeccion
gluOrtho2D(0.0, 1050.0, 0.0, 1000.0); //vista ortogonal
}
void dibuja(void) //funcion dibuja
{int i,a=20;
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(1.0 , 1.0 , 0.6);
glLineWidth(2);
glBegin(GL_LINES);
//valor inicial----valor final
for(i=1;i<=10;i++){
//abajo
glVertex2i(240-20*i,240-20*i);
glVertex2i(260+20*i,240-20*i);
//derecha
glVertex2i(260+20*i,240-20*i);
glVertex2i(260+20*i,260+20*i);
//Izquierda
glVertex2i(240-20*i,240-20*i);
glVertex2i(240-20*i,260+20*i);
//arriba
81. glVertex2i(240-20*i,260+20*i);
glVertex2i(260+20*i,260+20*i);
}
int c,s=40;
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
for(c=0;c<=4;c++){
glVertex2i(280+s*c,280+s*c);
glVertex2i(300+s*c,300+s*c);
glVertex2i(200-s*c,200-s*c);
glVertex2i(220-s*c,220-s*c);
glVertex2i(220-s*c,280+s*c);
glVertex2i(200-s*c,300+s*c);
glVertex2i(280+s*c,220-s*c);
glVertex2i(300+s*c,200-s*c);
}
glEnd();
glFlush(); //forza dibujo
}
int main (int argc, char** argv) //metodo main
{
glutInit(&argc, argv); //incializa GLUT
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización
glutInitWindowSize(500,500); //tamaño de la ventana
82. glutInitWindowPosition(0,0); //posicion inicial de la ventana
glutCreateWindow("MI primer ventana"); //nombre de la ventana
inicializa();
glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización
glutMainLoop(); //muestra todo y espera
return 0; //retorna un valor de cero
}