Este documento presenta 14 prácticas de diseño utilizando el software OpenGL. La introducción explica que OpenGL es una API para crear gráficos 2D y 3D a partir de primitivas geométricas como puntos, líneas y triángulos. Las prácticas 1-4 muestran cómo crear formas básicas como un tablero de ajedrez, una estrella, un cubo con líneas y un cubo delineado utilizando comandos como glBegin, glVertex y glEnd.

1. CECYTEM PLANTEL TECAMAC
(Colegio de Estudios Científicos y Tecnológicos del Estado de México)
Integrantes:
Ana Karen Avila Enciso
Jesica González Aguilar
Grupo: 303
N.L. 1 N.L. 14
Materia:
Utilización de Software de Diseño
Especialidad: Técnico en Informática.
Profesor: René Domínguez Escalona
Manual de Practicas del Segundo Parcial

2. Índice
 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ñeo con Formas
 10.-Animacion del Circulo
 11.-Animacion del Sistema Solar
 12.-Movimiento en Ocho
 13.-Semaforo
 14.-Piramide

3. INTRODUCCION.
OpenGL (Open Graphics Library) es una especificación estándar que define
una API multilenguaje y multiplataforma para escribir aplicaciones que produzcan
gráficos 2D y3D. 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. Fue
desarrollada originalmente por Silicón Graphics Inc. (SGI) en 19922 y se usa
ampliamente en CAD, realidad virtual, representación científica, visualización de
información y simulación de vuelo. También se usa en desarrollo de videojuegos,
donde compite con Direct3D en plataformas Microsoft Windows
OpenGL tiene dos propósitos esenciales:
Ocultar la complejidad de la interfaz con las diferentes tarjetas gráficas,
presentando al programador una API única y uniforme.
Ocultar las diferentes capacidades de las diversas plataformas hardware,
requiriendo que todas las implementaciones soporten la funcionalidad completa de
OpenGL (utilizando emulación software si fuese necesario).
El funcionamiento básico de OpenGL consiste en aceptar primitivas tales como
puntos, líneas y polígonos, y convertirlas en píxeles. Este proceso es realizado por
una pipeline gráfica conocida como Máquina de estados de OpenGL.8 La mayor
parte de los comandos de OpenGL bien emiten primitivas a la pipeline gráfica o
bien configuran cómo la pipeline procesa dichas primitivas. Hasta la aparición de
la versión 2.0 cada etapa de la pipeline ejecutaba una función prefijada, resultando
poco configurable. A partir de la versión 2.0 algunas etapas son programables
usando un lenguaje de programación llamado GLSL.
OpenGL es una API basada en procedimientos de bajo nivel que requiere que el
programador dicte los pasos exactos necesarios para renderizar una escena. Esto
contrasta con las Apis descriptivas, donde un programador sólo debe describir la
escena y puede dejar que la biblioteca controle los detalles para representarla. El
diseño de bajo nivel de OpenGL requiere que los programadores conozcan en
profundidad la pipeline gráfica, a cambio de darles libertad para implementar
algoritmos gráficos novedosos.

4. Tablero de Ajedrez
Presentación o descripción:
En esta práctica realizaremos una tablero de Ajedrez con puntos esta solo para
empezar a poner en práctica la utilización de este programa.
Esta es la practica numero 1 y con esta empezamos a ver si es posible entenderle
a este programa.
Los cuadros deben de ir de color blanco y negro y este es el código para su
realización.
GlBegin (GL_POINTS);
Y
glPointSize(60); (Para definer el tamaño de los puntos)
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, 1050.0, 0.0, 1000.0); //vista ortogonal
}

5. 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);

6. glVertex2i(597,580);
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);

7. 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

8. 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
}

9. Estrella
Presentación o descripción:
En esta práctica realizaremos una estrella como con puras líneas.
Esta es la practica numero 2 y con esta empezamos utilizaremos solamente líneas
que es la siguiente instrucción:
glBegin(GL_LINES);
Codigo:
//mi primer ventana
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
void inicializa(void)
{
glClearColor(0.0,0.0,0.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(1.0 , 0.0 , 0.0);

10. 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();

11. glutDisplayFunc(dibuja); //Envia los graficos a la ventana de
visualización
glutMainLoop(); //muestra todo y espera
return 0; //retorna un valor de cero
}
Y asi es como queda:

12. Cubo con Líneas
Presentación o descripción:
En esta práctica realizamos un cubo con puras líneas asiendo el efecto para que
se vea como en 3D pero aun no se vera asi.
Esta es la practica numero 3 y en esta aprenderemos a utilizar aun mas y poner
en practica las líneas.
En esta práctica podemos utilizar las siguientes instrucciones que ya hemos
aprendido como se utilizan en todas las clases anteriores:
glBegin(GL_LINES);
Codigo:
//TABLERO DE AJEDREZ
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
void inicializa(void)
{
glClearColor(0.0,0.0,0.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
}

13. 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);

14. glVertex2i(600,600);
glVertex2i(600,300);
glVertex2i(600,600);
glVertex2i(300,600);
glVertex2i(600,600);
glVertex2i(400,400);
glVertex2i(600,300);
glVertex2i(400,100);
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

15. return 0; //retorna un valor de cero
}
Asi es como queda:

16. Cubo delineado
Presentación o descripción:
En esta práctica realizamos un cubo pro tendremos que marcar muy bien sus
líneas para darle otro tipo de vista
Esta es la practica numero 4 y en esta aprenderemos a utilizar aun mas y poner
en practica las líneas.
En esta práctica podemos utilizar las siguientes instrucciones que ya hemos
aprendido como se utilizan en todas las clases anteriores:
glBegin(GL_LINES);
glBegin(GL_QUADS);
Codigo:
//TABLERO DE AJEDREZ
#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
}

17. void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(1.0 , 1.0 , 0.0);
glBegin(GL_QUADS);
glColor3f(0.0,1.0,1.0);
glVertex2i(100,100);
glVertex2i(100,200);
glVertex2i(200,200);
glVertex2i(200,100);
glColor3f(0.0,1.0,0.0);
glVertex2i(200,100);
glVertex2i(200,200);
glVertex2i(250,250);
glVertex2i(250,150);
glColor3f(1.0,0.0,0.0);
glVertex2i(250,250);
glVertex2i(150,250);
glVertex2i(100,200);
glVertex2i(200,200);
glEnd();
glLineWidth(3);

18. glBegin(GL_LINES);
glColor3f(0.0,0.0,0.0);
glVertex2i(100,100);
glVertex2i(100,200);
glVertex2i(200,200);
glVertex2i(200,100);
glVertex2i(100,200);
glVertex2i(200,200);
glVertex2i(100,100);
glVertex2i(200,100);
glVertex2i(200,200);
glVertex2i(200,100);
glVertex2i(100,200);
glVertex2i(150,250);
glVertex2i(200,200);
glVertex2i(250,250);
glVertex2i(200,100);
glVertex2i(250,150);
glVertex2i(150,250);
glVertex2i(250,250);

19. glVertex2i(250,250);
glVertex2i(250,150);
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
}

21. Casita
Presentación o descripción:
En esta práctica realizamos una casa utilizando todo tipo de figuras
acomodándolas en un orden para que represente una casita
Esta es la practica número 6.
En esta práctica podemos utilizar las siguientes instrucciones que ya hemos
aprendido como se utilizan en todas las clases anteriores:
glBegin(GL_QUADS);
glBegin(GL_LINES);
glBegin(GL_POLYGON);
glBegin(GL_TRIANGLES);
glBegin(GL_POINTS);
//mi primer ventana
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
void inicializa(void)
{
glClearColor(0.0,0.0,0.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

22. }
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(0.0 , 0.0 , 0.0);
//carretera
glBegin(GL_QUADS);
glVertex2i(0,200);
glVertex2i(0,0);
glVertex2i(1000,0);
glVertex2i(1000,200);
glEnd();
glColor3f(1.0 , 1.0 , 0.0);
glLineWidth(4);
glBegin(GL_LINES);
glVertex2i(10,100);
glVertex2i(100,100);
glVertex2i(200,100);
glVertex2i(300,100);
glVertex2i(400,100);
glVertex2i(500,100);
glVertex2i(600,100);
glVertex2i(700,100);

23. glVertex2i(800,100);
glVertex2i(900,100);
glVertex2i(980,100);
glVertex2i(1000,100);
glEnd();
//pasto
glColor3f(0.3 , 1.0 , 0.2);
glBegin(GL_QUADS);
glVertex2i(0,500);
glVertex2i(0,200);
glVertex2i(1000,200);
glVertex2i(1000,500);
glEnd();
//linea amarilla
glColor3f(1.0 , 0.0 , 1.0);
glLineWidth(8);
glBegin(GL_LINES);
glVertex2i(0,200);
glVertex2i(1000,200);
glEnd();
//banqueta
glColor3f(0.2 , 0.8 , 1.0);
glLineWidth(50);
glBegin(GL_QUADS);

24. glVertex2i(0,208);
glVertex2i(0,300);
glVertex2i(1000,300);
glVertex2i(1000,208);
glVertex2i(440,300);
glVertex2i(440,450);
glVertex2i(560,450);
glVertex2i(560,300);
glEnd();
glColor3f(0.5 , 0.5 , 0.5);
glBegin(GL_QUADS);
glVertex2i(200,350);
glVertex2i(200,380);
glVertex2i(250,380);
glVertex2i(250,350);
glVertex2i(150,350);
glVertex2i(150,380);
glVertex2i(100,380);
glVertex2i(100,350);
glVertex2i(200,400);
glVertex2i(200,430);
glVertex2i(250,430);

25. glVertex2i(250,400);
glVertex2i(150,400);
glVertex2i(150,430);
glVertex2i(100,430);
glVertex2i(100,400);
glEnd();
//serca
glColor3f(1.0 , 0.0 , 1.0);
glBegin(GL_POLYGON);
glVertex2i(0,540);
glVertex2i(0,480);
glVertex2i(20,480);
glVertex2i(20,540);
glVertex2i(10,550);
glEnd();
glBegin(GL_POLYGON);
glVertex2i(40,540);
glVertex2i(40,480);
glVertex2i(60,480);
glVertex2i(60,540);
glVertex2i(50,550);
glEnd();
glBegin(GL_POLYGON);
glVertex2i(710,540);

26. glVertex2i(710,480);
glVertex2i(730,480);
glVertex2i(730,540);
glVertex2i(720,550);
glEnd();
glBegin(GL_POLYGON);
glVertex2i(750,540);
glVertex2i(750,480);
glVertex2i(770,480);
glVertex2i(770,540);
glVertex2i(760,550);
glEnd();
glBegin(GL_POLYGON);
glVertex2i(790,540);
glVertex2i(790,480);
glVertex2i(810,480);
glVertex2i(810,540);
glVertex2i(800,550);
glEnd();
glBegin(GL_POLYGON);
glVertex2i(830,540);
glVertex2i(830,480);
glVertex2i(850,480);
glVertex2i(850,540);
glVertex2i(840,550);

27. glEnd();
glBegin(GL_POLYGON);
glVertex2i(870,540);
glVertex2i(870,480);
glVertex2i(890,480);
glVertex2i(890,540);
glVertex2i(880,550);
glEnd();
glBegin(GL_POLYGON);
glVertex2i(910,540);
glVertex2i(910,480);
glVertex2i(930,480);
glVertex2i(930,540);
glVertex2i(920,550);
glEnd();
glBegin(GL_POLYGON);
glVertex2i(950,540);
glVertex2i(950,480);
glVertex2i(970,480);
glVertex2i(970,540);
glVertex2i(960,550);
glEnd();
glBegin(GL_POLYGON);
glVertex2i(990,540);
glVertex2i(990,480);

28. glVertex2i(1010,480);
glVertex2i(1010,540);
glVertex2i(1000,550);
glEnd();
glColor3f(1.0 , 1.0 , 0.0);
glLineWidth(10);
glBegin(GL_LINES);
glVertex2i(0,520);
glVertex2i(1000,520);
glEnd();
//casa
glColor3f(0.2 , 0.1 , 1.0);
glBegin(GL_QUADS);
glVertex2i(300,750);
glVertex2i(300,450);
glVertex2i(700,450);
glVertex2i(700,750);
glEnd();
glColor3f(0.0 , 0.0 , 1.0);
glLineWidth(14);
glBegin(GL_LINES);
glVertex2i(300,600);
glVertex2i(700,600);
glVertex2i(440,450);
glVertex2i(440,750);

29. glVertex2i(560,450);
glVertex2i(560,750);
glEnd();
//techo casa
glColor3f(1.0 , 1.0 , 0.0);
glBegin(GL_POLYGON);
glVertex2i(300,820);
glVertex2i(240,750);
glVertex2i(760,750);
glVertex2i(700,820);
glEnd();
//triangulo techo casa
glColor3f(1.0 , 0.9 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(600,720);
glVertex2i(500,800);
glVertex2i(400,720);
glEnd();
//puerta casa
glColor3f(1.0 , 1.0 , 1.0);
glBegin(GL_QUADS);
glVertex2i(454,450);
glVertex2i(454,570);
glVertex2i(546,570);
glVertex2i(546,450);

30. glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(474,470);
glVertex2i(474,550);
glVertex2i(526,550);
glVertex2i(526,470);
glEnd();
glColor3f(0.0 ,0.0 , 0.0);
glPointSize(3);
glBegin(GL_POINTS);
glVertex2i(464,505);
glEnd();
//ventanas casa
glColor3f(1.0 , 0.0 , 1.0);
glBegin(GL_QUADS);
glVertex2i(320,570);
glVertex2i(320,510);
glVertex2i(400,510);
glVertex2i(400,570);
glVertex2i(595,570);
glVertex2i(595,510);
glVertex2i(675,510);
glVertex2i(675,570);
glVertex2i(320,730);

31. glVertex2i(320,660);
glVertex2i(400,660);
glVertex2i(400,730);
glVertex2i(595,730);
glVertex2i(595,660);
glVertex2i(675,660);
glVertex2i(675,730);
glEnd();
glColor3f(1.0 , 1.0 , 1.0);
glLineWidth(4);
glBegin(GL_LINES);
glVertex2i(320,570);
glVertex2i(320,510);
glVertex2i(320,510);
glVertex2i(400,510);
glVertex2i(400,510);
glVertex2i(400,570);
glVertex2i(400,570);
glVertex2i(320,570);
glVertex2i(320,530);
glVertex2i(400,530);
glVertex2i(360,530);
glVertex2i(360,510);

32. glVertex2i(595,570);
glVertex2i(595,510);
glVertex2i(595,510);
glVertex2i(675,510);
glVertex2i(675,510);
glVertex2i(675,570);
glVertex2i(675,570);
glVertex2i(595,570);
glVertex2i(595,530);
glVertex2i(675,530);
glVertex2i(635,530);
glVertex2i(635,510);
glVertex2i(320,730);
glVertex2i(320,660);
glVertex2i(320,660);
glVertex2i(400,660);
glVertex2i(400,660);
glVertex2i(400,730);
glVertex2i(400,730);
glVertex2i(320,730);
glVertex2i(320,680);
glVertex2i(400,680);
glVertex2i(360,680);
glVertex2i(360,660);

33. glVertex2i(595,730);
glVertex2i(595,660);
glVertex2i(595,660);
glVertex2i(675,660);
glVertex2i(675,660);
glVertex2i(675,730);
glVertex2i(675,730);
glVertex2i(595,730);
glVertex2i(595,680);
glVertex2i(675,680);
glVertex2i(635,680);
glVertex2i(635,660);
glEnd();
//balcon casa
glColor3f(1.0 , 0.0 , 1.0);
glBegin(GL_QUADS);
glVertex2i(454,720);
glVertex2i(454,600);
glVertex2i(546,600);
glVertex2i(546,720);
glEnd();
glColor3f(1.0 , 1.0, 1.0);
glLineWidth(3);

34. glBegin(GL_LINES);
glVertex2i(455,640);
glVertex2i(455,600);
glVertex2i(467,640);
glVertex2i(467,600);
glVertex2i(479,640);
glVertex2i(479,600);
glVertex2i(491,640);
glVertex2i(491,600);
glVertex2i(503,640);
glVertex2i(503,600);
glVertex2i(515,640);
glVertex2i(515,600);
glVertex2i(527,640);
glVertex2i(527,600);
glVertex2i(539,640);
glVertex2i(539,600);
glVertex2i(455,640);
glVertex2i(546,640);
glVertex2i(505,640);
glVertex2i(505,720);
glEnd();
//cochera
glColor3f(1.0 , 0.0 , 1.0);
glBegin(GL_QUADS);

35. glVertex2i(90,450);
glVertex2i(90,600);
glVertex2i(300,600);
glVertex2i(300,450);
glEnd();
glColor3f(0.0 , 0.0, 1.0);
glLineWidth(12);
glBegin(GL_LINES);
glVertex2i(90,450);
glVertex2i(90,600);
glEnd();
//techo cochera
glColor3f(1.0 , 1.0 , 0.0);
glBegin(GL_POLYGON);
glVertex2i(90,660);
glVertex2i(60,600);
glVertex2i(300,600);
glVertex2i(300,660);
glEnd();
//pinos
glColor3f(0.5 , 0.0 , 0.3);
glBegin(GL_QUADS);
glVertex2i(850,450);
glVertex2i(900,450);
glVertex2i(900,530);

36. glVertex2i(850,530);
glEnd();
int i,a=9;
glColor3f(0.3 , 1.0 , 0.2);
glLineWidth(3);
glBegin(GL_LINES);
for(i=0;i<=14;i++){
glVertex2i(1000-a*i,530+a*i);
glVertex2i(740+a*i,530+a*i);
}
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(750,750); //tamaño de la ventana
glutInitWindowPosition(0,0); //posicion inicial de la ventana
glutCreateWindow("MI primer ventana"); //nombre de la ventana
inicializa();

37. glutDisplayFunc(dibuja); //Envia los graficos a la ventana de
visualización
glutMainLoop(); //muestra todo y espera
return 0; //retorna un valor de cero
}

38. Osita
Presentación o descripción:
En esta práctica realizamos un osito en este caso nosotras hicimos osita y
aprenderemos a manejar los circulos
Esta es la practica numero 7 y debemos de utilizar puros círculos para su
realizacion
En esta práctica podemos utilizar las siguientes instrucciones que ya hemos
aprendido como se utilizan en todas las clases anteriores:
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);

39. for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x +
sin(angulo) * radio, y + cos(angulo) * radio);}
glEnd();
El código que utilizamos en esta práctica es el siguiente:
//mi primer ventana
#include <GL/glut.h>
#include <GL/gl.h>
#include <math.h>
void inicializa(void)
{
glClearColor(0.2,0.8,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);}

40. 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);
//cuerpo del osito
glColor3f(1.0,0.1,0.7); //borra pantalla
circulo(250,250,100);
//cabeza del osito
glColor3f(1.0,0.1,0.7); //borra pantalla
circulo(250,400,75);
//pansiita

41. glColor3f(1.0,0.0,1.0); //borra pantalla
circulo(250,250,75);
//piessitos del osito
glColor3f(1.0,0.1,0.7); //borra pantalla
circulo(175,175,25);
//piessitos del osito
glColor3f(1.0,0.1,0.7); //borra pantalla
circulo(320,175,25);
//orejitas del osito
glColor3f(1.0,0.1,0.7); //borra pantalla
circulo(300,475,25);
//orejitas del osito
glColor3f(1.0,0.1,0.7); //borra pantalla
circulo(200,475,25);
//manitas del osito
glColor3f(1.0,0.1,0.7); //borra pantalla
circulo(150,300,25);
//manitas del osito
glColor3f(1.0,0.1,0.7); //borra pantalla
circulo(350,300,25);
//ojitos del osito
glColor3f(0.0,0.0,0.0); //borra pantalla
circulo(230,425,15);
//ojitos del osito
glColor3f(0.0,0.0,0.0); //borra pantalla

42. circulo(275,425,15);
//nariz del osito
glColor3f(0.0,0.0,0.0); //borra pantalla
circulo(250,400,5);
//boca dl osito
glColor3f(0.0,0.0,0.0); //borra pantalla
circulo(250,375,15);
//ojitos del osito
glColor3f(1.0,1.0,1.0); //borra pantalla
circulo(230,425,5);
//ojitos del osito
glColor3f(1.0,1.0,1.0); //borra pantalla
circulo(275,425,5);
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(100,100); //posicion inicial de la ventana
glutCreateWindow("Ventana"); //nombre de la ventana

43. inicializa();
glutDisplayFunc(dibuja); //Envia los graficos a la ventana de
visualización
glutMainLoop(); //muestra todo y espera
return 0; //retorna un valor de cero
}

44. Cubo con Cubitos
Presentación o descripción:
En esta práctica realizamos un cubo echo de cubitos pequeños
Esta es la practica numero 8 y utilizaremos puros cubitos.
En esta práctica podemos utilizar las siguientes instrucciones que ya hemos
aprendido como se utilizan en todas las clases anteriores:
glBegin(GL_QUADS);
El código que utilizamos en esta práctica es el siguiente:
//mi primer ventana
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
void inicializa(void)
{
glClearColor(0.0,0.0,.0,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

45. {
int i,a=100;
glClear(GL_COLOR_BUFFER_BIT);
for(i=0;i<=10;i++){
glColor3f(1.0 ,0.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(700,600+a*i);
glVertex2i(700,700+a*i);
//arriva
glVertex2i(750,750+a*i);
//derecha
glVertex2i(750,650+a*i);

46. glEnd();
glColor3f(1.0 ,1.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(600,600+a*i);
glVertex2i(600,700+a*i);
//arriva
glVertex2i(700,700+a*i);
//derecha
glVertex2i(700,600+a*i);
//abajo
glEnd();
glColor3f(1.0 ,0.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(600,700+a*i);

47. glVertex2i(650,750+a*i);
//arriva
glVertex2i(750,750+a*i);
//derecha
glVertex2i(700,700+a*i);
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(600,600+a*i);
glVertex2i(600,700+a*i);
//arriva
glVertex2i(600,700+a*i);
glVertex2i(700,700+a*i);
//derecha
glVertex2i(700,700+a*i);
glVertex2i(700,600+a*i);
//abajo
glVertex2i(700,600+a*i);
glVertex2i(600,600+a*i);

48. //diagonal derecha esquina arriva
glVertex2i(650,750+a*i);
glVertex2i(600,700+a*i);
//linea cuadro atras
//linea cuadro atras
glVertex2i(650,750+a*i);
glVertex2i(750,750+a*i);
//linea derecha atras
glVertex2i(750,750+a*i);
glVertex2i(750,650+a*i);
//linea abajo derecha diagonal
glVertex2i(700,600+a*i);
glVertex2i(750,650+a*i);
//linea arriva derecha diagonal
glVertex2i(700,700+a*i);
glVertex2i(750,750+a*i);
glEnd();
}

49. ////////////////////////////////////////////////////////////////////////
for(i=0;i<=10;i++){
glColor3f(1.0 ,0.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(1700,1600);
glVertex2i(1700,1700);
//arriva
glVertex2i(1750,1750);
//derecha
glVertex2i(1750,1650);
glEnd();
glColor3f(1.0 ,1.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro

50. //izquierda
glVertex2i(1600-a*i,1600);
glVertex2i(1600-a*i,1700);
//arriva
glVertex2i(1700-a*i,1700);
//derecha
glVertex2i(1700-a*i,1600);
//abajo
glEnd();
glColor3f(1.0 ,0.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1600-a*i,1700);
glVertex2i(1650-a*i,1750);
//arriva
glVertex2i(1750-a*i,1750);
//derecha
glVertex2i(1700-a*i,1700);
//abajo

51. glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(1600-a*i,1600);
glVertex2i(1600-a*i,1700);
//arriva
glVertex2i(1600-a*i,1700);
glVertex2i(1700-a*i,1700);
//derecha
glVertex2i(1700-a*i,1700);
glVertex2i(1700-a*i,1600);
//abajo
glVertex2i(1700-a*i,1600);
glVertex2i(1600-a*i,1600);
//diagonal derecha esquina arriva
glVertex2i(1650-a*i,1750);
glVertex2i(1600-a*i,1700);
//linea cuadro atras
//linea cuadro atras
glVertex2i(1650-a*i,1750);

52. glVertex2i(1750-a*i,1750);
//linea derecha atras
glVertex2i(1750,1750);
glVertex2i(1750,1650);
//linea abajo derecha diagonal
glVertex2i(1700,1600);
glVertex2i(1750,1650);
//linea arriva derecha diagonal
glVertex2i(1700-a*i,1700);
glVertex2i(1750-a*i,1750);
glEnd();
}
///////////////////////////////////////////////////////////////////////
for(i=0;i<=9;i++){
glColor3f(1.0 ,0.0 ,0.0 );

53. glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(1700,600);
glVertex2i(1700,700);
//arriva
glVertex2i(1750,750);
//derecha
glVertex2i(1750,650);
glEnd();
glColor3f(1.0 ,0.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1600-a*i,600);
glVertex2i(1600-a*i,700);
//arriva
glVertex2i(1700-a*i,700);

54. //derecha
glVertex2i(1700-a*i,600);
//abajo
glEnd();
glColor3f(1.0 ,1.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1600-a*i,700);
glVertex2i(1650-a*i,750);
//arriva
glVertex2i(1750-a*i,750);
//derecha
glVertex2i(1700-a*i,700);
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);

55. //cuadro
//izquierda
glVertex2i(1600-a*i,600);
glVertex2i(1600-a*i,700);
//arriva
glVertex2i(1600-a*i,700);
glVertex2i(1700-a*i,700);
//derecha
glVertex2i(1700-a*i,700);
glVertex2i(1700-a*i,600);
//abajo
glVertex2i(1700-a*i,600);
glVertex2i(1600-a*i,600);
//diagonal derecha esquina arriva
glVertex2i(1650-a*i,750);
glVertex2i(1600-a*i,700);
//linea cuadro atras
//linea cuadro atras
glVertex2i(1650-a*i,750);
glVertex2i(1750-a*i,750);
//linea derecha atras
glVertex2i(1750,750);
glVertex2i(1750,650);

56. //linea abajo derecha diagonal
glVertex2i(1700,600);
glVertex2i(1750,650);
//linea arriva derecha diagonal
glVertex2i(1700-a*i,700);
glVertex2i(1750-a*i,750);
glEnd();
}
//////////////////////////////////////////////////////////////////////
for(i=0;i<=10;i++){
glColor3f(1.0 ,0.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(1700,600+a*i);

57. glVertex2i(1700,700+a*i);
//arriva
glVertex2i(1750,750+a*i);
//derecha
glVertex2i(1750,650+a*i);
glEnd();
glColor3f(1.0 ,1.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1600,600+a*i);
glVertex2i(1600,700+a*i);
//arriva
glVertex2i(1700,700+a*i);
//derecha
glVertex2i(1700,600+a*i);
//abajo

58. glEnd();
glColor3f(1.0 ,1.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1600,700+a*i);
glVertex2i(1650,750+a*i);
//arriva
glVertex2i(1750,750+a*i);
//derecha
glVertex2i(1700,700+a*i);
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(1600,600+a*i);
glVertex2i(1600,700+a*i);

59. //arriva
glVertex2i(1600,700+a*i);
glVertex2i(1700,700+a*i);
//derecha
glVertex2i(1700,700+a*i);
glVertex2i(1700,600+a*i);
//abajo
glVertex2i(1700,600+a*i);
glVertex2i(1600,600+a*i);
//diagonal derecha esquina arriva
glVertex2i(1650,750+a*i);
glVertex2i(1600,700+a*i);
//linea cuadro atras
//linea cuadro atras
glVertex2i(1650,750+a*i);
glVertex2i(1750,750+a*i);
//linea derecha atras
glVertex2i(1750,750+a*i);
glVertex2i(1750,650+a*i);
//linea abajo derecha diagonal
glVertex2i(1700,600+a*i);
glVertex2i(1750,650+a*i);
//linea arriva derecha diagonal
glVertex2i(1700,700+a*i);

60. glVertex2i(1750,750+a*i);
glEnd();
}
for(i=0;i<=9;i++){
glColor3f(1.0 ,0.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(200+(50*i),100+(50*i));
glVertex2i(200+(50*i),200+(50*i));
//arriva
glVertex2i(250+(50*i),250+(50*i));
//derecha
glVertex2i(250+(50*i),150+(50*i));

61. glEnd();
glColor3f(1.0 ,1.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(100,100);
glVertex2i(100,200);
//arriva
glVertex2i(200,200);
//derecha
glVertex2i(200,100);
//abajo
glEnd();
glColor3f(1.0 ,1.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(100+(50*i),200+(50*i));

62. glVertex2i(150+(50*i),250+(50*i));
//arriva
glVertex2i(250+(50*i),250+(50*i));
//derecha
glVertex2i(200+(50*i),200+(50*i));
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(100,100);
glVertex2i(100,200);
//arriva
glVertex2i(100+(50*i),200+(50*i));
glVertex2i(200+(50*i),200+(50*i));
//derecha
glVertex2i(200+(50*i),200+(50*i));
glVertex2i(200+(50*i),100+(50*i));
//abajo
glVertex2i(200,100);
glVertex2i(100,100);

63. //diagonal derecha esquina arriva
glVertex2i(150+(50*i),250+(50*i));
glVertex2i(100+(50*i),200+(50*i));
//linea cuadro atras
//linea cuadro atras
glVertex2i(150+(50*i),250+(50*i));
glVertex2i(250+(50*i),250+(50*i));
//linea derecha atras
glVertex2i(250+(50*i),250+(50*i));
glVertex2i(250+(50*i),150+(50*i));
//linea abajo derecha diagonal
glVertex2i(200+(50*i),100+(50*i));
glVertex2i(250+(50*i),150+(50*i));
//linea arriva derecha diagonal
glVertex2i(200+(50*i),200+(50*i));
glVertex2i(250+(50*i),250+(50*i));
glEnd();
}
///////////////////////////////////////////////////////
for(i=0;i<=9;i++){
glColor3f(1.0 ,0.0 ,0.0 );

64. glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(1200+(50*i),100+(50*i));
glVertex2i(1200+(50*i),200+(50*i));
//arriva
glVertex2i(1250+(50*i),250+(50*i));
//derecha
glVertex2i(1250+(50*i),150+(50*i));
glEnd();
glColor3f(1.0 ,1.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1100,100);
glVertex2i(1100,200);
//arriva

65. glVertex2i(1200,200);
//derecha
glVertex2i(1200,100);
//abajo
glEnd();
glColor3f(1.0 ,1.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1100+(50*i),200+(50*i));
glVertex2i(1150+(50*i),250+(50*i));
//arriva
glVertex2i(1250+(50*i),250+(50*i));
//derecha
glVertex2i(1200+(50*i),200+(50*i));
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);

66. glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(1100,100);
glVertex2i(1100,200);
//arriva
glVertex2i(1100+(50*i),200+(50*i));
glVertex2i(1200+(50*i),200+(50*i));
//derecha
glVertex2i(1200+(50*i),200+(50*i));
glVertex2i(1200+(50*i),100+(50*i));
//abajo
glVertex2i(1200,100);
glVertex2i(1100,100);
//diagonal derecha esquina arriva
glVertex2i(1150+(50*i),250+(50*i));
glVertex2i(1100+(50*i),200+(50*i));
//linea cuadro atras
//linea cuadro atras
glVertex2i(1150+(50*i),250+(50*i));
glVertex2i(1250+(50*i),250+(50*i));
//linea derecha atras
glVertex2i(1250+(50*i),250+(50*i));
glVertex2i(1250+(50*i),150+(50*i));

67. //linea abajo derecha diagonal
glVertex2i(1200+(50*i),100+(50*i));
glVertex2i(1250+(50*i),150+(50*i));
//linea arriva derecha diagonal
glVertex2i(1200+(50*i),200+(50*i));
glVertex2i(1250+(50*i),250+(50*i));
glEnd();
}
////////////////////////////////////////////////////////
for(i=0;i<=9;i++){
glColor3f(1.0 ,0.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(200+(50*i),1100+(50*i));
glVertex2i(200+(50*i),1200+(50*i));
//arriva

68. glVertex2i(250+(50*i),1250+(50*i));
//derecha
glVertex2i(250+(50*i),1150+(50*i));
glEnd();
glColor3f(1.0 ,1.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(100,1100);
glVertex2i(100,1200);
//arriva
glVertex2i(200,1200);
//derecha
glVertex2i(200,1100);
//abajo
glEnd();
glColor3f(1.0 ,1.0 ,0.0 );

69. glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(100+(50*i),1200+(50*i));
glVertex2i(150+(50*i),1250+(50*i));
//arriva
glVertex2i(250+(50*i),1250+(50*i));
//derecha
glVertex2i(200+(50*i),1200+(50*i));
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(100,1100);
glVertex2i(100,1200);
//arriva
glVertex2i(100+(50*i),1200+(50*i));
glVertex2i(200+(50*i),1200+(50*i));

70. //derecha
glVertex2i(200+(50*i),1200+(50*i));
glVertex2i(200+(50*i),1100+(50*i));
//abajo
glVertex2i(200,1100);
glVertex2i(100,1100);
//diagonal derecha esquina arriva
glVertex2i(150+(50*i),1250+(50*i));
glVertex2i(100+(50*i),1200+(50*i));
//linea cuadro atras
//linea cuadro atras
glVertex2i(150+(50*i),1250+(50*i));
glVertex2i(250+(50*i),1250+(50*i));
//linea derecha atras
glVertex2i(250+(50*i),1250+(50*i));
glVertex2i(250+(50*i),1150+(50*i));
//linea abajo derecha diagonal
glVertex2i(200+(50*i),1100+(50*i));
glVertex2i(250+(50*i),1150+(50*i));
//linea arriva derecha diagonal
glVertex2i(200+(50*i),1200+(50*i));
glVertex2i(250+(50*i),1250+(50*i));

71. glEnd();
}
////////////////////////////////////////////////////////////
for(i=0;i<=9;i++){
glColor3f(1.0 ,0.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(1200+(50*i),1100+(50*i));
glVertex2i(1200+(50*i),1200+(50*i));
//arriva
glVertex2i(1250+(50*i),1250+(50*i));
//derecha
glVertex2i(1250+(50*i),1150+(50*i));
glEnd();
glColor3f(1.0 ,1.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);

72. //cuadro
//izquierda
glVertex2i(1100,1100);
glVertex2i(1100,1200);
//arriva
glVertex2i(1200,1200);
//derecha
glVertex2i(1200,1100);
//abajo
glEnd();
glColor3f(1.0 ,1.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1100+(50*i),1200+(50*i));
glVertex2i(1150+(50*i),1250+(50*i));
//arriva
glVertex2i(1250+(50*i),1250+(50*i));
//derecha

73. glVertex2i(1200+(50*i),1200+(50*i));
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(1100,1100);
glVertex2i(1100,1200);
//arriva
glVertex2i(1100+(50*i),1200+(50*i));
glVertex2i(1200+(50*i),1200+(50*i));
//derecha
glVertex2i(1200+(50*i),1200+(50*i));
glVertex2i(1200+(50*i),1100+(50*i));
//abajo
glVertex2i(1200,1100);
glVertex2i(1100,1100);
//diagonal derecha esquina arriva
glVertex2i(1150+(50*i),1250+(50*i));
glVertex2i(1100+(50*i),1200+(50*i));
//linea cuadro atras

74. //linea cuadro atras
glVertex2i(1150+(50*i),1250+(50*i));
glVertex2i(1250+(50*i),1250+(50*i));
//linea derecha atras
glVertex2i(1250+(50*i),1250+(50*i));
glVertex2i(1250+(50*i),1150+(50*i));
//linea abajo derecha diagonal
glVertex2i(1200+(50*i),1100+(50*i));
glVertex2i(1250+(50*i),1150+(50*i));
//linea arriva derecha diagonal
glVertex2i(1200+(50*i),1200+(50*i));
glVertex2i(1250+(50*i),1250+(50*i));
glEnd();
}
//////////////////////////////////////////////////////////////////////
for(i=0;i<=10;i++){
glColor3f(1.0 ,0.0 ,0.0 );

75. glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(200,100+a*i);
glVertex2i(200,200+a*i);
//arriva
glVertex2i(250,250+a*i);
//derecha
glVertex2i(250,150+a*i);
glEnd();
glColor3f(1.0 ,1.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(100,100+a*i);
glVertex2i(100,200+a*i);
//arriva

76. glVertex2i(200,200+a*i);
//derecha
glVertex2i(200,100+a*i);
//abajo
glEnd();
glColor3f(1.0 ,0.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(100,200+a*i);
glVertex2i(150,250+a*i);
//arriva
glVertex2i(250,250+a*i);
//derecha
glVertex2i(200,200+a*i);
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);

77. glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(100,100+a*i);
glVertex2i(100,200+a*i);
//arriva
glVertex2i(100,200+a*i);
glVertex2i(200,200+a*i);
//derecha
glVertex2i(200,200+a*i);
glVertex2i(200,100+a*i);
//abajo
glVertex2i(200,100+a*i);
glVertex2i(100,100+a*i);
//diagonal derecha esquina arriva
glVertex2i(150,250+a*i);
glVertex2i(100,200+a*i);
//linea cuadro atras
//linea cuadro atras
glVertex2i(150,250+a*i);
glVertex2i(250,250+a*i);
//linea derecha atras
glVertex2i(250,250+a*i);
glVertex2i(250,150+a*i);

78. //linea abajo derecha diagonal
glVertex2i(200,100+a*i);
glVertex2i(250,150+a*i);
//linea arriva derecha diagonal
glVertex2i(200,200+a*i);
glVertex2i(250,250+a*i);
glEnd();
}
//////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
for(i=0;i<=9;i++){
glColor3f(1.0 ,0.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(1200,1100);
glVertex2i(1200,1200);

79. //arriva
glVertex2i(1250,1250);
//derecha
glVertex2i(1250,1150);
glEnd();
glColor3f(1.0 ,1.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1100-a*i,1100);
glVertex2i(1100-a*i,1200);
//arriva
glVertex2i(1200-a*i,1200);
//derecha
glVertex2i(1200-a*i,1100);
//abajo
glEnd();

80. glColor3f(1.0 ,0.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1100-a*i,1200);
glVertex2i(1150-a*i,1250);
//arriva
glVertex2i(1250-a*i,1250);
//derecha
glVertex2i(1200-a*i,1200);
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(1100-a*i,1100);
glVertex2i(1100-a*i,1200);
//arriva

81. glVertex2i(1100-a*i,1200);
glVertex2i(1200-a*i,1200);
//derecha
glVertex2i(1200-a*i,1200);
glVertex2i(1200-a*i,1100);
//abajo
glVertex2i(1200-a*i,1100);
glVertex2i(1100-a*i,1100);
//diagonal derecha esquina arriva
glVertex2i(1150-a*i,1250);
glVertex2i(1100-a*i,1200);
//linea cuadro atras
//linea cuadro atras
glVertex2i(1150-a*i,1250);
glVertex2i(1250-a*i,1250);
//linea derecha atras
glVertex2i(1250,1250);
glVertex2i(1250,1150);
//linea abajo derecha diagonal
glVertex2i(1200,1100);
glVertex2i(1250,1150);
//linea arriva derecha diagonal

82. glVertex2i(1200-a*i,1200);
glVertex2i(1250-a*i,1250);
glEnd();
}
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
for(i=0;i<=9;i++){
glColor3f(1.0 ,0.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(1200,100);
glVertex2i(1200,200);

83. //arriva
glVertex2i(1250,250);
//derecha
glVertex2i(1250,150);
glEnd();
glColor3f(1.0 ,1.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1100-a*i,100);
glVertex2i(1100-a*i,200);
//arriva
glVertex2i(1200-a*i,200);
//derecha
glVertex2i(1200-a*i,100);
//abajo
glEnd();
glColor3f(1.0 ,0.0 ,0.0 );

84. glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1100-a*i,200);
glVertex2i(1150-a*i,250);
//arriva
glVertex2i(1250-a*i,250);
//derecha
glVertex2i(1200-a*i,200);
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(1100-a*i,100);
glVertex2i(1100-a*i,200);
//arriva
glVertex2i(1100-a*i,200);

85. glVertex2i(1200-a*i,200);
//derecha
glVertex2i(1200-a*i,200);
glVertex2i(1200-a*i,100);
//abajo
glVertex2i(1200-a*i,100);
glVertex2i(1100-a*i,100);
//diagonal derecha esquina arriva
glVertex2i(1150-a*i,250);
glVertex2i(1100-a*i,200);
//linea cuadro atras
//linea cuadro atras
glVertex2i(1150-a*i,250);
glVertex2i(1250-a*i,250);
//linea derecha atras
glVertex2i(1250,250);
glVertex2i(1250,150);
//linea abajo derecha diagonal
glVertex2i(1200,100);
glVertex2i(1250,150);
//linea arriva derecha diagonal

86. glVertex2i(1200-a*i,200);
glVertex2i(1250-a*i,250);
glEnd();
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
for(i=0;i<=10;i++){
glColor3f(1.0 ,0.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//izquierda
glVertex2i(1200,100+a*i);
glVertex2i(1200,200+a*i);
//arriva
glVertex2i(1250,250+a*i);
//derecha
glVertex2i(1250,150+a*i);

87. glEnd();
glColor3f(1.0 ,1.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1100,100+a*i);
glVertex2i(1100,200+a*i);
//arriva
glVertex2i(1200,200+a*i);
//derecha
glVertex2i(1200,100+a*i);
//abajo
glEnd();
glColor3f(1.0 ,0.0 ,0.0 );
glLineWidth(8);
glBegin(GL_QUADS);
//cuadro
//izquierda
glVertex2i(1100,200+a*i);

88. glVertex2i(1150,250+a*i);
//arriva
glVertex2i(1250,250+a*i);
//derecha
glVertex2i(1200,200+a*i);
//abajo
glEnd();
//cuadro
glColor3f(0.0 ,0.0 ,0.0 );
glLineWidth(4);
glBegin(GL_LINES);
//cuadro
//izquierda
glVertex2i(1100,100+a*i);
glVertex2i(1100,200+a*i);
//arriva
glVertex2i(1100,200+a*i);
glVertex2i(1200,200+a*i);
//derecha
glVertex2i(1200,200+a*i);
glVertex2i(1200,100+a*i);
//abajo
glVertex2i(1200,100+a*i);
glVertex2i(1100,100+a*i);

89. //diagonal derecha esquina arriva
glVertex2i(1150,250+a*i);
glVertex2i(1100,200+a*i);
//linea cuadro atras
//linea cuadro atras
glVertex2i(1150,250+a*i);
glVertex2i(1250,250+a*i);
//linea derecha atras
glVertex2i(1250,250+a*i);
glVertex2i(1250,150+a*i);
//linea abajo derecha diagonal
glVertex2i(1200,100+a*i);
glVertex2i(1250,150+a*i);
//linea arriva derecha diagonal
glVertex2i(1200,200+a*i);
glVertex2i(1250,250+a*i);
glEnd();
}

90. /////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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(750,750); //tamaño de la ventana
glutInitWindowPosition(0,0); //posicion inicial de la ventana
glutCreateWindow("cubo3d"); //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
}

92. Muñeco con Formas.
Presentación o descripción:
En esta práctica realizamos un muñeco con muchas figuras, como triángulos,
cuadrados, rectángulos, círculos, etc.
Debemos realizar esta practica en una clase solamente ya que es como un
examen para ver como trabajamos y todo lo que hemos aprendido sobre este
programa.
En esta práctica podemos utilizar las siguientes instrucciones que ya hemos
aprendido como se utilizan en todas las clases anteriores:
GlBegin (GL_QUADS);
GlBegin (GL_TRIANGLES);
GlBegin (GL_POLYGON);
GlBegin (GL_LINES);
Circulo ();
El código que utilizamos en esta práctica es el siguiente:
Void dibuja (void) //función dibuja
{
GlClear (GL_COLOR_BUFFER_BIT);
//cabello
glColor3f (0.0, 0.0, 0.0);
GlBegin (GL_TRIANGLES);
glVertex2i (280,400);
glVertex2i (290,400);
glVertex2i (350,450);
//cabello
glColor3f (0.0, 0.0, 0.0);
GlBegin (GL_TRIANGLES);
glVertex2i (280,400);
glVertex2i (290,400);
glVertex2i (325,500);
//cabello
glColor3f (0.0, 0.0, 0.0);

93. GlBegin (GL_TRIANGLES);
glVertex2i (280,400);
glVertex2i (290,400);
glVertex2i (300,500);
//cabello
glColor3f (0.0, 0.0, 0.0);
GlBegin (GL_TRIANGLES);
glVertex2i (280,400);
glVertex2i (290,400);
glVertex2i (250,500);
//cabello
glColor3f (0.0, 0.0, 0.0);
GlBegin (GL_TRIANGLES);
glVertex2i (280,400);
glVertex2i (290,400);
glVertex2i (200,500);
//cabello
glColor3f (0.0, 0.0, 0.0);
GlBegin (GL_TRIANGLES);
glVertex2i (280,400);
glVertex2i (290,400);
glVertex2i (150,400);
//cabello
glColor3f (0.0, 0.0, 0.0);
GlBegin (GL_TRIANGLES);
glVertex2i (280,400);
glVertex2i (290,400);
glVertex2i (100,400);
//cabello
glColor3f (0.0, 0.0, 0.0);
GlBegin (GL_TRIANGLES);
glVertex2i (280,400);
glVertex2i (290,400);
glVertex2i (75,400);
//cabello
glColor3f (0.0, 0.0, 0.0);
GlBegin (GL_TRIANGLES);
glVertex2i (280,400);
glVertex2i (290,400);
glVertex2i (50,400);
GlEnd ();
//cabeza
glColor3f (1.0, 0.8, 0.7); //borra pantalla
Círculo (250, 350,75);
//sonrisa
glColor3f (0.0, 0.0, 0.0); //borra pantalla
Circulo (250, 300,15);

94. //sonrisa
glColor3f (1.0, 0.8, 0.7); //borra pantalla
circulo(250,310,15);
//ojos
glColor3f(1.0,1.0,1.0); //borra pantalla
circulo(225,375,10);
//ojos
glColor3f(0.2,0.8,1.0); //borra pantalla
circulo(225,375,5);
//ojos
glColor3f(1.0,1.0,1.0); //borra pantalla
circulo(275,375,10);
//ojos
glColor3f(0.2,0.8,1.0); //borra pantalla
circulo(275,375,5);
//orejas
glColor3f(1.0,0.8,0.7); //borra pantalla
circulo(325,375,15);
//orejas
glColor3f(1.0,0.8,0.7); //borra pantalla
circulo(173,375,15);
//cuello
glColor3f(1.0,0.8,0.7);
//cuerpo
glBegin(GL_QUADS);
glColor3f(1.0,0.0,0.0);
glVertex2i(200,275);
glVertex2i(325,275);
glVertex2i(325,125);
glVertex2i(200,125);
//cuello
glColor3f(1.0,0.8,0.7);
glVertex2i(245,285);
glVertex2i(275,285);
glVertex2i(275,260);
glVertex2i(245,260);
//brazo
glVertex2i(200,275);
glVertex2i(200,245);
glVertex2i(150,150);
glVertex2i(130,150);
glVertex2i(325,275);
glVertex2i(325,245);
glVertex2i(370,150);
glVertex2i(390,150);
glEnd();
circulo(140,150,25);

95. circulo(380,150,25);
glColor3f(1.0,1.0,.0);
glBegin(GL_POLYGON);
glVertex2i(325,175);
glVertex2i(200,175);
glVertex2i(160,10);
glVertex2i(180,10);
glVertex2i(245,125);
glVertex2i(330,10);
glVertex2i(350,10);
glEnd();
glColor3f(0.0,0.0,0.0);
circulo(340,10,20);
circulo(170,10,20);
glFlush(); //forza dibujo
}
Salida:

96. ANIMACION CÍRCULO.
Presentación o descripción:
En esta práctica realizaremos una animación en Dev c++ esta vez no utilizaremos
cuadrados ni triángulos ahora solo utilizaremos un circulo y unas nuevas
instrucciones que el profesor nos dio.
Lo que tenemos que realizar es que un circulo avance hacia enfrente, hacia abajo,
hacia atrás, hacia arriba, en este orden una y otra vez.
Nos tenemos que guiar con un trabajo que el profesor nos dio pero que solo
avanza hacia enfrente, ahora tenemos que cambiar el código para que realice las
siguientes acciones.
La instrucción que utilizamos fue la siguiente:
if(y>=1 && y<600 && x==1000){
circulo(1000,700-y,40);
glFlush();
y++;
}
El código de toda la práctica es el siguiente:
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if(x>=1 && x<1000){
circulo(2+1*x,700,40);
glFlush();
x++;
}
if(y>=1 && y<600 && x==1000){
circulo(1000,700-y,40);
glFlush();
y++;
}
if(w>=1 && w<1000 && y==600 && x==1000){
circulo(1000-w,100,40);
glFlush();
w++;
}
if(z>=1 && z<1000 && y==600 && x==1000 && w==1000){
circulo(5,100+z,40);
glFlush();
z++;
if(z==600) {z=1;x=1;y=1;w=1;}
}

97. glutSwapBuffers();
}
SALIDA:

98. ANIMACION DEL SISTEMA SOLAR.
Presentación o descripción:
En esta practica también vamos a realizar una animación en Dev c++ pero ahora
realizaremos un sistema solar realizaremos nuestro sistema solar con movimiento
tanto de los planetas como de las orbitas.
Podemos ponerle el diseño que nosotros deseemos, tenemos que guiarnos con
una instrucción que el profesor nos pasó y también con su ayuda.
La instrucción que utilizamos fue la siguiente:
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();
El código de toda la práctica fue el siguiente:
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)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//esto
//sol
glColor3f (1.0, 1.0, 0.0);
circulo( 500,500,50);

99. //mercurio
glColor3f (1.0, 1.0, 1.0);
circuloc(500,500,2,100);
glColor3f (1.0, 0.0, 0.0);
circulo( 500+ sin(b) * 100,500 + cos(b) * 100,10);
//venus
glColor3f (1.0, 1.0, 1.0);
circuloc(500,500,2,150);
glColor3f (0.5, 0.2, 0.1);
circulo( 500+ sin(a) * 150,500 + cos(a) * 150,15);
//tierra
glColor3f (1.0, 1.0, 1.0);
circuloc(500,500,2,200);
glColor3f (0.08, 0.6, 0.9);
circulo( 500+ sin(c) * 200,500 + cos(c) * 200,20);
//marte
glColor3f (1.0, 1.0, 1.0);
circuloc(500,500,2,250);
glColor3f (1.0, 0.0, 0.0);
circulo( 500+ sin(d) * 250,500 + cos(d) * 250,22);
//jupiter
glColor3f (1.0, 1.0, 1.0);
circuloc(500,500,2,300);
glColor3f (0.4, 0.2, 0.6);
circulo( 500+ sin(e) * 300,500 + cos(e) * 300,23);
//saturno
glColor3f (1.0, 1.0, 1.0);
circuloc(500,500,2,350);
glColor3f (0.3, 0.9, 0.6);
circulo( 500+ sin(f) * 350,500 + cos(f) * 350,20);
//urano
glColor3f (1.0, 1.0, 1.0);
circuloc(500,500,2,400);
glColor3f (0.7, 0.1, 0.6);
circulo( 500+ sin(g) * 400,500 + cos(g) * 400,22);
//neptuno
glColor3f (1.0, 1.0, 1.0);
circuloc(500,500,2,450);
glColor3f (0.8, 0.3, 0.2);
circulo( 500+ sin(k) * 450,500 + cos(k) * 450,23);
a=a+0.09;
b=b+0.08;
c=c+0.07;
d=d+0.06;
e=e+0.05;
f=f+0.04;

100. g=g+0.03;
k=k+0.02;
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:

101. MOVIMIENTO EN OCHO.
Presentación o descripción:
En esta practica también realizaremos una animación pero ahora será con dos
círculos, lo que haremos será que en un dibujo parecido en ocho y ahora tenemos
que hacer que dos círculos se muevan como si fueran un carro en una pista.
La instrucción que utilizamos en esta practica es:
if(a>=6.15 && a<=12.41){
circulo(300+ sin (a)*60,300- cos(a)*60,10);
a=a +0.01;
}
else{
circulo(300 + 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++) {}
El código completo de esta práctica es el siguiente:
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(1.0, 1.0, 0.0);
circulo(300, 300, 70);
circulo(300,180,70);
glColor3f(1.0,1.0,1.0);
circulo(300,300,50);
circulo(300,180,50);
glColor3f(0.0,0.0,0.0);
if(a>=6.15 && a<=12.41){
circulo(300+ sin (a)*60,300- cos(a)*60,10);
a=a +0.01;
}
else{
circulo(300 + sin (b) *60,180+cos(b)*60,10);

102. b=b + 0.01;
if(b>12.4){a=6.15;b=6.15;}
for(int j=0; j<=10; j++) {}
}
glFlush();
glutSwapBuffers();
}
SALIDA.:

103. SEMAFORO:
Presentación o descripción:
En esta practica realizaremos un semáforo, logrando que se cambien de color y
que cuando este en verde parpadee un poco después el amarillo y por ultimo en
color rojo.
El profesor nos paso un trabajo ya terminado y después nos explico como
realizarlo además de que igual nos paso un video tutorial de cómo realizarlo.
El código completo de esta practica es el siguiente:
#include <GL/glut.h>
#include <GL/gl.h>
#include <math.h>
void inicializa(void)
{
glClearColor(0.0,0.0,0.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);}

104. glEnd();
}
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.0,0.0,1.0);
glBegin(GL_QUADS);
glVertex2i(200,500);
glVertex2i(300,500);
glVertex2i(300,200);
glVertex2i(200,200);
glEnd();
//rojo
glColor3f(1.0,0.0,1.0); //borra pantalla
circulo(250,400,50);
//amarillo
glColor3f(1.0,0.0,1.0); //borra pantalla
circulo(250,300,50);
//amarillo
glColor3f(1.0,0.0,1.0); //borra pantalla
circulo(250,200,50);
glFlush(); //forza dibujo
}
SALIDA:

105. PIRAMIDE.
Presentación o Descripción:
En esta practica realizaremos una pirámide que solo se vera por la parte de arriba
para esto tenemos que guiarnos con la instrucción que el profesor ya nos paso
anteriormente.
También con su ayuda realizaremos lo que falta de la práctica.
Esta práctica se realizara más fácilmente con la instrucción Ford para que sea
más fácil.
El código completo de esta práctica es el siguiente:
void dibuja(void) //funcion dibuja
{int i,a=20;
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(0.0 , 0.0 , 0.0);
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
glVertex2i(240-20*i,260+20*i);
glVertex2i(260+20*i,260+20*i);
}

106. 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();
SALIDA: