1. COLEGIO DE ESTUDIOS CIENTIFICOS Y
TECNOLOGICOS DEL ESTADO DE
MEXICO
Nombre del profesor: Rene Domínguez Escalona
Nombre de los integrantes:
• Estela Elizabeth Mendoza González
• Nayely Sugey Mejía García
Trabajo: Manual de practicas
Grado: 3° Semestre
Grupo: 303
Materia: Utilización de software de diseño para el manejo de
gráficos.
1

2. INDICE
Introduccion sobre Open_GL……………………..3
Código del movimiento circular…………………..8
Tablero de ajedrez……………………………………9
Estrella…………………………………………………..17
Cubo con lineas……………………………………20
Cubo delineado…………………………………24
Muñeco con triángulos……………………………29
Casita…………………………………………………..37
Oso……………………………………………………..55
Cubo con cubitos…………………………………..58
Muñeco con formas………………………………..62
Animación circulo rotando……………………….68
Animación sistema solar……………………………71
Movimiento ocho…………………………………...74
Piramide………………………………………77
Semáforo……………………………………………..80
Nombre en 3D………………………………………85
Cubo en 3D………………………………………….91
2

3. INVESTIGACION SOBRE
Open_GL:
¿Qué es Open_GL?
R= Es una especificación estándar que define una API
Multilenguaje y multiplataforma para escribir aplicaciones que
produzcan gráficos en 2D y 3D.
¿Cuáles son las primitivas geométricas?
R=Formas geométricas por su básica constitución en las partes
que la conforman se conoces también con el nombre de
primitivas geométricas cuyas formas son:
GL_POINTS Dibuja puntos.
GL_LINES Dibuja líneas no conectadas.
GL_TRIANGLES Dibuja una serie de triángulos.
GL_QUADS Dibuja una serie de cuadriláteros.
GL_TRIANGLE_FAN Dibuja triángulos pegados unos con otros en
forma de abanico.
¿Cómo se crea una ventana en Open:GL?
R=Los paso necesarios para crear una ventana en Open:GL, los
podemos clasificar como sigue:
• Creamos una ventana
• Establecemos de manera de visión y la perspectiva
• Inicializamos la variable del estado de Open_GL
3

4. • Crea Ventana GL: Se puede considerar como la función
principal. Crea una ventana de Windows, selecciona el
Formato de pixel, crea su RC y DC y posteriormente llama
a las funciones siguientes para asignarle propiedades
de OpenGL.
• Elimina Ventana GL: Libera todos los recursos usados por la
ventana.
• Inicializa Escena GL: Establece el marco de visión
(Viewport) de la escena, así como la perspectiva que
vamos a Utilizar.
¿Qué es el GLVector?
R= En OpenGL los objetos los definimos como un conjunto
ordenado de vértices. Para especificar un vértice disponemos
del comando glVertex*(); void glVertex{234}{sifd} (TYPE coords);
Especifica un vértice para el uso en la descripción de un objeto
geométrico. El número de coordenadas puede ser de 2 (x,y), 3
(x,y,z) y 4 (x,y,z,w). Si se usa una versión en la que no se
especifica z o w, será entendido que a z se le asigna el valor 0 y
a w el valor 1.
¿Aplicaciones de Open_GL?
• Codificación del Color en modos RGBA (Rojo-Verde-Azul-
Alfa) o de color indexado.
4

5. • Visualización y Modelado que permite disponer objetos en
una escena tridimensional, mover nuestra cámara por el
espacio y seleccionar la posición ventajosa deseada para
visualizar la escena de composición.
• Mapeado de texturas que ayuda a traer realismo a
nuestros modelos por medio del dibujo de superficies
realistas en las caras de nuestros modelos poligonales
• La iluminación de materiales es una parte indispensable de
cualquier gráfico 3D. OpenGL provee de comandos para
calcular el color de cualquier punto dadas las propiedades
del material y las fuentes de luz en la habitación.
• El sombreado Gouraud es una técnica usada para aplicar
sombreados suaves a un objeto 3D y producir una sutil
diferencia de color por sus superficies.
• Efectos atmosféricos como la niebla, el humo y las neblinas
hacen que las imágenes producidas por ordenador sean
más realistas. Sin efectos atmosféricos las imágenes
aparecen a veces irrealmente nítidas y bien
definidas. Niebla es un término que en realidad describe
un algoritmo que simula neblinas, brumas, humo o polución
o simplemente el efecto del aire, añadiendo profundidad
a nuestras imágenes.
¿Cuáles son las tres librerías?
R=
• Glut.h
• Math-h
• Stdlib.h
5

6. ¿Qué funciones tienen las librerías?
R= Las librerías disponen de utilidades o funciones para entrada
o salida implementadas en el propio lenguaje, son utilizados
para el programador.
¿Cómo configurar Opengl en Dev c++?
R= OpenGL (Open Graphics Library): Es una API estándar para el
manejo de gráficos en 2 y 3 dimensiones independiente de la
plataforma. Es estructurado y está escrito en C. OpenGL tiene
funciones para renderizado en 2 y 3 dimensiones, rotación,
traslación, pintado, etc. Pero OpenGL NO provee métodos para
creación de ventanas manejo de dispositivos como teclado,
ratón, etc. OpeGL está definido en los archivos de cabecera y ,
los cuales están incluidos en la mayoría de compiladores.
* GLUT: (OpenGL Utility Toolkit): Ante la incapacidad de OpenGL
para crear controles gráficos como ventanas y manejar
dispositivos Mark Kilgard's desarrolló GLUT la cual es una librería
auxiliar a OpenGL que permite crear ventanas y manejar
dispositivos como el teclado y ratón y está diseñada para
integrarse completamente con OpenGL. Esta librería es
multiplataforma y tiene versiones para Windows, Linux y otros.
Así que para empezar a trabajar tenemos que bajar Dev-C++
de Aquí e instalarlo, este trae a OpenGL por defecto, pero para
además trabajar con GLUT necesitamos bajar el siguiente Dev-
Package de (elegimos glut.3.7.6+.DevPak), abrimos Dev-C++
vamos a Herramientas -> Package Manager, nos saldrá una
nueva ventana y daremos click en el botón Install,
seleccionamos el paquete y lo instalamos. Luego de esto ya
6

7. podremos ir a Nuevo Proyecto -> Multimedia -> glut y creamos
un nuevo proyecto. Este nos creará un demo del uso de glut
con OpenGL. Si lo compilamos y ejecutamos tendremos el
siguiente resultado:
CODIGO DEL MOVIMIENTO CIRCULAR:
• Primero haces un GLPlushMatrix, para guardar la matriz de
rotatraslacion.
• Luego haces un GLTranslate con las coordenadas de tu
zeppelín a continuación un GLRotate con sus ángulos.
• Luego lo dibujas.
• Por ultimo restauras la matriz.
•
GLPlushMatrix();
GLTranslate( posición del circulo);
GLRotate(rotación del circulo);
Circulo();
GLpopMatriz();
7

8. TABLERO DE AJEDREZ
Descripción: Lo que tenemos que hacer es un tablero de
ajedrez no importa los colores, este tablero debe de ser de 8x8.
Borrador:
8

9. Código:
void inicializa(void)
{
glClearColor(0.0,1.0,1.0,0.0); //color de fondo
glMatrixMode(GL_PROJECTION); //Modo de proyección
glLoadIdentity(); //Establece los parámetros de
proyección
gluOrtho2D(0.0, 1000.0, 0.0, 1000.0); //vista ortogonal
}
void dibuja(void) //función dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(0.0 ,0.0 ,1.0);
glPointSize(50);
glBegin (GL_POINTS);
glVertex2i(100,100);
glVertex2i(300,100);
9

10. glVertex2i(500,100);
glVertex2i(700,100);
glColor3f(0.0 ,0.0 ,0.0);
glPointSize(50);
glBegin (GL_POINTS);
glVertex2i(200,100);
glVertex2i(400,100);
glVertex2i(600,100);
glVertex2i(800,100);
glColor3f(0.0 ,0.0 ,1.0);
glPointSize(50);
glBegin (GL_POINTS);
glVertex2i(200,200);
glVertex2i(400,200);
glVertex2i(600,200);
glVertex2i(800,200);
glColor3f(0.0 ,0.0 ,0.0);
glPointSize(50);
glBegin (GL_POINTS);
10

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

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

13. glColor3f(0.0 ,0.0 ,0.0);
glPointSize(50);
glBegin (GL_POINTS);
glVertex2i(200,500);
glVertex2i(400,500);
glVertex2i(600,500);
glVertex2i(800,500);
glColor3f(0.0 ,0.0 ,1.0);
glPointSize(50);
glBegin (GL_POINTS);
glVertex2i(200,600);
glVertex2i(400,600);
glVertex2i(600,600);
glVertex2i(800,600);
glColor3f(0.0 ,0.0 ,0.0);
glPointSize(50);
glBegin (GL_POINTS);
glVertex2i(100,600);
glVertex2i(300,600);
13

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

15. glVertex2i(300,800);
glVertex2i(500,800);
glVertex2i(700,800);
glColor3f(0.0 ,0.0 ,1.0);
glPointSize(50);
glBegin (GL_POINTS);
glVertex2i(200,800);
glVertex2i(400,800);
glVertex2i(600,800);
glVertex2i(800,800);
glEnd();
glFlush(); //forza dibujo
Como quedo al final
15

16. Estrella
Descripción: Lo que tenemos que hacer es una estrella con
líneas no importa el tamaño de la estrella.
Borrador
16

17. Código:
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(0.0 , 0.0 , 1.0);
glBegin(GL_LINES);
glVertex2i(400,700);
glVertex2i(700,100);
glVertex2i(700,100);
glVertex2i(100,500);
glVertex2i(100,500);
glVertex2i(800,500);
glVertex2i(800,500);
glVertex2i(200,100);
glVertex2i(200,100);
glVertex2i(400,700);
glEnd();
17

18. glFlush(); //forza dibujo
}
Como quedo
18

19. Cubo con líneas
Descripción: Tenemos que realizar un cubo echo de líneas de
manera que se pueda visualizar todo completo.
Borrador:
19

20. Código:
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(0.0 , 0.0 , 0.0);
glLineWidth(4);
glBegin(GL_LINES);
glVertex2i(300,300);
glVertex2i(400,300);
glVertex2i(370,370);
glVertex2i(470,370);
glVertex2i(300,300);
glVertex2i(370,370);
glVertex2i(400,300);
glVertex2i(470,370);
glVertex2i(370,370);
20

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

22. Como quedo
22

23. CUBO DELINEADO
Descripción: Tenemos que realizar un cubo per que el contorno
se vea y debe de estar relleno de manera que se pueda
visualizar tres caras.
Borrador:
23

24. Código:
void dibuja(void) //función dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glBegin(GL_QUADS);
// parte de frente
glColor3f(1.0,0.0,0.0);
glVertex2i(200,200);
glColor3f(1.0,0.0,0.0);
glVertex2i(400,200);
glColor3f(1.0,0.0,0.0);
glVertex2i(400,400);
glColor3f(1.0,0.0,0.0);
glVertex2i(200,400);
// parte de lado
glColor3f(0.0,1.0,0.0);
glVertex2i(400,200);
24

25. glColor3f(0.0,1.0,0.0);
glVertex2i(500,300);
glColor3f(0.0,1.0,0.0);
glVertex2i(500,500);
glColor3f(0.0,1.0,0.0);
glVertex2i(400,400);
// parte de arriba
glColor3f(0.0,0.0,1.0);
glVertex2i(200,400);
glColor3f(0.0,0.0,1.0);
glVertex2i(400,400);
glColor3f(0.0,0.0,1.0);
glVertex2i(500,500);
glColor3f(0.0,0.0,1.0);
glVertex2i(300,500);
glEnd();
glLineWidth(5);
glBegin(GL_LINES);
glColor3f(0.0,0.0,0.0);
glVertex2i(200,200);
glVertex2i(400,200);
glVertex2i(400,200);
25

26. glVertex2i(400,400);
glVertex2i(400,400);
glVertex2i(200,400);
glVertex2i(200,400);
glVertex2i(200,200);
glVertex2i(400,200);
glVertex2i(500,300);
glVertex2i(500,300);
glVertex2i(500,500);
glVertex2i(500,500);
glVertex2i(400,400);
glVertex2i(400,400);
glVertex2i(400,200);
glVertex2i(200,400);
glVertex2i(400,400);
glVertex2i(400,400);
glVertex2i(500,500);
glVertex2i(500,500);
glVertex2i(300,500);
glVertex2i(300,500);
26

27. glVertex2i(200,400);
glEnd();
glFlush(); //forza dibujo
}
Resultado:
27

28. Muñeco con triangulos
Descripción: Tenemos que realizar un muñeco echo por puros
triángulos de manera que se vea la forma del dibujo.
Borrador:
28

29. Código:
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(1.0 , 0.0 , 0.0);
// triangulo de la cabeza
glBegin(GL_TRIANGLES);
glColor3f(0.0,0.0,1.0);
glVertex2i(250,750);
glColor3f(0.0,0.0,1.0);
glVertex2i(550,750);
glColor3f(0.0,0.0,1.0);
glVertex2i(400,850);
//triangulo de la cabeza 2
glColor3f(0.0,1.0,0.0);
glVertex2i(300,750);
glColor3f(0.0,1.0,0.0);
glVertex2i(500,750);
glColor3f(0.0,1.0,0.0);
glVertex2i(400,600);
29

30. //triangulo pequeño del cuerpo
glColor3f(0.0,0.0,0.0);
glVertex2i(400,550);
glColor3f(0.0,0.0,0.0);
glVertex2i(425,600);
glColor3f(0.0,0.0,0.0);
glVertex2i(374,600);
// triangulos de la mano izquierda
glColor3f(1.0,0.0,0.0);
glVertex2i(300,600);
glColor3f(1.0,0.0,0.0);
glVertex2i(100,300);
glColor3f(1.0,.0,0.0);
glVertex2i(50,400);
glColor3f(0.0,1.0,0.0);
glVertex2i(50,400);
glColor3f(0.0,1.0,1.0);
glVertex2i(0,450);
glColor3f(1.0,1.0,0.0);
glVertex2i(0,350);
// triangulos de la mano derecha
30

31. glColor3f(0.0,0.0,1.0);
glVertex2i(500,600);
glColor3f(0.0,0.0,1.0);
glVertex2i(650,300);
glColor3f(0.0,0.0,1.0);
glVertex2i(700,350);
glColor3f(1.0,0.0,0.0);
glVertex2i(700,350);
glColor3f(1.0,0.0,0.0);
glVertex2i(750,300);
glColor3f(1.0,0.0,0.0);
glVertex2i(750,400);
// triangulos de la pierna y pie izquierdo
glColor3f(1.0,0.0,1.0);
glVertex2i(350,100);
glColor3f(1.0,0.0,0.0);
glVertex2i(350,350);
glColor3f(0.0,1.0,1.0);
glVertex2i(300,300);
glColor3f(1.0,1.0,0.0);
31

32. glVertex2i(350,100);
glColor3f(1.0,0.0,1.0);
glVertex2i(250,150);
glColor3f(1.0,1.0,1.0);
glVertex2i(200,100);
// triangulos de la pierna y pie derecho
glColor3f(1.0,1.0,0.0);
glVertex2i(450,250);
glColor3f(1.0,0.0,1.0);
glVertex2i(600,250);
glColor3f(0.0,1.0,1.0);
glVertex2i(450,350);
glColor3f(0.0,0.0,1.0);
glVertex2i(600,150);
glColor3f(0.0,1.0,0.0);
glVertex2i(750,150);
glColor3f(0.0,0.0,0.0);
glVertex2i(675,200);
glColor3f(1.0,1.0,0.0);
glVertex2i(600,150);
32

33. glColor3f(1.0,0.0,1.0);
glVertex2i(600,250);
glColor3f(0.0,1.0,1.0);
glVertex2i(550,200);
glEnd();
// cuerpo del muñeco
glBegin(GL_QUADS);
glColor3f(1.0,1.0,0.0);
glVertex2i(300,350);
glColor3f(1.0,0.0,1.0);
glVertex2i(500,350);
glColor3f(0.0,1.0,1.0);
glVertex2i(500,600);
glColor3f(0.0,1.0,1.0);
glVertex2i(300,600);
// balon
glBegin(GL_QUADS);
glColor3f(1.0,1.0,0.0);
glVertex2i(600,100);
glColor3f(1.0,0.0,1.0);
glVertex2i(650,150);
glColor3f(0.0,1.0,1.0);
33

34. glVertex2i(700,150);
glColor3f(0.0,1.0,1.0);
glVertex2i(750,100);
// balon 2
glBegin(GL_QUADS);
glColor3f(1.0,0.0,0.0);
glVertex2i(600,100);
glColor3f(.0,0.0,1.0);
glVertex2i(650,50);
glColor3f(0.0,1.0,0.0);
glVertex2i(700,50);
glColor3f(1.0,0.0,0.0);
glVertex2i(750,100);
glEnd();
glFlush(); //forza dibujo
}
Resultado:
34

35. 35

36. Casita
Descripción: Tenemos que realizar una casa con todas las
figuras geométricas.
Borrador:
Código:
void dibuja(void) //funcion dibuja
36

37. {
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glBegin(GL_QUADS);
// calle
glColor3f(0.0,0.0,0.0);
glVertex2i(0,0);
glVertex2i(1000,0);
glVertex2i(1000,100);
glVertex2i(0,100);
//guarnicion
glColor3f(1.0,1.0,0.0);
glVertex2i(0,100);
glVertex2i(1000,100);
glVertex2i(1000,150);
glVertex2i(0,150);
// gris
glColor3f(1.0,0.0,1.0);
glVertex2i(0,150);
glVertex2i(1000,150);
glVertex2i(1000,200);
glVertex2i(0,200);
// pasto
37

38. glColor3f(0.0,1.0,0.0);
glVertex2i(0,200);
glVertex2i(1000,200);
glVertex2i(1000,450);
glVertex2i(0,450);
// parte de la casa (anaranjado)
glColor3f(1.0,0.0,0.0);
glVertex2i(150,300);
glVertex2i(200,300);
glColor3f(1.0,1.0,0.0);
glVertex2i(200,600);
glVertex2i(150,600);
// parte de la casa (gris)
glColor3f(1.0,1.0,1.0);
glVertex2i(200,300);
glVertex2i(450,300);
glColor3f(1.0,1.0,1.0);
glVertex2i(450,600);
glVertex2i(200,600);
// parte de la casa (roja)
glColor3f(1.0,0.0,0.0);
glVertex2i(50,600);
38

39. glVertex2i(450,600);
glVertex2i(450,700);
glVertex2i(100,700);
// parte de la casa (anaranjada)
glColor3f(1.0,0.0,0.0);
glVertex2i(450,300);
glVertex2i(850,300);
glColor3f(1.0,1.0,0.0);
glVertex2i(850,800);
glVertex2i(450,800);
// parte de la casa1 (rosa)
glColor3f(1.0,0.0,1.0);
glVertex2i(550,300);
glVertex2i(600,300);
glVertex2i(600,800);
glVertex2i(550,800);
// parte de la casa2 (rosa)
glColor3f(1.0,0.0,1.0);
glVertex2i(700,300);
glVertex2i(750,300);
glVertex2i(750,800);
glVertex2i(700,800);
39

40. // parte de la casa3 (rosa)
glColor3f(1.0,0.0,0.0);
glVertex2i(450,600);
glVertex2i(850,600);
glVertex2i(850,650);
glVertex2i(450,650);
// parte de la casa (roja)
glColor3f(1.0,0.0,0.0);
glVertex2i(300,800);
glVertex2i(1000,800);
glVertex2i(900,900);
glVertex2i(400,900);
// parte de la casa (rosa)
glColor3f(1.0,0.0,1.0);
glVertex2i(550,150);
glVertex2i(750,150);
glVertex2i(750,300);
glVertex2i(550,300);
// puerta (blanca)
glColor3f(1.0,1.0,1.0);
glVertex2i(600,300);
glVertex2i(700,300);
40

41. glVertex2i(700,550);
glVertex2i(600,550);
// puesta pequeña (azul)
glColor3f(0.0,0.0,1.0);
glVertex2i(625,325);
glVertex2i(675,325);
glVertex2i(675,500);
glVertex2i(625,500);
// chapa
glColor3f(0.0,0.0,0.0);
glVertex2i(600,380);
glVertex2i(620,380);
glVertex2i(620,400);
glVertex2i(600,400);
// ventasnas 1 y 2
glColor3f(0.0,0.0,0.0);
glVertex2i(450,350);
glVertex2i(550,350);
glVertex2i(550,450);
glVertex2i(450,450);
glColor3f(0.0,0.0,0.0);
41

42. glVertex2i(450,450);
glVertex2i(550,450);
glVertex2i(550,550);
glVertex2i(450,550);
//ventanas 3 y 4
glColor3f(0.0,0.0,0.0);
glVertex2i(750,350);
glVertex2i(850,350);
glVertex2i(850,450);
glVertex2i(750,450);
glColor3f(0.0,0.0,0.0);
glVertex2i(750,450);
glVertex2i(850,450);
glVertex2i(850,550);
glVertex2i(750,550);
// ventanas 5 y 6
glColor3f(0.0,0.0,0.0);
glVertex2i(450,660);
glVertex2i(525,660);
glVertex2i(525,775);
glVertex2i(450,775);
42

43. // ventana 7 y 8
glColor3f(0.0,0.0,0.0);
glVertex2i(775,660);
glVertex2i(850,660);
glVertex2i(850,775);
glVertex2i(775,775);
// ventanas 9 y 10
glColor3f(0.0,0.0,0.0);
glVertex2i(600,750);
glVertex2i(700,750);
glVertex2i(700,800);
glVertex2i(600,800);
// linea de las ventanas 9 y 10
glColor3f(1.0,1.0,1.0);
glVertex2i(600,725);
glVertex2i(700,725);
glVertex2i(700,750);
glVertex2i(600,750);
glEnd();
glLineWidth(5);
glBegin(GL_LINES);
glColor3f(1.0,1.0,1.0);
43

44. // lineas de la calle
glColor3f(1.0,1.0,1.0);
glVertex2i(0,50);
glVertex2i(50,50);
glColor3f(1.0,1.0,1.0);
glVertex2i(100,50);
glVertex2i(200,50);
glColor3f(1.0,1.0,1.0);
glVertex2i(250,50);
glVertex2i(350,50);
glColor3f(1.0,1.0,1.0);
glVertex2i(400,50);
glVertex2i(500,50);
glColor3f(1.0,1.0,1.0);
glVertex2i(550,50);
glVertex2i(650,50);
glColor3f(1.0,1.0,1.0);
44

45. glVertex2i(700,50);
glVertex2i(800,50);
glColor3f(1.0,1.0,1.0);
glVertex2i(850,50);
glVertex2i(950,50);
// lineas de la ventana 1
glLineWidth(7);
glColor3f(1.0,1.0,1.0);
glVertex2i(450,350);
glVertex2i(550,350);
glVertex2i(550,350);
glVertex2i(550,450);
glVertex2i(550,450);
glVertex2i(450,450);
glVertex2i(450,450);
glVertex2i(450,350);
// lineas de la ventana 2
glLineWidth(7);
glColor3f(1.0,1.0,1.0);
glVertex2i(450,450);
glVertex2i(550,450);
45

46. glVertex2i(550,450);
glVertex2i(550,550);
glVertex2i(550,550);
glVertex2i(450,550);
glVertex2i(450,550);
glVertex2i(450,450);
// lineas de la ventana 3
glLineWidth(7);
glColor3f(1.0,1.0,1.0);
glVertex2i(750,350);
glVertex2i(850,350);
glVertex2i(850,350);
glVertex2i(850,450);
glVertex2i(850,450);
glVertex2i(750,450);
glVertex2i(750,450);
glVertex2i(750,350);
// lineas de la ventana 4
glLineWidth(7);
glColor3f(1.0,1.0,1.0);
glVertex2i(750,450);
glVertex2i(850,450);
46

47. glVertex2i(850,450);
glVertex2i(850,550);
glVertex2i(850,550);
glVertex2i(750,550);
glVertex2i(750,550);
glVertex2i(750,450);
// lineas de la ventana 5 y 6
glLineWidth(7);
glColor3f(1.0,1.0,1.0);
glVertex2i(450,660);
glVertex2i(525,660);
glVertex2i(525,660);
glVertex2i(525,775);
glVertex2i(525,775);
glVertex2i(450,775);
glVertex2i(450,775);
glVertex2i(450,660);
glVertex2i(450,725);
glVertex2i(525,725);
// lineas de la ventana 7 y 8
glVertex2i(775,660);
47

48. glVertex2i(850,660);
glVertex2i(850,660);
glVertex2i(850,775);
glVertex2i(850,775);
glVertex2i(775,775);
glVertex2i(775,775);
glVertex2i(775,660);
glVertex2i(775,725);
glVertex2i(850,725);
glEnd();
glBegin(GL_QUADS);
glColor3f(0.6,0.5,0.4);
glVertex2i(900,350);
glVertex2i(950,350);
glVertex2i(950,500);
glVertex2i(900,500);
glEnd();
glLineWidth(3);
glBegin(GL_LINES);
glColor3f(0.0,0.5,0.1);
glVertex2i(850,500);
48

49. glVertex2i(1000,500);
glVertex2i(860,510);
glVertex2i(990,510);
glVertex2i(870,520);
glVertex2i(980,520);
glVertex2i(880,530);
glVertex2i(970,530);
glVertex2i(890,540);
glVertex2i(960,540);
glVertex2i(900,550);
glVertex2i(950,550);
glEnd();
glBegin(GL_QUADS);
glColor3f(0.7,0.1,0.5);
glVertex2i(100,50);
glVertex2i(300,50);
glVertex2i(300,100);
49

50. glVertex2i(100,100);
glVertex2i(150,100);
glVertex2i(250,100);
glVertex2i(250,150);
glVertex2i(150,150);
glColor3f(0.0,0.0,0.0);
glVertex2i(200,100);
glVertex2i(250,100);
glVertex2i(250,150);
glVertex2i(200,150);
glEnd();
glBegin(GL_QUADS);
glColor3f(0.0,0.2,0.4);
glVertex2i(700,50);
glVertex2i(700,150);
glVertex2i(1000,150);
glVertex2i(1000,50);
glVertex2i(850,150);
glVertex2i(850,200);
glVertex2i(950,200);
50

51. glVertex2i(950,150);
glEnd();
glFlush(); //forza dibujo
}
Resultado:
51

52. Oso
Descripción: Tenemos que realizar un oso con círculos de
diferentes tamaños.
Borrador:
Código:
52

53. void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.0,0.0,0.0); //borra pantalla
//cuerpo
circulo(250,250,100);
//patitas
circulo(160,175,60);
circulo(340,175,60);
//bracito
circulo(160,325,50);
circulo(340,325,50);
//cabeza
circulo(250,400,70);
//orejas
circulo(215,470,20);
circulo(280,470,20);
glColor3f(1.0,1.0,1.0);
//ojos
circulo(220,430,10);
circulo(275,430,10);
//panza
53

54. circulo(250,250,50);
//boca
circulo(250,380,20);
glFlush();
Resultado:
54

55. Cubitos con cubos
Descripción: Tenemos que realizar un cubo echo por cubitos en
3D de manera que los cubitos sean el delineado para formar un
cubo mas grande.
Borrador:
Código:
void dibuja(void) //funcion dibuja
55

56. {
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(0.4 , 0.1 , 0.4);
//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);
}
//los de enfrente
//diagonales izquierca
56

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

58. }
glFlush();
Resultado:
58

59. Muñeco con formas
Descripción: Tenemos que realizar un muñeco del cecytem con
todas las primitivas que hemos visto.
Borrador:
Código:
void dibuja(void) //funcion dibuja
59

60. {
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(1.0 , 0.0 , 0.0);
// triangulo de la cabeza
glBegin(GL_TRIANGLES);
glColor3f(0.0,0.0,1.0);
glVertex2i(250,750);
glColor3f(0.0,0.0,1.0);
glVertex2i(550,750);
glColor3f(0.0,0.0,1.0);
glVertex2i(400,850);
//triangulo de la cabeza 2
glColor3f(0.0,1.0,0.0);
glVertex2i(300,750);
glColor3f(0.0,1.0,0.0);
glVertex2i(500,750);
glColor3f(0.0,1.0,0.0);
glVertex2i(400,600);
//triangulo pequeño del cuerpo
glColor3f(0.0,0.0,0.0);
glVertex2i(400,550);
glColor3f(0.0,0.0,0.0);
60

61. glVertex2i(425,600);
glColor3f(0.0,0.0,0.0);
glVertex2i(374,600);
// triangulos de la mano izquierda
glColor3f(1.0,0.0,0.0);
glVertex2i(300,600);
glColor3f(1.0,0.0,0.0);
glVertex2i(100,300);
glColor3f(1.0,.0,0.0);
glVertex2i(50,400);
glColor3f(0.0,1.0,0.0);
glVertex2i(50,400);
glColor3f(0.0,1.0,1.0);
glVertex2i(0,450);
glColor3f(1.0,1.0,0.0);
glVertex2i(0,350);
// triangulos de la mano derecha
glColor3f(0.0,0.0,1.0);
glVertex2i(500,600);
glColor3f(0.0,0.0,1.0);
glVertex2i(650,300);
61

62. glColor3f(0.0,0.0,1.0);
glVertex2i(700,350);
glColor3f(1.0,0.0,0.0);
glVertex2i(700,350);
glColor3f(1.0,0.0,0.0);
glVertex2i(750,300);
glColor3f(1.0,0.0,0.0);
glVertex2i(750,400);
// triangulos de la pierna y pie izquierdo
glColor3f(1.0,0.0,1.0);
glVertex2i(350,100);
glColor3f(1.0,0.0,0.0);
glVertex2i(350,350);
glColor3f(0.0,1.0,1.0);
glVertex2i(300,300);
glColor3f(1.0,1.0,0.0);
glVertex2i(350,100);
glColor3f(1.0,0.0,1.0);
glVertex2i(250,150);
glColor3f(1.0,1.0,1.0);
62

63. glVertex2i(200,100);
// triangulos de la pierna y pie derecho
glColor3f(1.0,1.0,0.0);
glVertex2i(450,250);
glColor3f(1.0,0.0,1.0);
glVertex2i(600,250);
glColor3f(0.0,1.0,1.0);
glVertex2i(450,350);
Resultado:
63

64. Animación circulo
Descripción: Tenemos que realizar una animación de un circulo
que valla recorriendo la pantalla.
Borrador:
Código:
void dibuja(void)
64

65. {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if(x>=1 && x<500){
circulo(100+x,100,40);
glFlush();
x++;
}
if(y>=1 && y<500 && x==500){
circulo(600,100+y,40);
glFlush();
y++;
}
if(z>=1 && z<500 && y==500 && x==500){
circulo(600-z,600,40);
glFlush();
z++;
}
if(k>=1 && k<500 && z==500 && y==500 && x==500){
circulo(100,600-k,40);
glFlush();
k++;
if(k==500){ x=1, y=1, k=1, z=1; }
65

66. }
glutSwapBuffers();
}
Resultado:
66

67. 67

68. Animacion sistema
Descripción: Tenemos que realizar el sistema solar de manera
que los planetas vallan girando.
Borrador:
68

69. Código:
void dibuja(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//esto
glColor3f(1.0,0.9,0.0);
circulo( 500,500,20);
glColor3f(1.0,0.0,0.0);
circuloc(500,500,2,50);
circulo( 500+ sin(ang) * rad,500 + cos(ang) * rad,15); //funcion
circulo
glColor3f(0.0,0.0,1.0);
circuloc(500,500,2,150);
circulo( 500+ sin(c) * 50,500 + cos(c) * 50,10);
glColor3f(0.0,1.0,0.0);
circuloc( 500,500,2,100);
circulo( 500+ sin(d) * 100,500 + cos(d) * 100,20);
glColor3f(0.0,1.0,1.0);
circuloc( 500,500,2,150);
circulo( 500+ sin(e) * 150,500 + cos(e) * 150,15);
glColor3f(0.9,0.0,0.4);
69

70. circuloc( 500,500,2,200);
circulo( 500+ sin(f) * 200,500 + cos(f) * 200,10);
glColor3f(0.4,0.7,0.5);
circuloc( 500,500,2,250);
circulo( 500+ sin(g) * 250,500 + cos(g) * 250,13);
glColor3f(0.7,0.7,0.4);
circuloc( 500,500,2,300);
circulo( 500+ sin(h) * 300,500 + cos(h) * 300,10);
glColor3f(0.2,0.1,4.0);
circuloc( 500,500,2,300);
circulo( 500+ sin(a) * 300,500 + cos(a) * 300,25);
glColor3f(0.0,0.6,0.4);
circuloc( 500,500,2,350);
circulo( 500+ sin(n) * 350,500 + cos(n) * 350,20);
glColor3f(0.4,0.1,0.2);
circuloc( 500,500,2,400);
circulo( 500+ sin(r) * 400,500 + cos(r) * 400,20);
c+=0.02;
d+=0.03;
e+=0.04;
f+=0.07;
g+=0.09;
70

71. h+=0.02;
a+=0.05;
n+=0.08;
r+=0.04;
ang=ang+0.1; //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
}
Resultado:
71

72. Movimiento ocho
Descripción: Tenemos que realizar un acho pero que alrededor
valla girando un círculo.
Borrador
72

73. Código:
void dibuja(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//esto
glColor3f (1.0, 1.0, 0.0);//primer circulo
circulo(500,500,150);
glColor3f (0.0, 0.0, 0.0);
circulo(500,500,100);
glColor3f (1.0, 1.0, 0.0);// segundo circulo
circulo(500,750,150);
glColor3f (0.0, 0.0, 0.0);
circulo(500,750,100);
//bolitas
glColor3f (1.0, 0.0, 0.0);
if(a>=6.15 && a<12.40){
circulo(500 -sin(a) * 125,500 +cos(a) * 125,20);
a=a+0.09;
}
else{
73

74. circulo(500 -sin(b)* 125,750 +cos(b)* -125,20);
b=b+0.09;
if(b>12.40) (a=6.15, b=6.15);
}
glFlush(); //forzar dibujado
Resultado:
74

75. Piramid
Descripción: Tenemos que realizar un pirámide y ponerle sus
escalones debe ser echo por cuadrados.
Borrador:
75

76. Código:
void dibuja(void) //funcion dibuja
int i,a=25;
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(1.0 , 0.0 , 0.0);
glLineWidth(2);
glBegin(GL_LINES);
//Valor incial --- Valor final o condicion --- incremento
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);
76

77. }
glEnd();
glFlush(); //forza dibujo
Resultado:
77

78. Semafor
o
Descripción: Tenemos que realizar un semáforo que valla
cambiando las luces el verde que parpadeé tres veces el
Amarillo y el rojo solo una vez.
Borrador:
78

79. Código:
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT |
GL_DEPTH_BUFFER_BIT); //borra pantalla
glColor3f(0.1 , 0.0 , 0.4);
// semaforo parte grande
glColor3f(0.2,0.3,0.7);
glBegin(GL_QUADS);
glVertex2i(250,50);
glVertex2i(250,275);
glVertex2i(300,275);
glVertex2i(300,50);
glVertex2i(200,275);
glVertex2i(200,575);
glVertex2i(350,575);
glVertex2i(350,275);
79

80. glEnd();
glColor3f(0.0,0.0,0.0);
glColor3f(0.0,0.0,0.0);
glColor3f(0.0,0.0,0.0);
circulo(275,325,30);
circulo(275,425,30);
circulo(275,525,30);
a=a+1;
for(int j=1 ;j<=10000000; j++){}
if(a>1 && a<15){
glColor3f(0.0,0.5,0.2);
circulo(275,325,30);
}
if(a>20 && a<45){
glColor3f(0.0,0.5,0.2);
circulo(275,325,30);
}
80

81. if(a>50 && a<65){
glColor3f(0.0,0.5,0.2);
circulo(275,325,30);
}
if(a>70 && a<95){
glColor3f(1.0,1.0,0.0);
circulo(275,425,30);
}
if(a>100 && a<125){
glColor3f(1.0,0.0,0.0);
circulo(275,525,30);
}
if (a>125) {a=0;}
glEnd();
glFlush();
81

82. Resultado:
82

83. Nombre en 3D
Descripción: Tenemos que realizar con cubos nuestro nombre
pero va hacer en 3D.
Borrador:
83

84. Código:
void dibuja( void )
if(ejes) creaEjes();
//glRotatef(anguloEsfera, 1.0f, 1.0f,0.0f);
glColor3f(1.0,1.0,0.0);
//R
glTranslatef(-8.0,0.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,1.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,1.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,1.0, 0.0);
glutSolidCube(1);
glTranslatef(1.0,0.0, 0.0);
glutSolidCube(1);
glTranslatef(1.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(1.0,-1.0, 0.0);
84

85. glutSolidCube(1);
glTranslatef(1.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,1.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,1.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,1.0, 0.0);
glutSolidCube(1);
glTranslatef(2.0,-3.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,1.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,1.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,1.0, 0.0);
glutSolidCube(1);
glTranslatef(1.0,0.0, 0.0);
glutSolidCube(1);
glTranslatef(1.0,0.0, 0.0);
glutSolidCube(1);
85

86. glTranslatef(0.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(-1.0,1.0, 0.0);
glutSolidCube(1);
glTranslatef(3.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,1.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,1.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(2.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,-1.0, 0.0);
glutSolidCube(1);
86

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

88. //AQUI
glPopMatrix ();
glFlush();
Resultado:
88

89. Cubo en 3D
Descripción: Tenemos que realizar un cubo echo por otros cubos
en 3D.
Borrador:
89

90. Código:
}
void creaMalla(void){
int i, long_eje=10;
glColor3f(1.0,1.0,0.0);
glBegin(GL_LINES);
for(i=-long_eje;i<=long_eje;i++){
glVertex3f(i,-long_eje,0);
glVertex3f(i,long_eje,0);
glVertex3f(-long_eje,i,0);
glVertex3f(long_eje,i,0);
glVertex3f(i,0,-long_eje);
glVertex3f(i,0,long_eje);
glVertex3f(-long_eje,0,i);
glVertex3f(long_eje,0,i);
}
glEnd();
}
void creaEjes(void){
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINES);
90

91. glColor3f(0.0,0.0,1.0);
glVertex3f(-11.0,0.0,0.0);
glVertex3f(11.0,0.0,0.0);
glColor3f(1.0,0.0,0.0);
glVertex3f(0.0,-11.0,0.0);
glVertex3f(0.0,11.0,0.0);
glColor3f(0.0,1.0,0.0);
glVertex3f(0.0,0.0,-11.0);
glVertex3f(0.0,0.0,11.0);
glEnd();
glBegin(GL_TRIANGLES);
glColor3f(0.0,0.0,1.0);
glVertex3f(11.0,0.0,0.0);
glVertex3f(10.5,0.0,-.50);
glVertex3f(10.5,0.0,.50);
glColor3f(1.0,0.0,0.0);
glVertex3f(0.0,11.0,0.0);
glVertex3f(-.50,10.5,0.0);
glVertex3f(.50,10.5,0.0);
glColor3f(0.0,1.0,0.0);
glVertex3f(0.0,0.0,11.0);
glVertex3f(-.50,0.0,10.5);
91

92. glVertex3f(.50,0.0,10.5);
//puntas otras
glColor3f(0.0,0.0,1.0);
glVertex3f(-11.0,0.0,0.0);
glVertex3f(-10.5,0.0,.50);
glVertex3f(-10.5,0.0,-.50);
glColor3f(1.0,0.0,0.0);
glVertex3f(0.0,-11.0,0.0);
glVertex3f(.50,-10.5,0.0);
glVertex3f(-.50,-10.5,0.0);
glColor3f(0.0,1.0,0.0);
glVertex3f(0.0,0.0,-11.0);
glVertex3f(.50,0.0,-10.5);
glVertex3f(-.50,0.0,-10.5);
glEnd();
void dibuja( void )
{
glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glEnable(GL_DEPTH_TEST); // Activamos el z-Buffer
glEnable(GL_LIGHTING); // Activamos la iluminación
glEnable(GL_LIGHT0); // Activamos la luz 0
92

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

94. glLightfv(GL_LIGHT0,GL_POSITION,(GLfloat [])
{0.0f,12.0f,5.0f,0.0f}); // Posición de la luz
glLightfv(GL_LIGHT0,GL_EMISSION,(GLfloat []){0.5,0.5,0.5,1.0});
//glShadeModel (GL_SMOOTH);
// esfera
glPushMatrix();
mover();
if(malla) creaMalla();
if(ejes) creaEjes();
//glRotatef(anguloEsfera, 1.0f, 1.0f,0.0f);
glColor3f(1.0,1.0,0.0);
//R
glTranslatef(-8.0,0.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(2.0,-6.0, 0.0);
94

95. glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(2.0,-6.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(2.0,-6.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
95

96. glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(-6.0,-6.0, 2.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(2.0,-6.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
96

97. glTranslatef(2.0,-6.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(2.0,-6.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(-6.0,-6.0, 2.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
97

98. glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(2.0,-6.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(2.0,-6.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
98

99. glTranslatef(2.0,-6.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(-6.0,-6.0, 2.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(2.0,-6.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
99

100. glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(2.0,-6.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(2.0,-6.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,2.0, 0.0);
100

101. glutSolidCube(1);
// AQUI PONES TU NOMBRE
//AQUI
//AQUI
//AQUI//AQUI
//AQUI//AQUI//AQUI
//AQUI
glPopMatrix ();
glFlush();
glutSwapBuffers ();
//anguloEsfera+=2.0f;
}
void reshape(int w, int h){
glClearColor(1.0,1.0,1.0,0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,15,-15,15,-30,30);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glClear(GL_DEPTH_TEST);
}
101

102. void activo(int x,int y){
// x= e;
//y= f;
girax=y;
giray=700-x;
glutPostRedisplay();
}
void teclado(unsigned char key, int x, int y){
switch(key){
case 27:
exit(0);
case '+':
zoom++;
break;
case '-':
zoom--;
break;
case 'p':
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
102

103. gluPerspective(45,1,10,100);
zoom=-40;
break;
case 'o':
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,15,-15,15,-30,30);
zoom=0;
break;
case 'm':
malla= !malla;
break;
case 'e':
ejes= !ejes;
default: break;
}
glutPostRedisplay();
}
void flechas(int key, int x, int y){
switch(key){
case GLUT_KEY_LEFT:
103

104. giray-=15;
break;
case GLUT_KEY_RIGHT:
giray+=15;
break;
case GLUT_KEY_UP:
girax-=15;
break;
case GLUT_KEY_DOWN:
girax+=15;
break;
default: break;
}
glutPostRedisplay();
}
int main ( int argc, char** argv )
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize (600,600);
glutInitWindowPosition (100,100);
104

105. glutCreateWindow ("Objetos 3D");
//init ( );
glutDisplayFunc (dibuja);
//glutIdleFunc(dibuja);
glutReshapeFunc ( reshape );
glutKeyboardFunc(teclado);
glutSpecialFunc(flechas);
glutMotionFunc(activo);
glutMainLoop( );
return 0;
}
Resultado:
105

106. 106