Este documento presenta un manual de prácticas de OpenGL. Incluye códigos para crear varias figuras geométricas 3D como un tablero de ajedrez, estrellas, un cubo con líneas y más. Explica que OpenGL es una API para crear gráficos 2D y 3D usando primitivas geométricas simples como puntos, líneas y triángulos. Los códigos están basados en coordenadas cartesianas para formar las figuras.

1. Colegio de Estudios Cientificos y Tecnológicos del Estado de México
Utilización de Software de diseño para el manejo de gráficos
Diana Becerra Hernández
MANUAL DE PRACTICAS DE OPEN GL
Prof.: Rene Domínguez Escalona
Grupo: 303
Ciclo escolar 2012-2013

2. Introducción
En el presente trabajo podrás ver diversos ejercicios de open gl que es una
especificación estándar que define una API multilenguaje y multiplataforma para
escribir aplicaciones que produzcan gráficos 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. Fue desarrollada originalmente por Silicón (SGI)
en 1992 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.
En el siguiente trabajo podrás observar diversas prácticas que se realizaron en
open gl y los resultados de las mismas, también podrás darte cuenta que en
open gl las figuras geométricas y los planos cartesianos son esenciales para poder
realizar una figura básica, que al paso del tiempo puede llegar a convertirse en
una figura o personaje con movimiento en 3d.
En open gl los códigos son la principal fuente para poder realizar nuestros
diseños estos códigos están basados generalmente en un plano cartesiano en el
que ponemos nuestras coordenadas para poder formar una figura y de ello te
darás cuenta en el siguiente proyecto, en donde los números y las figuras
geométricas no han de faltar.
Bueno en el siguiente proyecto notaras borradores los cuales son hechos para
facilitar realizar una figura ya que en ellos te vasas.

3. INDICE
1. TABLERO DE AJEDREZ……………………………………………………………4
2. ESTRELLA………………………………………………………………………..10
3. CUBO CON LINEAS………………………………………………………………..15
4. CUBO DELINEADO…………………………………………………………….19
5. MUÑECO CON TRIANGULOS……………………………………………………24
6. CASITA………………………………………………………………………………..36
7. OSO…………………………………………………………………………………..56
8. CUBO CON CUBITOS……………………………………………………………..62
9. MUÑECO CON FORMAS…………………………………………………………..70
10. ANIMACION CIRC ULO…………………………………………………………87
11. ANIMACION SISTEMA SOLAR……………………………………………………90
12. MOVIMIENTO EN 8…………………………………………………………………93
13. SEMAFORO………………………………………………………………………….98
14.PIRAMIDE……………………………………………………………………….104

4. Tablero de Ajedrez
En esta práctica deberás realizar un tablero en donde pondrás 8*8 de cuadro de
dos diversos colores, no hay problema si quieres agregar más cuadros si es que
lo quieres hacer más grande, siempre y cuando sean pares.
CODIGO
//mi primer ventana
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
void inicializa(void)
{
glClearColor(1.0,0.5,0.3); //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 ,1.0 ,1.0 );
glPointSize(50);
glBegin(GL_POINTS);

5. glVertex2i(100,100);
glVertex2i(200,200);
glVertex2i(300,100);
glVertex2i(400,200);
glVertex2i(500,100);
glVertex2i(600,200);
glVertex2i(700,100);
glVertex2i(800,200);
glVertex2i(100,300);
glVertex2i(200,400);
glVertex2i(300,300);
glVertex2i(400,400);
glVertex2i(500,300);
glVertex2i(600,400);
glVertex2i(700,300);
glVertex2i(800,400);
glVertex2i(100,500);
glVertex2i(200,600);
glVertex2i(300,500);
glVertex2i(400,600);
glVertex2i(500,500);
glVertex2i(600,600);
glVertex2i(700,500);
glVertex2i(800,600);
glVertex2i(100,700);

6. glVertex2i(200,800);
glVertex2i(300,700);
glVertex2i(400,800);
glVertex2i(500,700);
glVertex2i(600,800);
glVertex2i(700,700);
glVertex2i(800,800);
glEnd();
glColor3f(0.0 ,0.0 ,0.0 );
glPointSize(50);
glBegin(GL_POINTS);
glVertex2i(200,100);
glVertex2i(300,200);
glVertex2i(400,100);
glVertex2i(500,200);
glVertex2i(600,100);
glVertex2i(700,200);
glVertex2i(800,100);
glVertex2i(100,200);
glVertex2i(200,300);
glVertex2i(300,400);
glVertex2i(400,300);
glVertex2i(500,400);
glVertex2i(600,300);
glVertex2i(700,400);

7. glVertex2i(800,300);
glVertex2i(100,400);
glVertex2i(200,500);
glVertex2i(300,600);
glVertex2i(400,500);
glVertex2i(500,600);
glVertex2i(600,500);
glVertex2i(700,600);
glVertex2i(800,500);
glVertex2i(100,600);
glVertex2i(200,700);
glVertex2i(300,800);
glVertex2i(400,700);
glVertex2i(500,800);
glVertex2i(600,700);
glVertex2i(700,800);
glVertex2i(800,700);
glVertex2i(100,800);
glEnd();
glColor3f(1.0 ,1.0 ,1.0 );
glPointSize(50);
glBegin(GL_LINE);
glVertex2i(500,900);
glVertex2i(500,100);

8. 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(475,475); //tamaño de la ventana
glutInitWindowPosition(0,0); //posicion inicial de la ventana
glutCreateWindow("ajedrez"); //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
}
SALIDA

10. Estrella
En esta práctica deberás realizar una estrella utilizando líneas como se puede
observar en el código en este caso yo pondré tres estrellas, las puedes realizar del
color que desees.
BORRADOR
CODIGO
//mi primer ventana
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
void inicializa(void)
{

11. 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
{
glLineWidth(5);
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(1.0 , 1.0 , 0.0);
glBegin(GL_LINES);
glVertex2i(100,200);
glVertex2i(700,700);
glVertex2i(700,700);
glVertex2i(100,700);
glVertex2i(100,700);
glVertex2i(700,200);
glVertex2i(700,200);
glVertex2i(400,900);
glVertex2i(400,900);
glVertex2i(100,200);
glLineWidth(10);

12. glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(1.0 , 0.0 , 1.0);
glBegin(GL_LINES);
glVertex2i(150,250);
glVertex2i(750,750);
glVertex2i(750,750);
glVertex2i(150,750);
glVertex2i(150,750);
glVertex2i(750,250);
glVertex2i(750,250);
glVertex2i(450,950);
glVertex2i(450,950);
glVertex2i(150,250);
glLineWidth(10);
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(0.0 , 1.0 , 0.0);
glBegin(GL_LINES);
glVertex2i(200,300);
glVertex2i(800,800);
glVertex2i(800,800);
glVertex2i(200,800);
glVertex2i(200,800);
glVertex2i(800,300);

13. glVertex2i(800,300);
glVertex2i(500,1000);
glVertex2i(500,1000);
glVertex2i(200,300);
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
}

14. SALIDA

15. CUBO CON LINEAS
Este cubo se realizara mediante líneas para que lo formaran en tresd.
CODIGO
//mi primer ventana
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
void inicializa (void)
{
glClearColor(0.0,1.0,0.0,3.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
{
int i;
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.0 ,0.0 ,0.0 );
glPointSize(50);
//linea de abajo
glBegin(GL_LINES);
glVertex2i(200,200);
glVertex2i(400,200);

16. // linea derecha de la derecha
glBegin(GL_LINES);
glVertex2i(200,200);
glVertex2i(200,400);
//linea de arriba
glBegin(GL_LINES);
glVertex2i(400,400);
glVertex2i(200,400);
//linea de la izquierda
glBegin(GL_LINES);
glVertex2i(400,400);
glVertex2i(400,200);
//otro cuadrado
//linea de abajo
glBegin(GL_LINES);
glVertex2i(350,350);
glVertex2i(550,350);
// linea derecha de la derecha
glBegin(GL_LINES);
glVertex2i(350,350);
glVertex2i(350,550);
//linea de arriba
glBegin(GL_LINES);
glVertex2i(550,550);

17. glVertex2i(350,550);
//linea de la izquierda
glBegin(GL_LINES);
glVertex2i(550,550);
glVertex2i(550,350);
//diagonales
glBegin(GL_LINES);
glVertex2i(400,400);
glVertex2i(550,550);
// diagonal 2
glVertex2i(200,200);
glVertex2i(350,350);
// diagonal 3
glVertex2i(200,400);
glVertex2i(350,550);
// diagonal 4
glVertex2i(400,200);
glVertex2i(550,350);
glEnd();
glFlush(); //forza dibujo
}
int main (int argc, char** argv) //metodo main
{
glutInit(&argc, argv); //incializa GLUT

18. glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de
visualización
glutInitWindowSize(475,475); //tamaño de la ventana
glutInitWindowPosition(0,0); //posicion inicial de la ventana
glutCreateWindow("PIRAMIDE"); //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
}
SALIDA

19. CUBO DELINEADO
En este cubo deberás de rellenarlo y delinearlo en este caso yo utilizare la
fórmula del cuadrado y después de las líneas.
CODIGO
//mi primer ventana
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
void inicializa(void)
{
glClearColor(0.0,1.0,1.0,1.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);
glBegin(GL_POLYGON);
glVertex2i(100,200);
glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(100,450);

20. glColor3f(1.0 , 0.0 , 0.14);
glVertex2i(350,450);
glColor3f(1.0 , 0.10 , 1.0);
glVertex2i(350,200);
glColor3f(1.0 , 0.0 , 1.0);
glEnd();
//borra pantalla
glColor3f(0.0 , 1.0 , 0.0);
glBegin(GL_POLYGON);
glVertex2i(100,450);
glColor3f(1.0 , 1.0 , 0.0);
glVertex2i(225,575);
glColor3f(1.0 , 1.0 , 3.0);
glVertex2i(450,575);
glColor3f(1.0 , 5.0 , 0.0);
glVertex2i(350,450);
glColor3f(1.0 , 1.0 , 0.0);
glEnd();
glColor3f(0.0 , 0.0 , 1.0);
glBegin(GL_POLYGON);
glVertex2i(350,450);
glColor3f(0.0 , 3.0 , 2.0);

21. glVertex2i(450,575);
glColor3f(0.0 , 0.16 , 0.1);
glVertex2i(450,325);
glColor3f(0.0 , 0.17 , 0.143);
glVertex2i(350,200);
glColor3f(0.10 , 0.50 , 1.0);
glEnd();
glLineWidth(6);
glBegin(GL_LINES);
glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(100,200);
glVertex2i(100,450);
glVertex2i(95,450);
glVertex2i(355,450);
glVertex2i(350,450);
glVertex2i(350,200);
glVertex2i(355,200);
glVertex2i(95,200);
glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(350,200);
glVertex2i(450,325);
glVertex2i(450,325);
glVertex2i(450,575);

22. glVertex2i(450,575);
glVertex2i(350,450);
glVertex2i(350,450);
glVertex2i(350,200);
glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(455,575);
glVertex2i(215,575);
glVertex2i(215,575);
glVertex2i(95,455);
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

23. 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
}
SALIDA

24. MUÑECO CONTRIANGULOS
Este muñeco será realizado con diversas figuras geométricas con las cuales se
utilizarán códigos que identificaran a las mismas.
BORRADOR

25. CODIGO
//mi primer ventana
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
void inicializa(void)
{
glClearColor(0.0,1.0,1.0,0.0); //color de fondo
glMatrixMode(GL_PROJECTION); //Modo de proyeccion
glLoadIdentity(); //Establece los parametros de proyeccion

26. 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);
glBegin(GL_TRIANGLES);
glVertex2i(160,40);
glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(245,40);
glColor3f(1.0 , 1.0 , 0.0);
glVertex2i(200,80);
glEnd();
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(245,40);
glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(245,360);
glColor3f(1.0 , 1.0 , 0.0);
glVertex2i(180,280);
glEnd();

27. glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(320,360);
glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(320,280);
glColor3f(1.0 , 1.0 , 0.0);
glVertex2i(420,280);
glEnd();
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(420,280);
glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(380,240);
glColor3f(1.0 , 1.0 , 0.0);
glVertex2i(420,180);
glEnd();
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(420,180);
glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(520,180);

28. glColor3f(1.0 , 1.0 , 0.0);
glVertex2i(440,220);
glEnd();
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(60,360);
glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(80,440);
glColor3f(1.0 , 1.0 , 0.0);
glVertex2i(100,400);
glEnd();
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(100,400);
glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(200,520);
glColor3f(1.0 , 1.0 , 0.0);
glVertex2i(140,340);
glEnd();

29. glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(260,520);
glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(298,480);
glColor3f(1.0 , 1.0 , 0.0);
glVertex2i(320,520);
glEnd();
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(380,520);
glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(440,360);
glColor3f(1.0 , 1.0 , 0.0);
glVertex2i(480,400);
glEnd();
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(480,400);

30. glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(500,460);
glColor3f(1.0 , 1.0 , 0.0);
glVertex2i(520,360);
glEnd();
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(298,520);
glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(360,600);
glColor3f(1.0 , 1.0 , 0.0);
glVertex2i(220,600);
glEnd();
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(160,600);
glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(298,720);
glColor3f(1.0 , 1.0 , 0.0);
glVertex2i(420,600);
glEnd();

31. glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(540,320);
glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(498,280);
glColor3f(1.0 , 1.0 , 0.0);
glVertex2i(560,280);
glEnd();
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(540,320);
glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(580,540);
glColor3f(1.0 , 1.0 , 0.0);
glVertex2i(520,540);
glEnd();
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(540,320);
glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(640,540);

32. glColor3f(1.0 , 1.0 , 0.0);
glVertex2i(620,540);
glEnd();
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(540,320);
glColor3f(1.0 , 0.0 , 1.0);
glVertex2i(498,540);
glColor3f(1.0 , 1.0 , 0.0);
glVertex2i(478,540);
glEnd();
glBegin(GL_QUADS);
glColor3f(0.6 , 0.5 , 0.4);
glVertex2i(200,520);
glVertex2i(200,340);
glVertex2i(380,340);
glVertex2i(380,520);
glEnd();
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(260,520);
glColor3f(1.0 , 0.0 , 1.0);

33. glVertex2i(298,480);
glColor3f(1.0 , 1.0 , 0.0);
glVertex2i(320,520);
glEnd();
glBegin(GL_POLYGON);
glVertex2i(520,100);
glVertex2i(520,140);
glVertex2i(480,180);
glVertex2i(440,180);
glVertex2i(400,140);
glVertex2i(400,100);
glVertex2i(440,60);
glVertex2i(480,60);
glEnd();
glBegin(GL_POLYGON);
glVertex2i(0,0);
glVertex2i(0,40);
glVertex2i(1440,40);
glVertex2i(1440,0);
glEnd();

34. 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
}
SALIDA

36. CASITA
Esta casa será realizada con diversas figuras geométricas que la irán formando
para ello deberemos utilizar diversos códigos de figuras geométricas como
(TRIANGLES) entre otras.
BORRADOR
CODIGO
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
void inicializa(void)
{

37. glClearColor(0.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, 1000.0, 0.0, 1000.0); //vista ortogonal
}
void dibuja(void) //funcion dibuja
{
//calle
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_POLYGON);
glVertex2i(0,0);
glVertex2i(0,120);
glVertex2i(998,120);
glVertex2i(998,0);
glEnd();
//raya amarilla
glColor3f(1.0 , 0.96 , 0.49);
glBegin(GL_POLYGON);
glVertex2i(0,120);
glVertex2i(0,140);

38. glVertex2i(998,140);
glVertex2i(998,120);
glEnd();
//rallita gris
glColor3f(0.66 , 0.66 , 0.66);
glBegin(GL_POLYGON);
glVertex2i(0,140);
glVertex2i(0,180);
glVertex2i(998,180);
glVertex2i(998,140);
glEnd();
//rallita gris
glColor3f(0.66 , 0.66 , 0.66);
glBegin(GL_POLYGON);
glVertex2i(320,180);
glVertex2i(320,300);
glVertex2i(360,300);
glVertex2i(360,180);
glEnd();
//pasto derecha
glColor3f(0.0 , 1.0 , 0.0);
glBegin(GL_POLYGON);

39. glVertex2i(0,180);
glVertex2i(0,300);
glVertex2i(320,300);
glVertex2i(320,180);
glEnd();
//cuadritos
glColor3f(0.66 , 0.66 , 0.66);
glBegin(GL_POLYGON);
glVertex2i(60,200);
glVertex2i(60,220);
glVertex2i(100,220);
glVertex2i(100,200);
glEnd();
//2 cuadritos
glColor3f(0.66 , 0.66 , 0.66);
glBegin(GL_POLYGON);
glVertex2i(60,240);
glVertex2i(60,260);
glVertex2i(100,260);
glVertex2i(100,240);
glEnd();
//3 cuadritos

40. glColor3f(0.66 , 0.66 , 0.66);
glBegin(GL_POLYGON);
glVertex2i(120,240);
glVertex2i(120,260);
glVertex2i(160,260);
glVertex2i(160,240);
glEnd();
//4 cuadritos
glColor3f(0.66 , 0.66 , 0.66);
glBegin(GL_POLYGON);
glVertex2i(120,200);
glVertex2i(120,220);
glVertex2i(160,220);
glVertex2i(160,200);
glEnd();
//pasto izquierda
glColor3f(0.0 , 1.0 , 0.0);
glBegin(GL_POLYGON);
glVertex2i(360,180);
glVertex2i(360,300);
glVertex2i(998,300);
glVertex2i(998,180);
glEnd();

41. //cochera
glColor3f(0.74 , 0.69 , 0.65);
glBegin(GL_POLYGON);
glVertex2i(60,280);
glVertex2i(60,440);
glVertex2i(160,440);
glVertex2i(160,280);
glEnd();
// rallita de la cochera
glColor3f(0.85 , 0.50 , 0.11);
glBegin(GL_POLYGON);
glVertex2i(40,280);
glVertex2i(40,440);
glVertex2i(60,440);
glVertex2i(60,280);
glEnd();
// techito de la cochera
glColor3f(0.85 , 0.14 , 0.11);
glBegin(GL_POLYGON);
glVertex2i(160,440);
glVertex2i(20,440);
glVertex2i(40,460);

42. glVertex2i(160,460);
glEnd();
// casa
glColor3f(1.0 , 1.00 , 0.0);
glBegin(GL_POLYGON);
glVertex2i(160,280);
glVertex2i(160,560);
glVertex2i(520,560);
glVertex2i(520,280);
glEnd();
// rallas de la casa
glColor3f(0.854 , 0.509 , 0.113);
glBegin(GL_POLYGON);
glVertex2i(300,280);
glVertex2i(300,520);
glVertex2i(320,520);
glVertex2i(320,280);
glEnd();
// 2 rallas de la casa
glColor3f(0.854 , 0.509 , 0.113);
glBegin(GL_POLYGON);
glVertex2i(360,280);

43. glVertex2i(360,520);
glVertex2i(380,520);
glVertex2i(380,280);
glEnd();
// 3 rallas de la casa
glColor3f(0.854 , 0.509 , 0.113);
glBegin(GL_POLYGON);
glVertex2i(160,420);
glVertex2i(160,440);
glVertex2i(520,440);
glVertex2i(520,420);
glEnd();
// techo grande de la casa
glColor3f(0.854 , 0.145 , 0.113);
glBegin(GL_POLYGON);
glVertex2i(100,560);
glVertex2i(160,600);
glVertex2i(520,600);
glVertex2i(580,560);
glEnd();
// techo chico de la casa
glColor3f(1.0 , 0.0 , 0.0);

44. glBegin(GL_POLYGON);
glVertex2i(280,520);
glVertex2i(340,560);
glVertex2i(400,520);
glEnd();
//1 ventana de la casa
glColor3f(0.113 , 0.607 , 0.854);
glBegin(GL_POLYGON);
glVertex2i(200,340);
glVertex2i(200,400);
glVertex2i(260,400);
glVertex2i(260,340);
glEnd();
//2 ventana de la casa
glColor3f(0.113 , 0.607 , 0.854);
glBegin(GL_POLYGON);
glVertex2i(200,480);
glVertex2i(200,540);
glVertex2i(260,540);
glVertex2i(260,480);
glEnd();
//3 ventana de la casa

45. glColor3f(0.113 , 0.607 , 0.854);
glBegin(GL_POLYGON);
glVertex2i(420,480);
glVertex2i(420,540);
glVertex2i(480,540);
glVertex2i(480,480);
glEnd();
//4 ventana de la casa
glColor3f(0.113 , 0.607 , 0.854);
glBegin(GL_POLYGON);
glVertex2i(420,340);
glVertex2i(420,400);
glVertex2i(480,400);
glVertex2i(480,340);
glEnd();
//puerta
glColor3f(1.0 , 1.0 , 1.0);
glBegin(GL_POLYGON);
glVertex2i(320,280);
glVertex2i(320,400);
glVertex2i(360,400);
glVertex2i(360,280);
glEnd();

46. //relleno de la puerta
glColor3f(0.113 , 0.607 , 0.854);
glBegin(GL_POLYGON);
glVertex2i(330,320);
glVertex2i(330,380);
glVertex2i(350,380);
glVertex2i(350,320);
glEnd();
//1 tronco
glColor3f(0.560 , 0.360 , 0.188);
glBegin(GL_POLYGON);
glVertex2i(640,200);
glVertex2i(640,260);
glVertex2i(660,260);
glVertex2i(660,200);
glEnd();
//2 tronco
glColor3f(0.560 , 0.360 , 0.188);
glBegin(GL_POLYGON);
glVertex2i(800,200);
glVertex2i(800,260);
glVertex2i(820,260);

47. glVertex2i(820,200);
glEnd();
//1 cerca
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_POLYGON);
glVertex2i(0,320);
glVertex2i(0,340);
glVertex2i(40,340);
glVertex2i(40,320);
glEnd();
//2 cerca
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_POLYGON);
glVertex2i(520,320);
glVertex2i(520,340);
glVertex2i(998,340);
glVertex2i(998,320);
glEnd();
//3 cerca
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_POLYGON);
glVertex2i(20,280);

48. glVertex2i(20,380);
glVertex2i(35,380);
glVertex2i(35,280);
glEnd();
//4 cerca
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_POLYGON);
glVertex2i(540,280);
glVertex2i(540,380);
glVertex2i(560,380);
glVertex2i(560,280);
glEnd();
//5 cerca
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_POLYGON);
glVertex2i(740,280);
glVertex2i(740,380);
glVertex2i(760,380);
glVertex2i(760,280);
glEnd();
//6 cerca

49. glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_POLYGON);
glVertex2i(900,280);
glVertex2i(900,380);
glVertex2i(920,380);
glVertex2i(920,280);
glEnd();
//7 cerca
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_POLYGON);
glVertex2i(940,280);
glVertex2i(940,380);
glVertex2i(960,380);
glVertex2i(960,280);
glEnd();
//7 cerca
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_POLYGON);
glVertex2i(980,280);
glVertex2i(980,380);
glVertex2i(998,380);
glVertex2i(998,280);
glEnd();

50. //1 arbol de tronco
glColor3f(0.187 , 0.854 , 0.113);
glBegin(GL_POLYGON);
glVertex2i(560,260);
glVertex2i(660,540);
glVertex2i(740,260);
glEnd();
//2 arbol de tronco
glColor3f(0.187 , 0.854 , 0.113);
glBegin(GL_POLYGON);
glVertex2i(750,260);
glVertex2i(820,480);
glVertex2i(900,260);
glEnd();
//rallas de la calle
glColor3f(1.0 , 1.0 , 1.0);
glBegin(GL_POLYGON);
glVertex2i(40,75);
glVertex2i(40,85);
glVertex2i(120,85);
glVertex2i(120,75);

51. glEnd();
//rallas de la calle
glColor3f(1.0 , 1.0 , 1.0);
glBegin(GL_POLYGON);
glVertex2i(200,75);
glVertex2i(200,85);
glVertex2i(280,85);
glVertex2i(280,75);
glEnd();
//rallas de la calle
glColor3f(1.0 , 1.0 , 1.0);
glBegin(GL_POLYGON);
glVertex2i(420,75);
glVertex2i(420,85);
glVertex2i(500,85);
glVertex2i(500,75);
glEnd();
//rallas de la calle
glColor3f(1.0 , 1.0 , 1.0);
glBegin(GL_POLYGON);
glVertex2i(640,75);

52. glVertex2i(640,85);
glVertex2i(720,85);
glVertex2i(720,75);
glEnd();
//rallas de la calle
glColor3f(1.0 , 1.0 , 1.0);
glBegin(GL_POLYGON);
glVertex2i(840,75);
glVertex2i(840,85);
glVertex2i(900,85);
glVertex2i(900,75);
glEnd();
//saguan
glColor3f(1.0 , 1.0 , 1.0);
glBegin(GL_POLYGON);
glVertex2i(320,470);
glVertex2i(360,470);
glVertex2i(360,440);
glVertex2i(320,440);
glEnd();

53. //cuadros de las ventanas
glColor3f(1.0 , 1.0 , 1.0);
glBegin(GL_POLYGON);
glVertex2i(200,480);
glVertex2i(260,480);
glVertex2i(260,500);
glVertex2i(200,500);
glEnd();
//cuadros de las ventanas
glColor3f(1.0 , 1.0 , 1.0);
glBegin(GL_POLYGON);
glVertex2i(200,340);
glVertex2i(260,340);
glVertex2i(260,360);
glVertex2i(200,360);
glEnd();
//cuadros de las ventanas
glColor3f(1.0 , 1.0 , 1.0);
glBegin(GL_POLYGON);
glVertex2i(420,480);
glVertex2i(420,500);
glVertex2i(480,500);
glVertex2i(480,480);

54. glEnd();
//cuadros de las ventanas
glColor3f(1.0 , 1.0 , 1.0);
glBegin(GL_POLYGON);
glVertex2i(420,340);
glVertex2i(420,360);
glVertex2i(480,360);
glVertex2i(480,340);
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

55. glutMainLoop(); //muestra todo y espera
return 0; //retorna un valor de cero
}
SALIDA

56. OSO
Este oso se diseñara solo con círculos y para ello se agregara la biblioteca de mat
para poder copilar nuestro código en él se mostraran colores cafés y ojos
destellantes.
BORRADOR
CODIGO
//mi primer ventana
#include <GL/glut.h>
#include <GL/gl.h>
#include <math.h>
void inicializa(void)

57. {
glClearColor(2.2,0.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);

58. for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) * radio,
y + cos(angulo) * radio);}
glEnd();
}
void dibuja(void) //funcion dibuja
{
//cuerpo
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.560,0.360,0.188);
circulo(250,150,100);
glColor3f(1.0,0.0,0.0);
circuloc(250,150,5,40);
//cabeza
glColor3f(0.560,0.360,0.188);
circulo(250,325,100);
glColor3f(0.560,0.360,0.188);
circulo(150,425,50);
glColor3f(0.560,0.360,0.188);
circulo(350,425,50);
//relleno de orejas

59. glColor3f(1.10,0.1,0.1);
circulo(150,425,20);
glColor3f(1.10,0.1,0.1);
circulo(350,425,20);
//extremidades
glColor3f(0.560,0.360,0.188);
circulo(325,75,45);
glColor3f(1.0,0.0,0.0);
circulo(325,75,20);
glColor3f(0.560,0.360,0.188);
circulo(175,75,45);
glColor3f(1.0,0.0,0.0);
circulo(175,75,20);
glColor3f(0.0,0.0,0.0);
circuloc(325,75,5,45);
glColor3f(0.0,0.0,0.0);
circuloc(175,75,5,45);
// 2 extremidades
glColor3f(0.560,0.360,0.188);
circulo(350,175,45);
glColor3f(1.0,0.0,0.0);
circulo(350,175,20);

60. glColor3f(0.560,0.360,0.188);
circulo(150,175,45);
glColor3f(1.0,0.0,0.0);
circulo(150,175,20);
glColor3f(0.0,0.0,0.0);
circuloc(350,175,5,45);
glColor3f(0.0,0.0,0.0);
circuloc(150,175,5,45);
// cara
glColor3f(1.0,1.0,1.0);
circulo(300,350,25);
glColor3f(1.0,1.0,1.0);
circulo(200,350,25);
// cara
glColor3f(0.0,0.0,0.0);
circulo(300,350,10);
glColor3f(0.0,0.0,0.0);
circulo(200,350,10);
//nariz
glColor3f(0.0,0.0,0.0);
circulo(250,325,20);
glFlush(); //forza dibujo

61. }
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
inicializa();
glutDisplayFunc(dibuja); //Envia los graficos a la ventana de
visualización
glutMainLoop(); //muestra todo y espera
return 0; //retorna un valor de cero
}
SALIDA

62. CUBO CON CUBITOS
En esta imagen se realizara un cubo que lleve cubitos de colores cada uno de
ellos en una cara distinta y los cubitos,se pueden hacer del tamaño que desees en
este caso los haremos normales.
BORRADOR

63. CODIGO
//mi primer ventana
#include <GL/glut.h>
#include <GL/gl.h>
void inicializa(void)
{
glClearColor(0.9,0.5,0.2,0.8); //color de fondo
glMatrixMode(GL_PROJECTION); //Modo de proyeccion
glLoadIdentity(); //Establece los parametros de proyeccion
gluOrtho2D(0.0, 600.0, 0.0, 600.0); //vista ortogonal

64. }
void cubo (int x, int y,int t,int l){
double a=.8,b=.6;
glColor3f(0.0 , 1.1 , 0.0);
glBegin(GL_QUADS);
glVertex2f(x,y);
glVertex2f(x+t,y);
glVertex2f(x+t,y+t);
glVertex2f(x,y+t);
glColor3f(1.0 , 0.0 , 1.0);
glVertex2f(x,y+t);
glVertex2f(x+t,y+t);
glVertex2f(x+t+(t*a),y+t+(t*b));
glVertex2f(x+(t*a),y+t+(t*b));
glColor3f(0.0 , 0.0 , 0.9);
glVertex2f(x+t,y+t);
glVertex2f(x+t+(t*a),y+t+(t*b));
glVertex2f(x+t+(t*a),y+(t*b));
glVertex2f(x+t,y);
glEnd();
glColor3f(0.0 , 0.0 , 0.0);
glLineWidth(4);
glBegin(GL_LINES);

65. glVertex2f(x,y);
glVertex2f(x+t,y);
glVertex2f(x+t,y);
glVertex2f(x+t,y+t);
glVertex2f(x+t,y+t);
glVertex2f(x,y+t);
glVertex2f(x,y);
glVertex2f(x,y+t);
glVertex2f(x+t,y+t);
glVertex2f(x+t,y+t);
glVertex2f(x+t+(t*a),y+t+(t*b));
glVertex2f(x+t+(t*a),y+t+(t*b));
glVertex2f(x+(t*a),y+t+(t*b));
glVertex2f(x,y+t);
glVertex2f(x+t+(t*a),y+t+(t*b));
glVertex2f(x+(t*a),y+t+(t*b));
glVertex2f(x+t,y+t);
glVertex2f(x+t+(t*a),y+t+(t*b));
glVertex2f(x+t+(t*a),y+t+(t*b));
glVertex2f(x+t+(t*a),y+(t*b));
glVertex2f(x+t+(t*a),y+(t*b));
glVertex2f(x+t,y);

66. glVertex2f(x+t,y+t);
glEnd();
}
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(1.0 , 0.0 , 0.0);
//columna izquierda atras
for(int i=0;i<=10;i++){
cubo(260,220+20*i,20,5);
}
//abajo atras
for(int j=0;j<=9;j++){
cubo(280+20*j,220,20,5);
}
//arriba de atras
for(int j=0;j<=10;j++){
cubo(260+20*j,420,20,5);
}
//columna derecha atras
for(int i=0;i<=10;i++){
cubo(480,220+20*i,20,5);
}

67. //los de enfrente
//diagonales izquierca
for(int k=0;k<=8;k++){
cubo(245-20*k*.8,407-20*k*.6,20,5);
cubo(245-20*k*.8,207-20*k*.6,20,5);
}
//columna izquierda frente
for(int i=0;i<=10;i++){
cubo(100,100+20*i,20,5);
}
//abajo frente
for(int j=0;j<=10;j++){
cubo(120+20*j,100,20,5);
//arriba frente
cubo(120+20*j,300,20,5);
}
//diagonales derecha
for(int k=0;k<=8;k++){
cubo(466-20*k*.8,408-20*k*.6,20,5);
cubo(466-20*k*.8,208-20*k*.6,20,5);
}
//columna derecha frente
for(int i=0;i<=10;i++){
cubo(320,100+20*i,20,5);

68. }
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
inicializa();
glutDisplayFunc(dibuja); //Envia los graficos a la ventana de
visualización
glutMainLoop(); //muestra todo y espera
return 0; //retorna un valor de cero
}

69. SALIDA

70. MUÑECO CON FORMAS
En este personaje utilizaremos diversas figuras geométricas al igual que líneas,
polígonos y colores diversos.
BORRADOR
CODIGO
//mi primer ventana

71. #include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <math.h>
void inicializa(void)
{
glClearColor(2.2,0.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)

72. {
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); //borra pantalla
glColor3f(1.0 , 1.0 , 0.0);
glBegin(GL_POLYGON);
glVertex2i(160,140);
glVertex2i(160,160);
glVertex2i(300,160);
glVertex2i(300,140);
glEnd();
glColor3f(0.0 , 0.0 , 0.0);

73. glBegin(GL_POLYGON);
glVertex2i(220,140);
glVertex2i(220,160);
glVertex2i(240,160);
glVertex2i(240,140);
glEnd();
glColor3f(0.0 , 0.2 , 0.6);
glBegin(GL_POLYGON);
glVertex2i(160,140);
glVertex2i(100,40);
glVertex2i(160,20);
glVertex2i(225,140);
glEnd();
glColor3f(0.0 , 0.2 , 0.6);
glBegin(GL_POLYGON);
glVertex2i(225,140);
glVertex2i(280,20);
glVertex2i(340,40);
glVertex2i(300,140);
glEnd();
glColor3f(0.0 , 0.0 , 0.0);

74. glBegin(GL_TRIANGLES);
glVertex2i(60,10);
glVertex2i(160,20);
glVertex2i(100,40);
glEnd();
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(275,20);
glVertex2i(380,10);
glVertex2i(340,40);
glEnd();
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_QUADS);
glVertex2i(160,160);
glVertex2i(160,320);
glVertex2i(300,320);
glVertex2i(300,160);
glEnd();
glColor3f(0.8 , 0.5 , 0.4);

75. glBegin(GL_TRIANGLES);
glVertex2i(200,320);
glVertex2i(225,280);
glVertex2i(260,320);
glEnd();
glColor3f(0.0 , 0.2 , 0.6);
glBegin(GL_POLYGON);
glVertex2i(225,140);
glVertex2i(280,20);
glVertex2i(340,40);
glVertex2i(300,140);
glEnd();
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_POLYGON);
glVertex2i(120,200);
glVertex2i(80,200);
glVertex2i(160,320);
glVertex2i(160,280);
glEnd();
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_POLYGON);

76. glVertex2i(380,200);
glVertex2i(340,200);
glVertex2i(300,280);
glVertex2i(300,320);
glEnd();
glColor3f(0.8 , 0.5 , 0.4);
glBegin(GL_POLYGON);
glVertex2i(200,320);
glVertex2i(200,340);
glVertex2i(260,340);
glVertex2i(260,320);
glEnd();
//CUADRITOS
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_QUADS);
glVertex2i(220,260);
glVertex2i(240,260);
glVertex2i(240,280);
glVertex2i(220,280);
glEnd();

77. glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_QUADS);
glVertex2i(220,225);
glVertex2i(240,225);
glVertex2i(240,250);
glVertex2i(220,250);
glEnd();
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_QUADS);
glVertex2i(220,170);
glVertex2i(240,170);
glVertex2i(240,190);
glVertex2i(220,190);
glEnd();
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_QUADS);
glVertex2i(220,200);
glVertex2i(240,200);
glVertex2i(240,220);
glVertex2i(220,220);
glEnd();

78. glColor3f(0.8 , 0.5 , 0.4);
glBegin(GL_POLYGON);
glVertex2i(110,200);
glVertex2i(100,160);
glVertex2i(80,160);
glVertex2i(90,200);
glEnd();
glColor3f(0.8 , 0.5 , 0.4);
glBegin(GL_POLYGON);
glVertex2i(350,200);
glVertex2i(360,160);
glVertex2i(380,160);
glVertex2i(370,200);
glEnd();
glColor3f(0.8 , 0.5 , 0.4);
glBegin(GL_POLYGON);
glVertex2i(350,200);
glVertex2i(360,160);
glVertex2i(380,160);
glVertex2i(370,200);

79. glEnd();
//cabeza
glColor3f(0.8,0.5,0.4);
circulo(225,405,80);
glColor3f(0.8,0.5,0.4);
circulo(150,405,25);
glColor3f(0.8,0.5,0.4);
circulo(300,405,25);
glColor3f(1.0,1.0,1.0);
circulo(200,415,20);
glColor3f(1.0,1.0,1.0);
circulo(260,415,20);
glColor3f(0.0,0.0,0.0);
circulo(200,415,10);
glColor3f(0.0,0.0,0.0);
circulo(260,415,10);

80. glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(150,430);
glVertex2i(140,450);
glVertex2i(170,460);
glEnd();
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(170,460);
glVertex2i(160,498);
glVertex2i(200,480);
glEnd();
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(200,480);
glVertex2i(215,515);
glVertex2i(240,480);
glEnd();

81. glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(220,480);
glVertex2i(250,515);
glVertex2i(260,475);
glEnd();
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(260,475);
glVertex2i(300,490);
glVertex2i(280,450);
glEnd();
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(280,450);
glVertex2i(330,480);

82. glVertex2i(305,420);
glEnd();
//BOCA
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_LINES);
glVertex2i(200,360);
glVertex2i(200,350);
glVertex2i(200,350);
glVertex2i(260,350);
glVertex2i(260,350);
glVertex2i(260,360);
//NARIZ
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_LINES);
glVertex2i(220,400);
glVertex2i(220,360);
glVertex2i(220,360);
glVertex2i(240,360);
//DEDOS
glColor3f(0.0 , 0.0 , 0.0);

83. glBegin(GL_LINES);
glVertex2i(80,160);
glVertex2i(81,150);
glVertex2i(81,150);
glVertex2i(85,160);
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_LINES);
glVertex2i(85,160);
glVertex2i(86,150);
glVertex2i(86,150);
glVertex2i(90,160);
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_LINES);
glVertex2i(90,160);
glVertex2i(91,150);
glVertex2i(91,150);
glVertex2i(95,160);
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_LINES);
glVertex2i(95,160);

84. glVertex2i(96,150);
glVertex2i(96,150);
glVertex2i(100,160);
//DEDOGORDO ARREGLAR
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_LINES);
glVertex2i(85,180);
glVertex2i(75,180);
glVertex2i(75,180);
glVertex2i(85,170);
//mano derecha
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_LINES);
glVertex2i(362,160);
glVertex2i(363,150);
glVertex2i(363,150);
glVertex2i(368,160);
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_LINES);

85. glVertex2i(368,160);
glVertex2i(369,150);
glVertex2i(369,150);
glVertex2i(374,160);
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_LINES);
glVertex2i(374,160);
glVertex2i(375,150);
glVertex2i(375,150);
glVertex2i(380,160);
//dedo gordo
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_LINES);
glVertex2i(362,180);
glVertex2i(342,160);
glVertex2i(342,160);
glVertex2i(362,160);
glEnd();

86. 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
}
SALIDA

87. ANIMACION DEL CÍRCULO
Es esta animación simplemente aremos que el circulo gire con el siguiente código
CODIGO
#include <unistd.h>
#include <GL/glut.h>
#include <GL/gl.h>
#include <math.h>
int rad=100;

88. double ang=0;
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 circulo(int x, int y, int radio)
{
int angulo=0;
glBegin(GL_TRIANGLE_FAN); glColor3f (1.0,0.0,0.0);
glVertex2f(x,y);
glColor3f(1.0,1.0,1.0);
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
circulo( 500+ sin(ang) * rad,500 + cos(ang) * rad,50); //funcion circulo
ang=ang+0.01; //velocidad entre mas grande mas rapido y entre menos mas lento
for(int j=1;j<=1000000;j++){}//pausa

89. if(ang==360){ang=0;}// se repite idefinidamente
glFlush(); //forzar dibujado
glutSwapBuffers(); //y esto
}
int main (int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA| GLUT_DEPTH);//esto
tambien
glutInitWindowSize(500,500);
glutInitWindowPosition(200,400);
glutCreateWindow("Ventana");
inicializa();
glutDisplayFunc(dibuja);
glutIdleFunc(dibuja);//esto es lo que cambia
glutMainLoop();
return 0;
}

90. SALIDA
SISTEMA SOLAR
En el siguiente trabajo podrás observar una simulación de los planetas cada uno
de ellos llevar diversos tamaños y colores, y giraran en una órbita simulando la
galaxia.
CODIGO
#include <unistd.h>
#include <GL/glut.h>

91. #include <GL/gl.h>
#include <math.h>
int rad=100;
double ang=0;
void inicializa(void)
{
glClearColor(0.0,0.0,1.0,0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, 1000.0, 0.0, 1000.0);// el ancho y largo de nuestra pantalla
}
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++){ glVertex2f(x + sin(angulo) * radio, y
+ cos(angulo) * radio);}
glEnd();
}
void dibuja(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//esto

92. circulo( 500+ sin(ang) * rad,500 + cos(ang) * rad,10); //funcion circulo
circulo( 500+ sin(ang) * 50,500 + cos(ang) * 50,10);
circulo( 500+ sin(ang) * 150,500 + cos(ang) * 150,10);
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
}
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;
}

93. SALIDA
MOVIMIENTO EN 8
En esta práctica podrás ver a una bolita que Cruza en 8 esto a causa de la
animación dada.
CODIGO
#include <unistd.h>

94. #include <GL/glut.h>
#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(1.0,1.0,0.0,1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, 400.0, 0.0, 400.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(0.5, 0.0, 1.0);
circulo(300, 300, 70);

95. circulo(300,180,70);
glColor3f(0.0,0.0,0.0);
circulo(300,300,50);
circulo(300,180,50);
glColor3f(1.0,0.3,1.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);
b=b + 0.01;
if(b>12.4){a=6.15;b=6.15;}
for(int j=0; j<=10; j++) {}
}

96. glFlush();
glutSwapBuffers();
}
int main (int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA| GLUT_DEPTH);
glutInitWindowSize(700,700);
glutInitWindowPosition(10,10);
glutCreateWindow("Ventana");
inicializa();
glutDisplayFunc(dibuja);
glutIdleFunc(dibuja);
glutMainLoop();
return 0;
}
SALIDA

97. SEMAFORO

98. En este trabajo podrás hacer la simulación de un semáforo utilizando colores
distintos , parecidos a los reales y se ara la simulación del cambio de color.
BORRADOR
CODIGO
#include <unistd.h>
#include <GL/glut.h>
#include <GL/gl.h>
#include <math.h>
int x=1,d=1, e=1,z=1,w=1, y=1;
void inicializa(void)
{
glClearColor(0.0,0.0,0.0,0.0);

99. glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, 1000.0, 0.0, 800.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);// 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();
}

100. void dibuja(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(0.8,1.0,0.0);
glBegin(GL_QUADS);
glVertex2i(400,800);
glVertex2i(600,800);
glVertex2i(600,400);
glVertex2i(400,400);
glEnd();
glColor3f(0.8,1.0,0.0);
glBegin(GL_QUADS);
glVertex2i(480,400);
glVertex2i(530,400);
glVertex2i(530,50);
glVertex2i(480,50);
glEnd();
glColor3f(0,0.0,0.0);
circuloc(500,700,4,40);
circuloc(500,600,4,40);
circuloc(500,500,4,40);
glColor3f(0.0,0.0,0.0);
circulo(500,700,40);

101. circulo(500,600,40);
circulo(500,500,40);
glColor3f (1.0, 0.0, 0.0);
if(x>=1 && x<600){
circulo(500,700,40);
glFlush();
x++;
}
glColor3f (0.0, 1.0, 0.0);
if(y>=1 && y<800 && x==600){
circulo(500,500,40);
glFlush();
y++;
}
glColor3f(0.0,0.0,0.0);
if(w>=1 && w<600 && y==800 && x==600){
circulo(500,600,40);
glFlush();
w++;
}
glColor3f (0.0, 1., 0.0);
if(z>=1 && z<800 && y==800 && x==600 && w==600){
circulo(500,500,40);
glFlush();
z++;

102. }
glColor3f(0.0,0.0,0.0);
if(d>=1 && d<800 && y==800 && x==600 && w==600 && z==800){
circulo(500,500,40);
glFlush();
d++;
}
glColor3f (1.0, 1., 0.0);
if(e>=1 && e<800 && y==800 && x==600 && w==600 && d==800){
circulo(500,600,40);
glFlush();
e++;
}
if(e==800) {e=1;d=1;z=1;x=1;y=1;w=1;}
glutSwapBuffers();
}
int main (int argc, char** argv)
{
glutInit(&argc, argv);

103. glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA| GLUT_DEPTH);
glutInitWindowSize(800,600);
glutInitWindowPosition(10,10);
glutCreateWindow("Ventana");
inicializa();
glutDisplayFunc(dibuja);
glutIdleFunc(dibuja);
glutMainLoop();
return 0;
}
SALIDA

104. PIRAMIDE
En esta práctica se hará una pirámide utilizando solo líneas y colores que desees esto es
una práctica sencilla y fácil aunque un poco tediosa.
CODIGO
//mi primer ventana
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
void inicializa(void)
{
glClearColor(0.0,0.1,4.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 dibuja(void) //funcion dibuja
{
glLineWidth(4);
int i=0,a=20;
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(1.0 , 0.0 , 0.0);

105. glBegin (GL_LINES);
//Valor inicial--- Valor final o condicion--- incremento
for(i=1;i<=10; i++){
//abajo
glColor3f(1.0 , 1.0 , 0.0);
glVertex2i(240-a*i,240+a*i);
glVertex2i(260+a*i,240+a*i);
//derecha
glColor3f(1.0 , 0.0 , 0.0);
glVertex2i(240-a*i,240+a*i);
glVertex2i(240-a*i,220-a*i);
// izquierda
glColor3f(1.0 , 1.0 , 0.0);
glVertex2i(260+a*i,240+a*i);
glVertex2i(260+a*i,220-a*i);
//arriba
glColor3f(1.0 , 1.0 , 0.0);
glVertex2i(240-a*i,220-a*i);
glVertex2i(260+a*i,220-a*i);
}
glEnd();
glBegin(GL_LINES);

106. glVertex2i(42,20);
glVertex2i(62,40);
glVertex2i(82,60);
glVertex2i(102,80);
glVertex2i(122,100);
glVertex2i(142,120);
glVertex2i(162,140);
glVertex2i(182,160);
glVertex2i(202,180);
glVertex2i(222,200);
glVertex2i(282,260);
glVertex2i(302,280);
glVertex2i(322,300);
glVertex2i(342,320);
glVertex2i(362,340);

107. glVertex2i(382,360);
glVertex2i(402,380);
glVertex2i(422,400);
glVertex2i(442,420);
glVertex2i(462,440);
//derecha izquierda
glVertex2i(42,440);
glVertex2i(62,415);
glVertex2i(82,400);
glVertex2i(102,375);
glVertex2i(122,360);
glVertex2i(142,335);
glVertex2i(162,320);
glVertex2i(182,295);

108. glVertex2i(202,280);
glVertex2i(222,255);
glVertex2i(282,200);
glVertex2i(302,180);
glVertex2i(322,160);
glVertex2i(342,140);
glVertex2i(362,120);
glVertex2i(382,100);
glVertex2i(402,80);
glVertex2i(422,60);
glVertex2i(442,40);
glVertex2i(462,20);

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

110. }
SALIDA