El documento presenta 10 prácticas de OpenGL para crear diferentes figuras geométricas 2D como un tablero de ajedrez, una estrella, un cubo con líneas. También incluye prácticas más complejas como un cubo delineado, un muñeco con triángulos y formas, y animaciones de un círculo y el sistema solar.

1. Colegio de Estudios Científicos y Tecnológicos
del Estado de México.
P l a n t e l: Tecámac
Carrera: Técnico en Informática
Asignatura: Utilización de Software de Diseño para el Manejo de
Gráficos.
Docente: Ing. René Domínguez Escalona.
Alumnos:
Bernal Sixto Karla Gabriela
Campos Centeno Jorge Alejandro
Título: ”MANUAL DE PRACTICAS DE OpenGl ”
1

2. Ecatepec de Morelos, Estado de México, a jueves 01 de marzo del 2012.
INTRODUCCIÓN.
OpenGl
es una especificación estándar que define a una APL
(Open Graphics Library)
(Application Programming Interface) multilenguaje para producir
aplicaciones que produzcan gráficos en 2D y 3D. La interfaz consiste en
más de 250 funciones diferentes que pueden usarse para dibujar escenas
tridimensionales complejas a partir de primitivas geométricas simples, tales
como puntos, líneas y triángulos.
Así mismo cuenta con varias paqueterias las cuales ayudan a el uso de
este software.
¿Cuáles son las librerías de OpenGl y sus características?
La librería principal de OpenGl nos suministra todas las funciones necesarias
para mostrar un entorno 3D aunque hay algunas operaciones que son algo
tediosas de realizar utilizando solo esta librería. Estas son por ejemplo
calcular la matriz de proyección. Para esto se han desarrollado tambien
una librería auxiliar:
GLU: Esta librería acompaña a la OpenGl principal. Incluye funciones más
complejas que GL por ejemplo definir un cilindro o un disco con un solo
comando, también contiene funciones para trabajar con splines y
operaciones con matrices.
GLUT: Esta librería es independiente de la librería OpenGl de cada
plataforma. Esta librería no incluye funciones adicionales para OpenGl :(
pero nos permite utilizar funciones para el tratamiento de ventanas,
teclado y ratón. Para trabajar con OpenGl en cualquier plataforma,
primero tenemos que inicializar una ventana (y esto es diferente entre
Windows y Linux por ejemplo). GLUT nos permite crear ventanas y controlar
la entrada independientemente de la plataforma utilizada :). Aunque
también contiene comandos para crear conos, tazas de té...
GLAUX: Esta librería, muy parecida a GLUT, es la que Microsoft ha
desarrollado para Windows. Mantiene prácticamente la misma estructura
2

3. que la GLUT con el defecto de que solo sirve para Windows, mientras que
GLUT sirve para cualquier plataforma.
INDICE
Portada…………………………………………………………………….1
Introducción………………………………………………………………2
Indice………………………………………………………………………3
Practicas
Tablero De Ajedrez………………………………………………………4
Estrella………………………………………………………………………5
Cubo Con Lineas…………………………………………………………6
Cubo Delineado………………………………………………………….7
Muñeco Con triangulos…………………………………………………8
Casita………………………………………………………………………9
Oso………………………………………………………………………….10
Cubo Con Cubitos……………………………………………………….11
Muñeco Con Formas……………………………………………………12
Animación a Un Circulo………………………………………………..13
Animaciòn del Sistema Solar………………………………………….14
Movimiento en ocho…………………………………………………….15
Semaforo…………………………………………………………………..16
Cubo en 3D………………………………………………………………..17
Nombre en 3D…………………………………………………………….18
Practica Extra: Piramide………………………………….……………..19
3

4. Practica 1.
Tablero De Ajedrez.
DESCRIPCIÓN.
Con la primitiva de PUNTO en OpenGL (POINTS) crear una simulación de un
tablero de ajedrez de 8 x 8 cuadros uno blanco y uno negro.
Borrador
CODIGO
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(0.0 , 0.0 , 0.0);
glPointSize(80);
glBegin(GL_POINTS);
glVertex2i(100,100);
4

5. glVertex2i(320,100);
glVertex2i(540,100);
glVertex2i(760,100);
glVertex2i(210,210);
glVertex2i(430,210);
glVertex2i(650,210);
glVertex2i(100,320);
glVertex2i(320,320);
glVertex2i(540,320);
glVertex2i(760,320);
glVertex2i(210,430);
glVertex2i(430,430);
glVertex2i(650,430);
glVertex2i(100,540);
glVertex2i(320,540);
glVertex2i(540,540);
glVertex2i(760,540);
glVertex2i(210,650);
glVertex2i(430,650);
glVertex2i(650,650);
glVertex2i(100,760);
glVertex2i(320,760);
glVertex2i(540,760);
glVertex2i(760,760);
glVertex2i(210,870);
glVertex2i(430,870);
glVertex2i(650,870);
glEnd();
glColor3f(1.0 , 1.0 , 1.0);
glPointSize(80);
glBegin(GL_POINTS);
glVertex2i(210,100);
glVertex2i(430,100);
glVertex2i(650,100);
5

6. glVertex2i(100,210);
glVertex2i(320,210);
glVertex2i(540,210);
glVertex2i(760,210);
glVertex2i(210,320);
glVertex2i(430,320);
glVertex2i(650,320);
glVertex2i(100,430);
glVertex2i(320,430);
glVertex2i(540,430);
glVertex2i(760,430);
glVertex2i(210,540);
glVertex2i(430,540);
glVertex2i(650,540);
glVertex2i(100,650);
glVertex2i(320,650);
glVertex2i(540,650);
glVertex2i(760,650);
glVertex2i(210,760);
glVertex2i(430,760);
glVertex2i(650,760);
glVertex2i(100,870);
glVertex2i(320,870);
glVertex2i(540,870);
glVertex2i(760,870);
glEnd();
glFlush(); //forza dibujo
}
6

7. SALIDA
7

8. Practica 2.
Estrella.
DESCRIPCIÓN.
Con la primitiva de LINEA en OpenGL (LINES) crear una estrella del tamaño
cuales quiera.
BORRADOR
CODIGO
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT);
glLineWidth(3);
glColor3f(101 ,333 ,210 );
glBegin(GL_LINES);
8

9. glVertex2i(152,0);
glVertex2i(394,750);
glVertex2i(394,750);
glVertex2i(638,0);
glVertex2i(638,0);
glVertex2i(0,463);
glVertex2i(0,463);
glVertex2i(789,463);
glVertex2i(789,463);
glVertex2i(152,0);
glEnd();
glFlush(); //forza dibujo
}
SALIDA
9

10. Practica 3.
Cubo con Lineas.
DESCRIPCIÓN.
Con la primitiva de LINEA en OpenGL (LINES) crear una cubo del tamaño
cuales quiera(obvio sin relleno).
BORRADOR
10

11. CODIGO
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(0.0 , 0.0 , 0.0);
glLineWidth(4);
glBegin(GL_LINES);
glVertex2i(300,300);
glVertex2i(400,300);
glVertex2i(370,370);
glVertex2i(470,370);
glVertex2i(300,300);
glVertex2i(370,370);
glVertex2i(400,300);
glVertex2i(470,370);
11

12. glVertex2i(370,370);
glVertex2i(370,470);
glVertex2i(470,370);
glVertex2i(470,470);
glVertex2i(370,470);
glVertex2i(470,470);
glVertex2i(300,300);
glVertex2i(300,400);
glVertex2i(300,400);
glVertex2i(370,470);
glVertex2i(470,470);
glVertex2i(400,400);
glVertex2i(400,400);
glVertex2i(300,400);
glVertex2i(400,400);
glVertex2i(400,300);
glEnd();
glFlush(); //forza dibujo
}
SALIDA
12

13. Practica 4.
Cubo Delineado.
DESCRIPCIÓN.
13

14. Con la primitiva de CUADRO en OpenGL (QUADS) crear una cubo del
tamaño cuales quiera con diferentes colores de relleno. Y así mismo
remarcar todas las orillas de cada cuadro que conforman el cubo con las
primitiva de LINES en OpenGL (LINES), para así lograr la simulacion de un
cubo delineado.
BORRADOR
CODIGO
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glBegin(GL_QUADS);
//atras
glColor3f(0.0 , 0.6 , 0.0);
glVertex2d(100,150);
glVertex2d(300,150);
glVertex2d(300,350);
glVertex2d(100,350);
14

15. //abajo
glColor3f(0.7 , 0.8 , 0.7);
glVertex2d(200,100);
glVertex2d(400,100);
glVertex2d(300,150);
glVertex2d(100,150);
//izquierda
glColor3f(0. , 0.4 , 1.0);
glVertex2d(100,150);
glVertex2d(200,100);
glVertex2d(200,300);
glVertex2d(100,350);
//derecho
glColor3f(0.0 , 0.8 , 0.0);
glVertex2d(300,150);
glVertex2d(400,100);
glVertex2d(400,300);
glVertex2d(300,350);
//arriba
glColor3f(5.5 , 0.0 , 0.0);
glVertex2d(200,300);
glVertex2d(400,300);
glVertex2d(300,350);
glVertex2d(100,350);
//frente
15

16. glColor3f(0.2 , 0.9 , 0.0);
glVertex2d(200,100);
glVertex2d(400,100);
glVertex2d(400,300);
glVertex2d(200,300);
glEnd();
glFlush(); //forza dibujo
}
SALIDA
Practica 5.
Muñeco con Triangulos.
16

17. DESCRIPCIÓN.
Con las primitivas de TRIANGULO y CUADRO en OpenGL (TRIANGLE &&
QUADS) crear un pequeño hombre.
BORRADOR
CODIGO
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glBegin(GL_QUADS);
glColor3f(0.3 , 0.7 , 0.9);
glVertex2i(0,500);
glVertex2i(500,500);
glVertex2i(500,114);
glVertex2i(0,114);
17

18. glColor3f(0.4 , 0.7 , 0.2);
glVertex2i(0,115);
glVertex2i(0,0);
glVertex2i(500,0);
glVertex2i(500,115);
glEnd();
glColor3f(1.0 , 0.0 , 0.0);
glLineWidth(4);
glBegin(GL_TRIANGLES);
glVertex2i(184,405);
glVertex2i(314,405);
glVertex2i(250,468);
glColor3f(0.9 , 0.7 , 0.5);
glVertex2i(215,405);
glVertex2i(287,405);
glVertex2i(250,335);
glColor3f(0.9 , 0.7 , 0.5);
glVertex2i(239,335);
glVertex2i(261,335);
glVertex2i(250,314);
glEnd();
glBegin(GL_QUADS);
glColor3f(0.0 , 1.0 , 0.0);
glVertex2i(208,335);
glVertex2i(292,335);
glVertex2i(293,241);
glVertex2i(208,241);
glEnd();
glBegin(GL_TRIANGLES);
18

19. glColor3f(0.9 , 0.7 , 0.5);
glVertex2i(239,335);
glVertex2i(261,335);
glVertex2i(250,314);
glColor3f(0.9 , 0.7 , 0.5);
glVertex2i(208,335);
glColor3f(1.0 , 1.0 , 1.0);
glVertex2i(170,241);
glColor3f(1.0 , 1.0 , 1.0);
glVertex2i(160,279);
glColor3f(0.9 , 0.7 , 0.5);
glVertex2i(160,279);
glColor3f(1.0 , 1.0 , 1.0);
glVertex2i(151,298);
glColor3f(1.0 , 1.0 , 1.0);
glVertex2i(142,260);
glColor3f(0.9 , 0.7 , 0.5);
glVertex2i(329,240);
glColor3f(1.0 , 1.0 , 1.0);
glVertex2i(339,279);
glColor3f(1.0 , 1.0 , 1.0);
glVertex2i(293,335);
glColor3f(0.9 , 0.7 , 0.5);
glVertex2i(348,297);
glColor3f(1.0 , 1.0 , 1.0);
glVertex2i(357,259);
glVertex2i(339,279);
glColor3f(1.0 , 0.9 , 0.0);
19

20. glVertex2i(333,326);
glVertex2i(391,326);
glVertex2i(362,247);
glColor3f(0.3 , 0.7 , 0.9);
glVertex2i(362,250);
glVertex2i(348,326);
glVertex2i(341,322);
glColor3f(0.3 , 0.7 , 0.9);
glVertex2i(377,326);
glVertex2i(384,322);
glVertex2i(364,250);
glColor3f(0.9 , 0.7 , 0.5);
glVertex2i(239,241);
glColor3f(1.0 , 1.0 , 1.0);
glVertex2i(239,96);
glColor3f(1.0 , 1.0 , 1.0);
glVertex2i(214,210);
glColor3f(1.0 , 0.0 , 0.0);
glVertex2i(238,95);
glVertex2i(195,96);
glVertex2i(213,117);
glColor3f(0.9 , 0.7 , 0.5);
glVertex2i(256,241);
glColor3f(1.0 , 1.0 , 1.0);
glVertex2i(256,210);
glColor3f(1.0 , 1.0 , 1.0);
glVertex2i(299,210);
glColor3f(0.9 , 0.7 , 0.5);
20

21. glVertex2i(299,210);
glVertex2i(282,189);
glVertex2i(290,158);
glColor3f(1.0 , 0.0 , 0.0);
glVertex2i(292,158);
glVertex2i(316,178);
glVertex2i(333,158);
glColor3f(0.0 , 0.0 , 0.0);
glVertex2i(308,158);
glVertex2i(308,143);
glVertex2i(293,143);
glVertex2i(322,158);
glVertex2i(322,143);
glVertex2i(337,143);
glVertex2i(337,128);
glVertex2i(322,128);
glVertex2i(322,113);
glVertex2i(308,128);
glVertex2i(308,113);
glVertex2i(293,128);
glColor3f(1.0 , 0.9 , 0.0);
glVertex2i(362,246);
glVertex2i(383,239);
glVertex2i(341,239);
glEnd();
glBegin(GL_QUADS);
glColor3f(0.0 , 0.0 , 0.0);
21

22. glVertex2i(308,128);
glVertex2i(322,128);
glVertex2i(322,113);
glVertex2i(308,113);
glVertex2i(308,128);
glColor3f(0.0 , 0.0 , 0.0);
glVertex2i(308,143);
glVertex2i(322,143);
glVertex2i(322,128);
glVertex2i(322,143);
glVertex2i(322,128);
glVertex2i(337,128);
glVertex2i(337,143);
glVertex2i(322,143);
glVertex2i(322,157);
glVertex2i(308,157);
glVertex2i(308,143);
glVertex2i(308,143);
glVertex2i(308,128);
glVertex2i(293,128);
glVertex2i(293,143);
glEnd();
glFlush(); //forza dibujo
}
SALIDA
22

23. Practica 6.
Casita.
23

24. DESCRIPCIÓN.
Con las primitivas de TRIANGULO, CUADRO, LINEA y PUNTO en OpenGL
(TRIANGLE, QUADS, LINES && POINTS) crear una copia de las siguiente
imagen:
CODIGO
void dibuja(void)
{
int i,j=0;
/* borra la pantalla */
glClear(GL_COLOR_BUFFER_BIT);
// Cerca
for(i=0;i<50;i++){
glBegin(GL_POLYGON);
glColor3f (1.0, 0.3, 0.0);
glVertex2f(0+20*i,292);
glVertex2f(5+20*i,300);
glVertex2f(10+20*i,292);
glVertex2f(10+20*i,240);
glVertex2f(0+20*i,240);
glEnd();
}
glBegin(GL_QUADS);
24

25. glVertex2i(0,289);
glVertex2i(1000,289);
glVertex2i(1000,280);
glVertex2i(0,280);
//pasto
glColor3f (0.4, 0.8, 0.2);
glVertex2i(0,240);
glVertex2i(1000,240);
glVertex2i(1000,120);
glVertex2i(0,120);
//banqueta
glColor3f (0.6, 0.6, 0.6);
glVertex2i(0,120);
glVertex2i(1000,120);
glVertex2i(1000,90);
glVertex2i(0,90);
glColor3f (1.0, 1.0, 0.0);
glVertex2i(0,90);
glVertex2i(1000,90);
glVertex2i(1000,82);
glVertex2i(0,82);
25

26. //calle
glColor3f (0.3, 0.3, 0.3);
glVertex2i(0,82);
glVertex2i(1000,82);
glVertex2i(1000,0);
glVertex2i(0,0);
//piedras
glColor3f (0.6, 0.6, 0.6);
glVertex2i(105,180);
glVertex2i(135,180);
glVertex2i(135,165);
glVertex2i(105,165);
glVertex2i(165,180);
glVertex2i(195,180);
glVertex2i(195,165);
glVertex2i(165,165);
glVertex2i(105,150);
glVertex2i(135,150);
glVertex2i(135,135);
glVertex2i(105,135);
26

27. glVertex2i(165,150);
glVertex2i(195,150);
glVertex2i(195,135);
glVertex2i(165,135);
//entrada
glVertex2i(345,195);
glVertex2i(405,195);
glVertex2i(405,120);
glVertex2i(345,120);
// Casa
glColor3f (1.0, 0.8, 0.0);
glVertex2i(210,450);
glVertex2i(540,450);
glVertex2i(540,195);
glVertex2i(210,195);
// Techo casa
glColor3f (0.9, 0.09, 0.0);
glVertex2i(210,495);
glVertex2i(540,495);
glVertex2i(585,450);
glVertex2i(165,450);
// Techo cochera
glVertex2i(75,345);
27

28. glVertex2i(210,345);
glVertex2i(210,315);
glVertex2i(60,315);
//Cortina
glColor3f (0.9, 0.9, 0.9);
glVertex2i(90,315);
glVertex2i(210,315);
glVertex2i(210,195);
glVertex2i(90,195);
//Puerta
glColor3f (1.0, 1.0, 1.0);
glVertex2i(345,300);
glVertex2i(405,300);
glVertex2i(405,195);
glVertex2i(345,195);
//Columnas
glColor3f (0.7, 0.5, 0.3);
glVertex2i(75,315);
glVertex2i(90,315);
glVertex2i(90,195);
glVertex2i(75,195);
28

29. glVertex2i(210,330);
glVertex2i(540,330);
glVertex2i(540,315);
glVertex2i(210,315);
glVertex2i(330,435);
glVertex2i(345,435);
glVertex2i(345,195);
glVertex2i(330,195);
glVertex2i(405,435);
glVertex2i(420,435);
glVertex2i(420,195);
glVertex2i(405,195);
//Ventanas i
glColor3f (0.7, 0.7, 1.0);
glVertex2i(240,435);
glVertex2i(300,435);
glVertex2i(300,375);
glVertex2i(240,375);
29

30. glVertex2i(240,300);
glVertex2i(300,300);
glVertex2i(300,240);
glVertex2i(240,240);
//Ventanas d
glVertex2i(450,435);
glVertex2i(510,435);
glVertex2i(510,375);
glVertex2i(450,375);
glVertex2i(450,300);
glVertex2i(510,300);
glVertex2i(510,240);
glVertex2i(450,240);
//Ventanas balcon
glVertex2i(345,435);
glVertex2i(405,435);
glVertex2i(405,330);
glVertex2i(345,330);
//Ventanas puerta
glVertex2i(360,285);
glVertex2i(390,285);
30

31. glVertex2i(390,210);
glVertex2i(360,210);
//Tallos
glColor3f (0.5, 0.3, 0.2);
glVertex2i(670,225);
glVertex2i(700,225);
glVertex2i(700,150);
glVertex2i(670,150);
glVertex2i(875,225);
glVertex2i(905,225);
glVertex2i(905,150);
glVertex2i(875,150);
glEnd();
glBegin(GL_TRIANGLES);
// Techo balcon
glColor3f (0.5, 0.3, 0.2);
glVertex2i(375,480);
glVertex2i(435,435);
glVertex2i(315,435);
31

32. glEnd();
//arboles
glLineWidth (4);
glBegin(GL_LINES);
glColor3f (0.0, 0.7, 0.0);
for(i=0;i<32;i++){
glVertex2i(680-3*i,540-10*j);
glVertex2i(690+3*i,540-10*j);
glVertex2i(685-3*i,535-10*j);
glVertex2i(695+3*i,535-10*j);
glVertex2i(885-3*i,540-10*j);
glVertex2i(895+3*i,540-10*j);
glVertex2i(890-3*i,535-10*j);
glVertex2i(900+3*i,535-10*j);
j=j+1;
}
glEnd();
//Linea Calle
glLineWidth (4);
glColor3f (0.0, 0.0, 0.0);
glBegin(GL_LINES);
32

33. for(i=0;i<50;i++){
glVertex2i(0+120*i,41);
glVertex2i(90+120*i,41);
}
//Barandal
glVertex2i(344,375);
glVertex2i(406,375);
for(i=0;i<7;i++){
glVertex2i(345+10*i,375);
glVertex2i(345+10*i,330);
}
//Divicion Ventana
glVertex2i(240,262);
glVertex2i(300,262);
glVertex2i(240,397);
glVertex2i(300,397);
glVertex2i(450,397);
glVertex2i(510,397);
glVertex2i(450,262);
glVertex2i(510,262);
glVertex2i(375,434);
glVertex2i(375,375);
glVertex2i(270,397);
33

34. glVertex2i(270,375);
glVertex2i(270,262);
glVertex2i(270,240);
glVertex2i(480,397);
glVertex2i(480,375);
glVertex2i(480,262);
glVertex2i(480,240);
glEnd();
//Contorno ventanas
glBegin(GL_LINE_LOOP);
glVertex2i(240,435);
glVertex2i(300,435);
glVertex2i(300,375);
glVertex2i(240,375);
glEnd();
glBegin(GL_LINE_LOOP);
glVertex2i(240,300);
glVertex2i(300,300);
glVertex2i(300,240);
glVertex2i(240,240);
34

35. glEnd();
glBegin(GL_LINE_LOOP);
glVertex2i(450,435);
glVertex2i(510,435);
glVertex2i(510,375);
glVertex2i(450,375);
glEnd();
glBegin(GL_LINE_LOOP);
glVertex2i(450,300);
glVertex2i(510,300);
glVertex2i(510,240);
glVertex2i(450,240);
glEnd();
//Chapa
glPointSize(4);
glColor3f (0.0, 0.0, 0.0);
glBegin(GL_POINTS);
glVertex2i(352,247);
glVertex2i(352,245);
glEnd();
glFlush();
}
35

36. SALIDA
Practica 7.
Oso.
36

37. DESCRIPCIÓN.
Crendo una nueva instrucción en OpenGl con la que puedas dibujar
CIRCULOS crea un oso cualesquiera.
BORRADOR
CODIGO
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);}
glEnd();
}
void dibuja(void) //funcion dibuja
37

38. {
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.4,0.3,0.3); //borra pantalla
circulo(254,180,123);
circulo(248,319,84);
glColor3f(0.5,0.4,0.4); //borra pantalla
circulo(300,395,25);
circulo(183,393,25);
circulo(135,237,31);
circulo(371,233,31);
circulo(326,81,31);
circulo(176,87,31);
circulo(253,130,7);
glColor3f(1.0,1.0,1.0); //borra pantalla
circulo(267,331,15);
circulo(237,331,15);
glColor3f(1.0,0.0,0.0); //borra pantalla
circulo(252,295,7);
glColor3f(0.0,0.0,0.0); //borra pantalla
circulo(262,330,3);
circulo(245,329,3);
glEnd();
glFlush(); //forza dibujo
}
SALIDA
38

39. 39

40. Practica 8.
Cubo con Cubitos.
DESCRIPCIÓN.
Crea una nueva instrucción con la cual puedas multiplicar un dibujo que
en este caso sea el CUBO DELIEADO que hicimos anteriormente y que se
multiplique en forma de linea y acomodarlos para que nos forme otro
cubo.
BORRADOR
CODIGO
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(1.0 , 0.0 , 0.0);
40

41. for(int k=0;k<=10;k++){
cubo(260-20*k*.8,220-20*k*.6,20,5);
}
for(int j=0;j<=9;j++){
cubo(280+20*j,420,20,5);
cubo(280+20*j,220,20,5);
}
for(int i=0;i<=9;i++){
cubo(260,240+20*i,20,5);
}
for(int k=0;k<=10;k++){
cubo(481-20*k*.8,220-20*k*.6,20,5);
}
for(int i=0;i<=9;i++){
cubo(481,240+20*i,20,5);
}
//traves traseras
for(int k=0;k<=10;k++){
cubo(260-20*k*.8,420-20*k*.6,20,5);
}
for(int j=0;j<=9;j++){
cubo(280+20*j,420,20,5);
41

42. }
//cubo delantero
for(int i=0;i<=10;i++){
cubo(100,100+20*i,20,5);
}
for(int j=0;j<=9;j++){
cubo(120+20*j,100,20,5);
cubo(120+20*j,300,20,5);
}
for(int i=0;i<=10;i++){
cubo(320,100+20*i,20,5);
}
for(int k=0;k<=10;k++){
cubo(481-20*k*.8,420-20*k*.6,20,5);
}
glFlush(); //forza dibujo
}
SALIDA
42

43. Practica 9.
43

44. Muñeco con Formas.
DESCRIPCIÓN.
Con las primitvas ya conocidas crea un dibujo de un niño.
BORRADOR
CODIGO
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);}
glEnd();
}
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT);
44

45. glColor3f(1.0 , 00, 0.0);
glColor3f(0.8,0.7,0.6);
circulo(800,1000,200);
circulo(1200,1000,200);
glEnd();
// cabeza
glColor3f(0.8,0.7,0.6); //borra pantalla
circulo(1000,1000,300);
// ojos
glColor3f(0.0,0.0,1.0);
circulo(950,1050,10);
circulo(1100,1050,10);
glEnd();
//orejas
//cuello
glBegin(GL_POLYGON);
glColor3f(0.8,0.7,0.6);
glVertex2f(1050,750);
glVertex2f(1050,820);
glVertex2f(950,820);
glVertex2f(950,750);
glVertex2f(1000,650);
// Playera
glBegin(GL_POLYGON);
glColor3f(1.0,1.0,1.0);
glVertex2f(1200,350);
glVertex2f(1200,550);
glVertex2f(1250,450);
glVertex2f(1350,450);
glVertex2f(1200,750);
glVertex2f(1050,750);
glVertex2f(1000,650);
45

46. glVertex2f(950,750);
glVertex2f(800,750);
glVertex2f(705,450);
glVertex2f(800,450);
glVertex2f(850,550);
glVertex2f(850,350);
glEnd();
//CUERPO
glBegin(GL_TRIANGLES);
glColor3f(1.0,1.0,1.0);
glVertex2f(1200,350);
glVertex2f(1000,650);
glVertex2f(850,350);
glEnd();
glBegin(GL_QUADS);
glColor3f(0.0,0.0,1.0);
glVertex2f(950,650);
glVertex2f(1050,650);
glVertex2f(1050,550);
glVertex2f(950,550);
glVertex2f(950,500);
glVertex2f(1050,500);
glVertex2f(1050,400);
glVertex2f(950,400);
glVertex2f(1200,350);
glVertex2f(850,350);
glVertex2f(850,300);
glVertex2f(1200,300);
glColor3f(0.0,0.0,0.0);
glVertex2f(950,350);
46

47. glVertex2f(1050,350);
glVertex2f(1050,300);
glVertex2f(950,300);
// BRAZOS
glColor3f(0.8,0.5,0.4);
glVertex2f(750,450);
glVertex2f(780,450);
glVertex2f(780,380);
glVertex2f(750,380);
glVertex2f(1275,450);
glVertex2f(1305,450);
glVertex2f(1305,380);
glVertex2f(1275,380);
glEnd();
//MANOS IZQUIERDA
glLineWidth (3);
glBegin(GL_LINES);
glColor3f(0.8,0.5,0.4);
glVertex2i(750,380);
glVertex2i(720,350);
glVertex2i(720,350);
glVertex2i(740,360);
glVertex2i(740,360);
glVertex2i(740,320);
glVertex2i(740,320);
glVertex2i(750,360);
glVertex2i(750,360);
47

48. glVertex2i(760,320);
glVertex2i(760,320);
glVertex2i(770,360);
glVertex2i(770,360);
glVertex2i(780,320);
glVertex2i(780,320);
glVertex2i(790,360);
glVertex2i(790,360);
glVertex2i(810,350);
glVertex2i(810,350);
glVertex2f(780,380);
// MANO DERECHA
glVertex2f(1275,380);
glVertex2f(1255,350);
glVertex2f(1255,350);
glVertex2f(1270,360);
glVertex2f(1270,360);
glVertex2f(1270,320);
glVertex2f(1270,320);
glVertex2f(1280,360);
glVertex2f(1280,360);
glVertex2f(1290,320);
glVertex2f(1290,320);
48

49. glVertex2f(1300,360);
glVertex2f(1300,360);
glVertex2f(1310,320);
glVertex2f(1310,320);
glVertex2f(1320,360);
glVertex2f(1320,360);
glVertex2f(1340,350);
glVertex2f(1340,350);
glVertex2f(1305,380);
// NARIZ
glColor3f(0.0,0.0,0.0);
glVertex2f(1020,1020);
glVertex2f(1000,1000);
glVertex2f(1000,1000);
glVertex2f(1040,1000);
// BOCA
glVertex2f(975,900);
glVertex2f(975,880);
glVertex2f(975,880);
glVertex2f(1050,880);
glVertex2f(1050,880);
glVertex2f(1050,900);
glEnd();
49

50. // CABELLO
glEnd();
// PANTALON
glBegin(GL_POLYGON);
glColor3f(0.3,0.7,0.7);
glVertex2f(850,300);
glVertex2f(750,100);
glVertex2f(900,50);
glVertex2f(1020,250);
glVertex2f(1020,300);
glEnd();
glBegin(GL_POLYGON);
glColor3f(0.3,0.7,0.7);
glVertex2f(1020,300);
glVertex2f(1020,250);
glVertex2f(1100,50);
glVertex2f(1250,100);
glVertex2f(1200,300);
glEnd();
glBegin(GL_TRIANGLES);
glColor3f(1.6 , 0.8 , 0.9);
glVertex2f(750,100);
glVertex2f(900,50);
glVertex2f(650,50);
glVertex2f(1100,50);
glVertex2f(1250,100);
glVertex2f(1350,50);
glEnd();
glFlush(); //forza dibujo
}
50

51. SALIDA
Practica 10.
Animación de un Circulo.
51

52. DESCRIPCIÓN.
Crea una nueva instrucción con la cual puedas mover un circula en forma
de cuadrado repetitivamente.
CODIGO
void circulo(int x, int y, int radio)
{
int angulo=0;
glBegin(GL_TRIANGLE_FAN); glColor3f (0.5, 0.5, 0.5);
glVertex2f(x,y);
glColor3f(0,0.0,0.0);
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);
//abajo
if(x>=1 && x<500){
circulo(100+1*x,100,40);
x++;}
// derecha sube
if(x==500 && y>=1 && y<500) {
circulo(600,100+1*y,40);
y++;}
//arriva ezkierda
if(x==500 && y==500 && z>=1 && z<500){
circulo(600-z,600,40);
z++;}
// izqierda abajo
if(x==500 && y==500 && z==500 && w>=1 && w<500){
circulo(100,600-w,40);
w++;
if(w==500) {x=1; y=1; z=1; w=1;}
52

53. glFlush();}
glutSwapBuffers();
}
Practica 11.
Animaciòn del Sistema Solar.
53

54. DESCRIPCIÓN.
En esta animaciòn realizaremos un sistema solar con movimien5o en todos
los planetas.
BORRADOR
CODIGO
void dibuja(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//esto
glColor3f (0.9,0.8, 0.0);
circulo(500,500,50);
circulo( 500+ sin(ang) * 70,500 + cos(ang) * 70,10);
glColor3f (1.0,1.0, 1.0);
circuloc(500,500,1,70); //funcion circulo
54

55. glColor3f (0.5, 0.5, 0.9);
circulo( 500- sin(a) * 150,500 + cos(a) * 150,12);
glColor3f (1.0,1.0, 1.0);
circuloc(500,500,1,150);
glColor3f (1.6, 1.5, 1.7);
circulo( 500+ sin(b) * 200,500 + cos(b) * 200,12);
glColor3f (1.0,1.0, 1.0);
circuloc(500,500,1,200);
glColor3f (0.0,0.4, 0.0);
circulo( 500- sin(c) * 250,500 + cos(c) * 250,13);
glColor3f (1.0,1.0, 1.0);
circuloc(500,500,1,250);
glColor3f (0.2,0.0, 0.0);
circulo( 500+ sin(d) * 300,500 + cos(d) * 300,12);
glColor3f (1.0,1.0, 1.0);
circuloc(500,500,1,300);
glColor3f (1.0,0.0, 1.0);
circulo( 500- sin(f) * 350,500 + cos(f) * 350,13);
55

56. glColor3f (1.0,1.0, 1.0);
circuloc(500,500,1,350);
glColor3f (0.1,0.5, 1.6);
circulo( 500+ sin(g) * 400,500 + cos(g) * 400,12);
glColor3f (1.0,1.0, 1.0);
circuloc(500,500,1,400);
glColor3f (1.0,0.6, 0.0);
circulo( 500- sin(h) * 450,500 + cos(h) * 450,10);
glColor3f (1.0,1.0, 1.0);
circuloc(500,500,1,450);
a+=0.01;
b+=0.02;
c+=0.03;
d+=0.04;
f+=0.05;
g+=0.06;
h+=0.07;
56

57. 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
glutSwapBuffers(); //y esto
}
SALIDA
57

58. Practica 12.
Movimiento en Ocho.
DESCRIPCIÓN.
En esta animaciòn realizaremos el movimiento de una pelota en forma de
ocho para lo cual ocuparemos lo siguiente.
BORRADOR
CODIGO
void dibuja(void)
58

59. {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(1.0, 0.9, 0.0);
circulo(200, 300, 70);
circulo(200,180,70);
glColor3f(1.0,1.0,1.0);
circulo(200,300,50);
circulo(200,180,50);
glColor3f(0.7,0.1,0.6);
if(a>=6.15 && a<=12.41){
circulo(200+ sin (a)*60,300- cos(a)*60,10);
a=a +0.01;
}
else{
circulo(200 + sin (b) *60,180+cos(b)*60,10);
b=b + 0.01;
if(b>12.4){a=6.15;b=6.15;}
for(int j=0; j<=10; j++) {}
}
glFlush();
glutSwapBuffers();
}
SALIDA
59

60. Practica 13.
Semaforo.
DESCRIPCIÓN.
Esta animaciòn como su nombre lo dice tendremos que realizar un
semaforo el cual cambie de color.
BORRADOR
60

61. CODIGO
void dibuja(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//esto
glBegin(GL_QUADS);//Cuadros fondo semaforo
glColor3f(0.0 , 0.2 , 0.2);
glVertex2i(170,437);
glVertex2i(320,437);
glVertex2i(320,182);
glVertex2i(170,182);
glVertex2i(229,183);
glVertex2i(278,183);
61

62. glVertex2i(278,3);
glVertex2i(229,3);
glEnd();
glColor3f(0.0,0.0,0.0);//Luces Verde
circulo(247,226,34);
glColor3f(0.0,0.0,0.0);//Luces Amarrilla
circulo(247,302,34);
glColor3f(0.0,0.0,0.0);//Luces Roja
circulo(247,381,34);
a=a+1; //velocidad entre mas grande mas rapido y entre menos mas lento
for(int j=1;j<=10000000;j++){}//pausa
if(a>1 && a<20){
glColor3f(1.0,0.0,0.0);//Luces Roja
circulo(247,381,34);
}
62

63. if(a>20 && a<45){
glColor3f(0.0,1.0,0.0);//Luces Roja
circulo(247,226,34);
}// se repite idefinidamente
if(a>45 && a<55){
glColor3f(0.0,1.0,0.0);//Luces Roja
circulo(247,226,34);
}// se repite idefinidamente
if(a>55 && a<55){
glColor3f(1.0,1.0,0.0);//Luces Roja
circulo(247,302,34);
}// se repite idefinidamente
if(a>50 && a<60){
glColor3f(1.0,1.0,0.0);//Luces Roja
circulo(247,302,34);
}// se repite idefinidamente
if(a>50 && a<55){
glColor3f(1.0,1.0,0.0);//Luces Roja
circulo(247,302,34);
}// se repite idefinidamente
if(a>60){a=0;}
63

64. glFlush(); //forzar dibujado
glutSwapBuffers(); //y esto
}
SALIDA
Practica 14.
Cubo 3D.
DESCRIPCIÓN.
64

65. En esta practica tendremos que realizar un cubo el cual tenga movimiento.
BORRADOR
CODIGO
void dibuja( void )
{
glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glEnable(GL_DEPTH_TEST); // Activamos el z-Buffer
glEnable(GL_LIGHTING); // Activamos la iluminación
glEnable(GL_LIGHT0); // Activamos la luz 0
65

66. //glShadeModel(GL_FLAT);
glShadeModel (GL_SMOOTH);
// Cargamos la matriz identidad para reiniciar las transformaciones
/* float angulo;
int i;
glLineWidth(20);
glBegin(GL_LINES);
glColor3d(1,1,1);
for (i=0; i<360; i+=10) {
angulo = (GLfloat)i*3.14159f/180.0f; // grados a radianes
glColor3d(1,1,1);
glVertex3i(0,0,-3);
glVertex3f(0+cos(angulo)*45, 0+sin(angulo)*45,0);
}
glEnd();*/
// Colocamos una luz
glLightfv(GL_LIGHT0,GL_DIFFUSE,(GLfloat []){1.0f,1.0f,1.0f,0.0f}); //
Color de la luz
glLightfv(GL_LIGHT0,GL_AMBIENT,(GLfloat []){1.0, 1.0, 1.0, 4.0}); //
Luz ambiente
glLightfv(GL_LIGHT0,GL_POSITION,(GLfloat []){0.0f,12.0f,5.0f,0.0f});
// Posición de la luz
glLightfv(GL_LIGHT0,GL_EMISSION,(GLfloat []){0.5,0.5,0.5,1.0});
66

67. //glShadeModel (GL_SMOOTH);
// esfera
glPushMatrix();
mover();
if(malla) creaMalla();
if(ejes) creaEjes();
//glRotatef(anguloEsfera, 1.0f, 1.0f,0.0f);
glColor3f(1.0,1.0,0.0);
//R
glTranslatef(-8.0,0.0, 0.0);
glutSolidCube(2);
glTranslatef(3.0,0.0, 0.0);
glutSolidCube(2);
glTranslatef(3.0,0.0, 0.0);
glutSolidCube(2);
glTranslatef(-6.0,3.0, 0.0);
glutSolidCube(2);
glTranslatef(0.0,3.0, 0.0);
glutSolidCube(2);
67

68. glTranslatef(3.0,-3.0, 0.0);
glutSolidCube(2);
glTranslatef(3.0,0.0, 0.0);
glutSolidCube(2);
glTranslatef(0.0,3.0, 0.0);
glutSolidCube(2);
glTranslatef(-3.0,0.0, 0.0);
glutSolidCube(2);
// AQUI PONES TU NOMBRE
//AQUI
//AQUI
//AQUI//AQUI
//AQUI//AQUI//AQUI
//AQUI
glPopMatrix ();
glFlush();
glutSwapBuffers ();
//anguloEsfera+=2.0f;
68

69. }
void reshape(int w, int h){
glClearColor(1.0,1.0,1.0,0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,15,-15,15,-30,30);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glClear(GL_DEPTH_TEST);
}
SALIDA
69

70. 70

71. Practica 15.
Nombre 3D.
DESCRIPCIÓN.
En esta practica tendremos que realizar un nombre en el cual tambien
tenga movimiento y se vean todos sus lados.
CODIGO
void dibuja( void )
{
glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glEnable(GL_DEPTH_TEST); // Activamos el z-Buffer
glEnable(GL_LIGHTING); // Activamos la iluminación
glEnable(GL_LIGHT0); // Activamos la luz 0
//glShadeModel(GL_FLAT);
glShadeModel (GL_SMOOTH);
// Cargamos la matriz identidad para reiniciar las transformaciones
/* float angulo;
int i;
glLineWidth(20);
glBegin(GL_LINES);
glColor3d(1,1,1);
for (i=0; i<360; i+=10) {
71

72. angulo = (GLfloat)i*3.14159f/180.0f; // grados a radianes
glColor3d(1,1,1);
glVertex3i(0,0,-3);
glVertex3f(0+cos(angulo)*45, 0+sin(angulo)*45,0);
}
glEnd();*/
// Colocamos una luz
glLightfv(GL_LIGHT0,GL_DIFFUSE,(GLfloat []){1.0f,1.0f,1.0f,3.0f}); // Color de la
luz
glLightfv(GL_LIGHT0,GL_AMBIENT,(GLfloat []){1.0, 7.0, 3.0, 4.0}); // Luz
ambiente
glLightfv(GL_LIGHT0,GL_POSITION,(GLfloat []){0.0f,12.0f,5.0f,13.0f}); //
Posición de la luz
glLightfv(GL_LIGHT0,GL_EMISSION,(GLfloat []){0.5,0.5,0.5,4.0});
//glShadeModel (GL_SMOOTH);
// esfera
glPushMatrix();
mover();
if(malla) creaMalla();
if(ejes) creaEjes();
//glRotatef(anguloEsfera, 1.0f, 1.0f,0.0f);
glColor3f(0.0,0.0,1.0);
//A
glTranslatef(-8.0,0.0, 0.0);
glutSolidCube(1);
72

73. glTranslatef(0.0,1.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,1.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,1.0, 0.0);
glutSolidCube(1);
glTranslatef(1.0,.0, 0.0);
glutSolidCube(1);
glTranslatef(1.0,.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(-1.0,1.0, 0.0);
glutSolidCube(1);
//l
glTranslatef(2.5,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,-1.0, 0.0);
73

74. glutSolidCube(1);
glTranslatef(0.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(1.0,-0, 0.0);
glutSolidCube(1);
//e
glTranslatef(2.0,3.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(1.0,0.0, 0.0);
glutSolidCube(1);
glTranslatef(-0.5,1.7, 0.0);
glutSolidCube(1);
glTranslatef(0.5,1.3, 0.0);
glutSolidCube(1);
//
glTranslatef(2.0,1.0, 0.0);
glutSolidCube(1);
74

75. glTranslatef(1.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(1.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(1.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(1.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(-1.0,3.0, 0.0);
glutSolidCube(1);
glTranslatef(1.0,1.0, 0.0);
glutSolidCube(1);
glTranslatef(-3.0,-3.0, 0.0);
glutSolidCube(1);
glTranslatef(-1.0,-1.0, 0.0);
glutSolidCube(1);
// AQUI PONES TU NOMBRE
//AQUI
//AQUI
75

76. //AQUI//AQUI
//AQUI//AQUI//AQUI
//AQUI
glPopMatrix ();
glFlush();
SALIDA
76

77. Practica Extra
Piramide.
DESCRIPCIÓN.
En esta actividad realizaremos con funciones en 3D el nombre de
nosotros en cual tenga movimiento con el mouse y se vea en tercera
dimensión.
BORRADOR
77

78. CODIGO
void dibuja(void) //funcion dibuja
{
int i,a=4;
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(1.0 , 1.0 , 1.0);
glLineWidth(2);
glBegin(GL_LINES);
//valor inicial ---- valor final o condicion ---- incremento
for(i=1;i<=10;i++){
//abajo
glVertex2i (240-a*i,240-a*i);
glVertex2i (260+a*i,240-a*i);
//derecha
glVertex2i (260+a*i,240-a*i);
glVertex2i (260+a*i,260+a*i);
//izquierda
glVertex2i (240-a*i,240-a*i);
glVertex2i (240-a*i,260+a*i);
//arriba
glVertex2i (240-a*i,260+a*i);
glVertex2i (260+a*i,260+a*i);
//linneas izquierdas
78

79. glColor3f(1.0 , 1.0 , 1.0);
glBegin(GL_LINES);
glVertex2i (236,236);
glVertex2i (232,232);
glVertex2i (228,228);
glVertex2i (224,224);
glVertex2i (220,220);
glVertex2i (216,216);
glVertex2i (212,212);
glVertex2i (208,208);
glVertex2i (204,204);
glVertex2i (200,200);
//derechas
glVertex2i (264,236);
glVertex2i (268,232);
glVertex2i (272,228);
glVertex2i (276,224);
79

80. glVertex2i (280,220);
glVertex2i (284,216);
glVertex2i (288,212);
glVertex2i (292,208);
glVertex2i (296,204);
glVertex2i (300,200);
//der arriba
glVertex2i (264,264);
glVertex2i (268,268);
glVertex2i (272,272);
glVertex2i (276,276);
glVertex2i (280,280);
glVertex2i (284,284);
glVertex2i (288,288);
glVertex2i (292,292);
glVertex2i (296,296);
glVertex2i (300,300);
80

81. //izq arriba
glVertex2i (236,264);
glVertex2i (232,268);
glVertex2i (228,272);
glVertex2i (224,276);
glVertex2i (220,280);
glVertex2i (216,284);
glVertex2i (212,288);
glVertex2i (208,292);
glVertex2i (204,296);
glVertex2i (200,300);
}
glEnd();
glFlush(); //forza dibujo
}
81

82. SALIDA
82