El código crea un tablero de ajedrez de 8x8 usando OpenGL. Usa dos colores (amarillo y negro) y puntos de 50 píxeles de diámetro para dibujar las celdas en una cuadrícula, alternando los colores en filas y columnas para formar el patrón de ajedrez.

1. Colegio de Estudios Científicos y
Tecnológicos del Estado de México.
P l a n t e l: Tecámac
Carrera: Técnico en Informática
Asignatura: Utilización de Software de Diseño para
el Manejo de Gráficos
Docente: René Domínguez Escalona
Alumno:
Mendoza González Guillermo Octavio
Pérez Luna María Fernanda
Título: ”Manual de prácticas de OpenGl ”
1

2. Introducción
¿Qué es OpenGl?
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 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 porSilicon Graphics Inc. (SGI) en 19922 y se usa
ampliamente en CAD, realidad virtual, representación científica, visualización de
información ysimulación de vuelo. También se usa en desarrollo de videojuegos,
donde compite con Direct3D en plataformas Microsoft Windows.
¿Cuáles son la primitiva geométrica?
 Formas geométricas consideradas primitivas por su básica constitución en las
partes que la conforman, se conocen también con el nombre de primitivas
geométricas cuyas formas son elCírculo, el Triángulo y el Cuadrado.
 Las primitivas geométricas en un software 3D pueden ser editadas para
conseguir formas geométricas más complejas, agregando
nuevos vértices, aristas y polígonos.
 Las primitivas son grupos de diversos objetos básicos, por ejemplo: los de tipo
bidimensional o 2d: son el círculo, el cuadrado y otras formas básicas.
 En cuanto a primitivas tridimensionales existen los cilindros, el tubo, el torus, la
esfera y el cubo, entre otros.

¿Cómo se crea una ventana en open gl?
Descripción de las funciones principales y variables
Funciones Principales
Los pasos necesarios para crear una ventana en OpenGL los podemos clasificar
como sigue:
- Creamos una ventana.
2

3. - Establecemos el marco de visión y la perspectiva.
- Inicializamos las variables de estado de OpenGL.
Las funciones principales necesarias para inicializar GL son:
CreaVentanaGL: 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.
EliminaVentanaGL: Libera todos los recursos usados por la ventana.
InicializaEscenaGL: Establece el marco de visión (Viewport) de la escena, así
como la perspectiva que vamos a
utilizar.
InicializaGL: Inicializamos todos los valores internos de OpenGL, como por
ejemplo el tipo de sombreado y luces,
si vamos a utilizar mapeado de texturas, el color de fondo de la escena,...
De este modo la función CreaVentanaGL, después de crear la ventana, llamaría a
InicializaEscenaGL y
posteriormente a InicializaGL y ya tendríamos nuestra ventana creada. Si por
algún motivo la llamada a las dos
últimas funciones fallara, eliminariamos la ventana mediante EliminaVentanaGL y
saldríamos de la aplicación.
Aplicaciones de open gl
Sin entrar en demasiados detalles, describiremos algunas de las características
que OpenGL implementa:
Primitivas geométricas Permiten construir descripciones matemáticas de
objetos. Las actuales primitivas son: puntos, líneas, polígonos, imágenes y
bitmaps.
Codificación del Color en modos RGBA (Rojo-Verde-Azul-Alfa) o de color
indexado.
Visualización y Modelado que permite disponer objetos en una escena
tridimensional, mover nuestra cámara por el espacio y seleccionar la
posicíon 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
3

4. La iluminación de materiales es una parte indispensable de cualquier
grágico 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 doble buffering ayuda a eliminar el parpadeo de las animaciones. Cada
fotograma consecutivo en una animación se construye en un buffer
separado de memoria y mostrado solo cuando está completo.
El Anti-alizado reduce los bordes escalonados en las líneas dibujadas
sobre una pantalla de ordenador. Los bordes escalonados aparecen a
menudo cuando las líneas se dibujan con baja resolución. El anti-alizado es
una ténica común en gráficos de ordenador que modifica el color y la
intensidad de los pixels cercanos a la línea para reducir el zig-zag artificial.
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
superfícies.
El Z-buffering mantiene registros de la coordenada Z de un objeto 3D. El
Z-buffer se usa para registrar la proximidad de un objeto al observador, y es
también crucial para el eliminado de superfícies ocultas.
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.
El Alpha blending usa el valor Alfa (valor de material difuso) del código
RGBA, y permite combinar el color del fragmento que se procesa con el del
pixel que ya está en el buffer. Imagina por ejemplo dibujar una ventana
transparente de color azul claro enfrente de una caja roja. El Alpha blending
permite simular la transparencia de la ventana, de manera que la caja vista
a través del cristal aparezca con un tono magenta.
Los planos de plantilla permiten restringir el trazado a ciertas regiones de
la pantalla.
Las listas de Display permiten almacenar comandos de dibujo en una lista
para un trazado posterior, cuando las listas de display se usan
apropiadamente puedan mejorar mucho el rendimiento de nuestras
aplicaciones.
Los Evaluadores Polinómicos sirven para soportar B-splines racionales
no uniformes, esto es para ayudar a dibujar curvas suaves a través de unos
cuantos puntos de referencia, ahorrándose la necesidad de acumular
grandes cantidades de puntos intermedios.
4

5. Características de Feedback, Selección y Elección que ayudan a crear
aplicaciones que permiten al usuario seleccionar una región de la pantalla o
elegir un objeto dibujado en la misma. El modo de feedback permite al
desarrollador obtener los resultados de los cálculos de trazado.
Primitivas de Raster (bitmaps y rectángulos de pixels)
Operaciones con Pixels
Transformaciones: rotación, escalado, perspectivas en 3D
¿Cuáles son las 3 librerías de Opengl y sus
características?
Librería adicionales de OpenGL
La librería principal de OpenGL nos suministra todas las funciones necesarias
para mostrar un entorno 3D aunque hay algunas operaciones que son algo
tediosas de realizar utilizando solo esta librería. Estas son por ejemplo calcular la
matriz de proyección. Para esto se han desarrollado tambien unas librería
auxiliares:
GLU: Esta librería acompaña a la OpenGL principal. Incluye funciones más
complejas que GL por ejemplo difinir un cilindro o un disco con un solo comando,
tambien contiene funciones para trabajar con splines y operaciones con matrices.
GLUT: Esta librería es independiente de la librería OpenGL de cada plataforma.
Esta librería no incluye funciones adiconales para OpenGL :( pero nos permite
utilizar funciones para el tratamiento de ventanas, teclado y ratón. Para trabajar
con OpenGL en cualquier plataforma, primero tenemos que inicializar una ventana
(y esto es diferente entre Windows y Linux por ejemplo). GLUT nos permite crear
ventanas y controlar la entrada independientemente de la plataforma utilizada :).
Aunque tambien contiene comandos para crear conos, tazas de té...
GLAUX: Esta librería, muy parecida a GLUT, es la que Microsoft ha desarrollado
para Windows. Mantiene practicamente la misma estructura que la GLUT con el
defecto de que solo sirve para Windows, mientras que GLUT sirve para cualquier
plataforma.
GLX: Esta es la librería utilizada para trabajar en un sistema de X-Windows
(Linux), permite no sólo renderizar en la máquina local, sino tambien a travez de
una red.
Tambien hay otras librerías más específicas para el control de entrada, sonido,
red.... Evidentemente podemos utilizar las DX, aunque tambien debes saber que
hay una colección de OpenXX que incluyen practicamente las mismas
5

6. características (algunas menos, todo hay que decirlo) que DX, como son OpenAL
(Audio), OpenNL (Red), OpenIN (Entrada)...
¿Cómo configurar open gl en dev c++?
Instalar Opengl en Dev C++
1. Para empezar la instalacion primero abrimos Dev C++ luego nos vamos a la
barra de menu y hacemos click en herramientas , luego hacemos click en Buscar
Actulizaciones
2. Luego nos aparacera una ventana que dira WebUpadate Nos dirigimos a la
parte roja asi como se muestra en la imagen ....
3. Luego expandimos las opciones y selecionamos devpak.org Comunity Dev
Paks
4. Luego hacemos click en Check for Updates
5. Luego nos aparacera un monton de actualizaciones Bueno a nosotros nos
interesa solo opengl .... Bueno entocnes solo marcamos el check de glut y freglut
6. Luego le damos click en Dowload selected y empezaran a descargarse las
opciones marcadas en nuestro caso el glut y freglut
7. Y Por ultimo cuando se ayan descargado todos los paquetes selecionados nos
aparacera una ventana como esta solo le damos click en install y listo :)
6

7. Índice
Portada………………………………………………………… 01
Introducción……………………………………………………..02-06
Índice……………………………………………………………07
Practica 1: Tablero de Ajedrez………………………………..08-12
Practica 2: Estrella……………………………………………..13-14
Practica 3: Cubo con líneas……………………………………15-17
Practica 4: Cubo delineado…………………………………….18-21
Practica 5: Muñeco con triángulos…………………………….22-26
Practica 6: Casita……………………………………………....27-39
Practica 7: Oso………………………………………………….40-44
Practica 8: Cubo con cubitos…………………………………..45-48
Practica 9: Muñeco con formas………………………………..49-55
Practica 10: Animación de circulo rotando……………………56-58
Practica 11: Animación del Sistema Solar…………………….59-61
Practica 12: Movimiento en ocho……………………………....62-64
Practica 13: Semáforo…………………………………………..65-69
Practica 14: Cubo en 3D………………………………………..70-73
Practica 15: Nombres en 3D……………………………………74-80
Practica Extra: Pirámide…………………………………………81-84
7

8. Practicas
Practica No.1: Tablero de Ajedrez
Descripción: En esta práctica debemos de realizar un tablero de
ajedrez de 8 X 8 en el cual allá dos colores diferentes y que se vayan
combinando los colores entre sí.
Borrador con coordenadas utilizadas:
Código:
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(1.0 ,1.0 ,0.0);
glPointSize(50);
8

9. glBegin (GL_POINTS);
glVertex2i(100,100);
glVertex2i(300,100);
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(1.0 ,1.0 ,0.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);
glVertex2i(100,200);
glVertex2i(300,200);
glVertex2i(500,200);
glVertex2i(700,200);
glColor3f(1.0 ,1.0 ,0.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);
9

10. glVertex2i(200,300);
glVertex2i(400,300);
glVertex2i(600,300);
glVertex2i(800,300);
glColor3f(1.0 ,1.0 ,0.0);
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(1.0 ,1.0 ,0.0);
glPointSize(50);
glBegin (GL_POINTS);
glVertex2i(100,500);
glVertex2i(300,500);
glVertex2i(500,500);
glVertex2i(700,500);
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(1.0 ,1.0 ,0.0);
glPointSize(50);
glBegin (GL_POINTS);
glVertex2i(200,600);
10

11. 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);
glVertex2i(500,600);
glVertex2i(700,600);
glColor3f(1.0 ,1.0 ,0.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);
glVertex2i(300,800);
glVertex2i(500,800);
glVertex2i(700,800);
glColor3f(1.0 ,1.0 ,0.0);
glPointSize(50);
glBegin (GL_POINTS);
glVertex2i(200,800);
glVertex2i(400,800);
11

12. glVertex2i(600,800);
glVertex2i(800,800);
glEnd();
glFlush(); //forza dibujo
}
Salida:
12

13. Practica No.2: Estrella
Descripción: En esta práctica bebemos de realizar una estrella de
cinco picos con la función de líneas.
Borrador con coordenadas utilizadas:
Código:
void dibuja(void) //funcion dibuja
13

14. {
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(0.0,0.0,0.0);
glLineWidth(5);
glBegin(GL_LINES);
glVertex2i(100,100);
glVertex2i(300,550);
glVertex2i(300,550);
glVertex2i(500,100);
glVertex2i(500,100);
glVertex2i(100,350);
glVertex2i(100,350);
glVertex2i(500,350);
glVertex2i(500,350);
glVertex2i(100,100);
glEnd();
glFlush(); //forza dibujo
}
Salida:
14

15. Practica No.3: Cubo con líneas
Descripción: En esa práctica debemos de utilizar la función de línea
y debemos de realizar un cubó el tamaño que deseemos.
Borrador con coordenadas utilizadas:
Código:
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glLineWidth(5);
glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_LINES);
glVertex2i(200,200);
15

16. glVertex2i(200,400);
glVertex2i(200,400);
glVertex2i(400,400);
glVertex2i(400,400);
glVertex2i(400,200);
glVertex2i(400,200);
glVertex2i(200,200);
glVertex2i(300,300);
glVertex2i(300,500);
glVertex2i(300,500);
glVertex2i(500,500);
glVertex2i(500,500);
glVertex2i(500,300);
glVertex2i(500,300);
glVertex2i(300,300);
glVertex2i(200,200);
glVertex2i(300,300);
glVertex2i(400,200);
glVertex2i(500,300);
glVertex2i(200,400);
glVertex2i(300,500);
glVertex2i(400,400);
glVertex2i(500,500);
glEnd();
glFlush(); //forza dibujo
}
Salida:
16

17. 17

18. Practica No.4: Cubo delineado
Descripción: En esta actividad debemos de realizar un cubo pero
ahora debe de ir relleno de color y delineado negro. Para eso
debemos de utilizar la función de cuadros para el relleno y la de líneas
para el delineado.
Borrador con coordenadas utilizadas:
Código:
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
18

19. glBegin(GL_QUADS);
// parte de frente
glColor3f(1.0,0.0,0.0);
glVertex2i(200,200);
glColor3f(0.0,1.0,0.0);
glVertex2i(400,200);
glColor3f(0.0,0.0,1.0);
glVertex2i(400,400);
glColor3f(1.0,0.0,1.0);
glVertex2i(200,400);
// parte de lado
glColor3f(0.0,1.0,0.0);
glVertex2i(400,200);
glColor3f(1.0,0.0,0.0);
glVertex2i(500,300);
glColor3f(0.0,0.0,1.0);
glVertex2i(500,500);
glColor3f(1.0,1.0,0.0);
glVertex2i(400,400);
// parte de arriba
glColor3f(1.0,0.0,1.0);
glVertex2i(200,400);
glColor3f(1.0,1.0,0.0);
glVertex2i(400,400);
glColor3f(1.0,1.0,1.0);
glVertex2i(500,500);
glColor3f(0.0,0.0,0.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);
19

20. 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);
glVertex2i(200,400);
glEnd();
glFlush(); //forza dibujo
}
Salida:
20

21. 21

22. Practica No.5: Muñeco con triángulos
Descripción: En esta práctica vamos a utilizar la función de
triángulos, cuadrados y polígonos y vamos a realizar un muñeco con
triángulos, la mayoría de las partes son puros triángulos y deberemos
de utilizar diferentes colores.
Borrador con coordenadas utilizadas:
Código:
22

23. 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(1.0,1.0,0.0);
glVertex2i(250,750);
glColor3f(0.0,1.0,0.0);
glVertex2i(550,750);
glColor3f(0.0,1.0,1.0);
glVertex2i(400,850);
//triangulo de la cabeza 2
glColor3f(0.0,1.0,0.0);
glVertex2i(300,750);
glColor3f(1.0,0.0,0.0);
glVertex2i(500,750);
glColor3f(0.0,0.0,1.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);
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,1.0);
glVertex2i(100,300);
glColor3f(1.0,1.0,0.0);
glVertex2i(50,400);
glColor3f(0.0,1.0,0.0);
23

24. 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(1.0,1.0,0.0);
glVertex2i(500,600);
glColor3f(0.0,1.0,1.0);
glVertex2i(650,300);
glColor3f(1.0,1.0,1.0);
glVertex2i(700,350);
glColor3f(1.0,0.0,1.0);
glVertex2i(700,350);
glColor3f(1.0,1.0,0.0);
glVertex2i(750,300);
glColor3f(0.0,1.0,1.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);
glVertex2i(200,100);
// triangulos de la pierna y pie derecho
glColor3f(1.0,1.0,0.0);
24

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

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

27. Practica No.6: Casita
Descripción: En esta práctica utilizaremos todas las funciones ya
aprendidas anterior mente ya que realizaremos una casa con
ventanas, puertas, barandales, arboles entre otras cosas y
utilizaremos diferentes combinaciones de colores para cada accesorio.
Borrador con coordenadas utilizadas:
Código:
void dibuja(void) //funcion dibuja
{
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);
27

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

29. glVertex2i(50,600);
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);
// parte de la casa3 (rosa)
glColor3f(1.0,0.0,1.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);
29

30. // 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);
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);
glVertex2i(450,450);
glVertex2i(550,450);
glVertex2i(550,550);
30

31. 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);
// 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);
31

32. glVertex2i(700,750);
glVertex2i(600,750);
glEnd();
glLineWidth(5);
glBegin(GL_LINES);
glColor3f(1.0,1.0,1.0);
// 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);
glVertex2i(700,50);
glVertex2i(800,50);
glColor3f(1.0,1.0,1.0);
glVertex2i(850,50);
glVertex2i(950,50);
// lineas de la ventana 1
32

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

34. glVertex2i(750,450);
glVertex2i(850,450);
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);
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();
34

35. // tronco del arbol
glBegin(GL_QUADS);
glColor3f(0.6,0.5,0.4);
glVertex2i(900,350);
glVertex2i(950,350);
glVertex2i(950,500);
glVertex2i(900,500);
glEnd();
// hojas de los arboles
glLineWidth(3);
glBegin(GL_LINES);
glColor3f(0.0,0.5,0.1);
glVertex2i(850,500);
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);
glVertex2i(910,560);
glVertex2i(940,560);
glVertex2i(920,570);
glVertex2i(930,570);
35

36. glEnd();
glBegin(GL_QUADS);
glColor3f(0.7,0.1,0.5);
glVertex2i(100,50);
glVertex2i(300,50);
glVertex2i(300,100);
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);
glVertex2i(950,150);
glColor3f(0.0,0.0,0.0);
glVertex2i(900,150);
glVertex2i(950,150);
glVertex2i(950,200);
36

37. glVertex2i(900,200);
glEnd();
// tronco del arbol
glBegin(GL_QUADS);
glColor3f(0.6,0.5,0.4);
glVertex2i(50,350);
glVertex2i(100,350);
glVertex2i(100,500);
glVertex2i(50,500);
glEnd();
// hojas de los arboles
glLineWidth(3);
glBegin(GL_LINES);
glColor3f(0.0,0.5,0.1);
glVertex2i(0,500);
glVertex2i(150,500);
glVertex2i(10,510);
glVertex2i(140,510);
glVertex2i(20,520);
glVertex2i(130,520);
glVertex2i(30,530);
glVertex2i(120,530);
glVertex2i(40,540);
glVertex2i(110,540);
glVertex2i(50,550);
glVertex2i(100,550);
glVertex2i(60,560);
glVertex2i(90,560);
37

38. glVertex2i(70,570);
glVertex2i(80,570);
glEnd();
glBegin(GL_LINES);
glLineWidth(3);
// barandal de la ventana
glColor3f(0.0,0.0,0.0);
glVertex2i(600,700);
glVertex2i(700,700);
glColor3f(0.0,0.0,0.0);
glVertex2i(600,600);
glVertex2i(600,700);
glVertex2i(625,600);
glVertex2i(625,700);
glVertex2i(650,600);
glVertex2i(650,700);
glVertex2i(675,600);
glVertex2i(675,700);
glVertex2i(700,600);
glVertex2i(700,700);
glVertex2i(600,600);
glVertex2i(700,600);
glEnd();
glFlush(); //forza dibujo
}
Salida:
38

39. 39

40. Practica No.7: Oso
Descripción: En esta actividad deberás de realizar un oso con la
función de círculo.
Borrador con coordenadas utilizadas:
40

41. Código:
void circuloc(int x, int y, int t, int radio)
{
int angulo=0;
glPointSize(t);
glBegin(GL_POINTS);
//glColor3f (1.0, 0.0, 1.0);
glVertex2f(x,y);
//glColor3f(0,0.0,0.0);
for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x +
sin(angulo) * radio, y + cos(angulo) * radio);}
glEnd();
}
void circulo(int x, int y, int radio)
{
int angulo=0;
glBegin(GL_TRIANGLE_FAN);
// glColor3f (1.0, 0.0, 1.0);
glVertex2f(x,y);
for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x +
sin(angulo) * radio, y + cos(angulo) * radio);}
glEnd();
}
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT);
//panza
glColor3f(0.2,0.1,0.1); //borra pantalla
circulo(280,200,100);
glColor3f(0.9,0.7,0.8);
circulo(280,200,60);
//pie izq
41

42. glColor3f(0.2,0.1,0.1);
circulo(190,100,40);
glColor3f(0.9,0.7,0.8);
circulo(190,100,20);
//pie der
glColor3f(0.2,0.1,0.1);
circulo(370,100,40);
glColor3f(0.9,0.7,0.8);
circulo(370,100,20);
//mano derecha
glColor3f(0.2,0.1,0.1);
circulo(390,280,40);
glColor3f(0.9,0.7,0.8);
circulo(390,280,20);
//mano izq
glColor3f(0.2,0.1,0.1);
circulo(170,280,40);
glColor3f(0.9,0.7,0.8);
circulo(170,280,20);
//cabeza
glColor3f(0.2,0.1,0.1);
circulo(280,350,60);
//oreja izq
glColor3f(0.2,0.1,0.1);
circulo(220,400,20);
glColor3f(0.9,0.7,0.8);
circulo(220,400,10);
//oreja dere
glColor3f(0.2,0.1,0.1);
circulo(340,400,20);
glColor3f(0.9,0.7,0.8);
circulo(340,400,10);
//ojo izq
42

43. glColor3f(0.0,0.0,0.0);
circulo(260,370,20);
glColor3f(0.9,0.7,0.4);
circulo(260,370,5);
//ojo der
glColor3f(0.0,0.0,0.0);
circulo(300,370,20);
glColor3f(0.9,0.7,0.4);
circulo(300,370,5);
//nariz
glColor3f(1.0,1.0,1.0);
circulo(280,340,10);
glEnd();
glBegin(GL_LINES);
glColor3f(1.0,1.0,1.0);
glVertex2i(280,330);
glVertex2i(280,310);
glVertex2i(250,310);
glVertex2i(310,310);
glEnd();
glFlush(); //forza dibujo
}
Salida:
43

44. 44

45. Practica No.8: Cubo con cubitos
Descripción: Debes de realizar un cubo con cubitos en el cual sea 8
X 8 y que no tenga rellenos solamente estén los cubitos.
Borrador con coordenadas utilizadas:
Código:
void cubo (int x, int y,int t,int l){
double a=.8,b=.6;
glColor3f(0.2 , 0.7 , 0.7);
glBegin(GL_QUADS);
glVertex2f(x,y);
glVertex2f(x+t,y);
glVertex2f(x+t,y+t);
glVertex2f(x,y+t);
glColor3f(0.0 , 0.5 , 0.8);
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.8 , 0.0 , 0.4);
glVertex2f(x+t,y+t);
45

46. 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(3);
glBegin(GL_LINES);
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);
glVertex2f(x+t,y+t);
glEnd();
46

47. }
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);
}
//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
47

48. 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);
}
glFlush(); //forza dibujo
}
Salida:
48

49. Practica No.9: Muñeco con formas
Descripción: En esta práctica debes de realizar un muñeco con
triángulos, cuadros, polígonos y que vayan rellenos de colores que el
dibujó te vaya indicando.
Borrador con coordenadas utilizadas:
Código:
49

50. void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
// pie izquierdo
glBegin(GL_QUADS);
glColor3f(0.0,0.0,0.0);
glVertex2i(200,100);
glVertex2i(300,100);
glVertex2i(300,150);
glVertex2i(250,150);
// pie derecho
glColor3f(0.0,0.0,0.0);
glVertex2i(450,100);
glVertex2i(450,150);
glVertex2i(500,150);
glVertex2i(550,100);
// pantalon
glColor3f(0.2,0.2,0.7);
glVertex2i(275,250);
glVertex2i(300,325);
glVertex2i(450,325);
glVertex2i(475,250);
glColor3f(0.2,0.2,0.7);
glVertex2i(250,150);
glVertex2i(275,250);
glVertex2i(375,250);
glVertex2i(300,150);
glColor3f(0.2,0.2,0.7);
glVertex2i(375,250);
glVertex2i(475,250);
glVertex2i(500,150);
glVertex2i(450,150);
// cinturon
50

51. glColor3f(1.0,1.0,1.0);
glVertex2i(300,325);
glVertex2i(300,350);
glVertex2i(450,350);
glVertex2i(450,325);
glColor3f(0.0,0.0,0.0);
glVertex2i(350,325);
glVertex2i(350,350);
glVertex2i(400,350);
glVertex2i(400,325);
// camisa
glColor3f(0.9,0.3,0.3);
glVertex2i(300,350);
glVertex2i(300,600);
glVertex2i(450,600);
glVertex2i(450,350);
// camisa torax
glVertex2i(225,550);
glVertex2i(250,600);
glVertex2i(500,600);
glVertex2i(525,550);
// manga izquierda
glVertex2i(200,450);
glVertex2i(225,550);
glVertex2i(300,550);
glVertex2i(250,450);
// manga derecha
glVertex2i(500,450);
glVertex2i(450,550);
glVertex2i(525,550);
glVertex2i(550,450);
// mano izquierda
glColor3f(0.9,0.8,0.7);
glVertex2i(200,375);
51

52. glVertex2i(210,450);
glVertex2i(230,450);
glVertex2i(220,375);
// mano derecha
glVertex2i(510,375);
glVertex2i(510,450);
glVertex2i(530,450);
glVertex2i(530,375);
// botones de la camisa
glColor3f(0.3,0.8,0.8);
glVertex2i(350,525);
glVertex2i(350,550);
glVertex2i(400,550);
glVertex2i(400,525);
glVertex2i(350,475);
glVertex2i(350,500);
glVertex2i(400,500);
glVertex2i(400,475);
glVertex2i(350,425);
glVertex2i(350,450);
glVertex2i(400,450);
glVertex2i(400,425);
glVertex2i(350,375);
glVertex2i(350,400);
glVertex2i(400,400);
glVertex2i(400,375);
// cuello
glColor3f(0.9,0.8,0.7);
glVertex2i(350,600);
glVertex2i(350,650);
glVertex2i(400,650);
glVertex2i(400,600);
52

53. glEnd();
glBegin(GL_TRIANGLES);
glColor3f(0.9,0.8,0.7);
glVertex2i(350,600);
glVertex2i(400,600);
glVertex2i(375,550);
// cabeza circulo
glColor3f(0.9,0.8,0.7);
circulo(375,750,150);
circulo(225,750,15);
circulo(525,750,15);
glEnd();
glBegin(GL_QUADS);
glColor3f(0.0,0.0,0.0);
glVertex2i(300,750);
glVertex2i(350,750);
glVertex2i(350,800);
glVertex2i(300,800);
glColor3f(0.0,0.0,0.0);
glVertex2i(400,750);
glVertex2i(450,750);
glVertex2i(450,800);
glVertex2i(400,800);
glEnd();
glBegin(GL_POLYGON);
glColor3f(1.0,1.0,1.0);
glVertex2i(350,725);
glVertex2i(375,700);
glVertex2i(400,725);
53

54. glEnd();
glLineWidth(5);
glBegin(GL_LINES);
glColor3f(0.0,0.0,0.0);
glVertex2i(300,650);
glVertex2i(450,650);
glEnd();
glBegin(GL_TRIANGLES);
glColor3f(0.4,0.2,0.1);
glVertex2i(300,880);
glVertex2i(375,950);
glVertex2i(450,880);
glVertex2i(435,890);
glVertex2i(490,890);
glVertex2i(510,815);
glVertex2i(310,880);
glVertex2i(245,905);
glVertex2i(245,830);
glEnd();
glBegin(GL_POLYGON);
glColor3f(0.9,0.8,0.7);
glVertex2i(510,375);
glVertex2i(490,350);
glVertex2i(520,370);
glVertex2i(510,320);
glVertex2i(525,380);
glVertex2i(520,390);
glVertex2i(545,350);
glEnd();
glBegin(GL_POLYGON);
54

55. glColor3f(0.9,0.8,0.7);
glVertex2i(200,375);
glVertex2i(180,350);
glVertex2i(210,370);
glVertex2i(205,320);
glVertex2i(215,380);
glVertex2i(210,390);
glVertex2i(235,350);
glEnd();
glFlush(); //forza dibujo
}
Salida:
55

56. Practica No.10: Animación de circulo rotando
Descripción: En esta actividad debes de realizar que el círculo vaya
dando vueltas por toda la ventana de OpenGl.
Borrador con coordenadas utilizadas:
Código:
void dibuja(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if(x>=1 && x<500){
circulo(2+1*x,500,50);
glFlush();
x++;
}
if(y>=1 && y<500 && x==500){
circulo(500,500+y,50);
56

57. glFlush();
y++;
}
if(k>=1 && k<500 && x==500 && y==500){
circulo(500-k,1000,50);
glFlush();
k++;
}
if(z>=1 && z<500 && x==500 && y==500 && k==500){
circulo(5,1000-z,50);
glFlush();
z++;
if(z==500){x=1; y=1; k=1; z=1;}
}
glutSwapBuffers();
}
Salida:
57

58. 58

59. Practica No.11: Animación del Sistema Solar
Descripción: En esta práctica realizaremos una animación en el
cual nosotros vamos a hacer la simulación del sistema solar y que los
planetas vayan girando sobre su eje de rotación.
Borrador con coordenadas utilizadas:
Código:
void dibuja(void)
59

60. {
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);
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);
60

61. c+=0.02;
d+=0.03;
e+=0.04;
f+=0.07;
g+=0.09;
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
}
Salida:
61

62. Practica No.12: Movimiento en ocho
Descripción: En esta práctica debemos de realizar que una pelotita
se mueva en una dirección de ocho.
Borrador con coordenadas utilizadas:
Código:
void dibuja(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//esto
62

63. glColor3f (1.0, 0.5, 0.4);//primer circulo
circulo(400,400,150);
glColor3f (0.4, 0.7, 0.2);
circulo(400,400,100);
glColor3f (1.0, 0.5, 0.4);// segundo circulo
circulo(400,650,150);
glColor3f (0.4, 0.7, 0.2);
circulo(400,650,100);
//bolitas
glColor3f (0.0, 0.0, 0.0);
if(a>=6.15 && a<12.40){
circulo(400 -sin(a) * 125,400 +cos(a) * 125,10);
a=a+0.1;
}
else{
circulo(400 -sin(b)* 125,650 +cos(b)* -125,10);
b=b+0.1;
if(b>12.40) (a=6.15, b=6.15);
}
glFlush(); //forzar dibujado
glutSwapBuffers(); //y esto
Salida:
63

64. 64

65. Practica No.13: Semáforo
Descripción: En esta práctica vamos a realizar un semáforo en el
cual el semáforo vaya cambiando los colores como lo es un semáforo
de realidad.
Borrador con coordenadas utilizadas:
Código:
65

66. 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.0,0.0,0.0);
glBegin(GL_QUADS);
glVertex2i(200,350);
glVertex2i(350,350);
glVertex2i(350,650);
glVertex2i(200,650);
// parte delgada
glVertex2i(250,100);
glVertex2i(300,100);
glVertex2i(300,350);
glVertex2i(250,350);
glEnd();
// lineas del semaforo
glLineWidth(5);
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINES);
glVertex2i(200,450);
glVertex2i(350,450);
glVertex2i(200,550);
glVertex2i(350,550);
// lineas de contorno
glVertex2i(200,350);
glVertex2i(200,650);
glVertex2i(200,650);
glVertex2i(350,650);
glVertex2i(350,650);
glVertex2i(350,350);
glVertex2i(350,350);
glVertex2i(200,350);
66

67. // lineas del contorno del tronco
glVertex2i(250,100);
glVertex2i(250,350);
glVertex2i(250,350);
glVertex2i(300,350);
glVertex2i(300,350);
glVertex2i(300,100);
glVertex2i(300,100);
glVertex2i(250,100);
glEnd();
glColor3f(0.0,0.0,0.0);
circulo(275,600,40);
glColor3f(0.0,0.0,0.0);
circulo(275,500,40);
glColor3f(0.0,0.0,0.0);
circulo(275,400,40);
a=a+1;
for(int j=1 ;j<=10000000; j++){}
if(a>1 && a<40){
glColor3f(1.0,0.0,0.0);
circulo(275,600,40);
}
if(a>40 && a<70){
glColor3f(0.8,0.1,0.1);
circulo(275,600,40);
}
if(a>100 && a<130){
glColor3f(1.0,0.9,0.0);
circulo(275,500,40);
}
67

68. if(a>70 && a<100){
glColor3f(0.2,0.6,0.3);
circulo(275,400,40);
}
if(a>130 && a<1){
glColor3f(1.0,0.0,0.0);
circulo(275,600,40);
}
if(a>130){a=0;}
glEnd();
glFlush(); //forza dibujo
glutSwapBuffers();
}
Salida:
68

69. 69

70. Practica No.14: Cubo 3D
Descripción: En esta actividad realizaremos con funciones en 3D el
un cubo el cual tenga movimiento con el mouse y se vea en tercera
dimensión.
Borrador con coordenadas utilizadas:
Código:
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
70

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

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

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

74. Practica No.15: Nombre 3D
Descripción: En esta actividad realizaremos con funciones en 3D el
nombre de nosotros en cual tenga movimiento con el mouse y se vea
en tercera dimensión.
Borrador con coordenadas utilizadas:
Código:
void dibuja( void )
{
glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
74

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

76. //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(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);
glTranslatef(1.0,0.0, 0.0);
glutSolidCube(1);
glTranslatef(1.0,0.0, 0.0);
glutSolidCube(1);
glTranslatef(-3.0,-3.0, 0.0);
glutSolidCube(1);
glTranslatef(5.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);
76

77. 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);
glTranslatef(1.0,0.0, 0.0);
glutSolidCube(1);
glTranslatef(-2.0,3.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,3.0, 0.0);
glutSolidCube(1);
glTranslatef(1.0,0.0, 0.0);
glutSolidCube(1);
glTranslatef(1.0,0.0, 0.0);
glutSolidCube(1);
glTranslatef(2.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(0.0,-1.0, 0.0);
glutSolidCube(1);
77

78. glTranslatef(0.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(0.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(1.0,6.0, 0.0);
glutSolidCube(1);
glTranslatef(1.0,0.0, 0.0);
glutSolidCube(1);
glTranslatef(1.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(-1.0,0.0, 0.0);
glutSolidCube(1);
glTranslatef(-1.0,0.0, 0.0);
glutSolidCube(1);
glTranslatef(2.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(1.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(1.0,-1.0, 0.0);
glutSolidCube(1);
glTranslatef(1.0,-1.0, 0.0);
glutSolidCube(1);
// AQUI PONES TU NOMBRE
78

79. //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);
}
Salida:
79

80. 80

81. Practica Extra: La pirámide
Descripción: En esta práctica debemos de realizar una pirámide
con 10 cuadros y que vayan disminuyendo, con una función en
especial y ponerle líneas de esquina a esquina.
Borrador con coordenadas utilizadas:
Código:
void dibuja(void) //funcion dibuja
{
int i,a=20;
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(1.0 , 1.0 , 0.0);
glBegin(GL_LINES);
81

82. //valor inicial --- valor final o condicion --- incremento
for(i=1;i<=10;i++){
//abajo
glVertex2i(300-a*i,300-a*i);
glVertex2i(320+a*i,300-a*i);
//derecha
glVertex2i(320+a*i,300-a*i);
glVertex2i(320+a*i,320+a*i);
//izquierda
glVertex2i(300-a*i,300-a*i);
glVertex2i(300-a*i,320+a*i);
//arriba
glVertex2i(300-a*i,320+a*i);
glVertex2i(320+a*i,320+a*i);
}
glEnd();
glBegin(GL_LINES);
glColor3f(1.0,1.0,0.0);
glVertex2i(120,120);
glVertex2i(100,100);
glVertex2i(140,140);
glVertex2i(160,160);
glVertex2i(180,180);
glVertex2i(200,200);
glVertex2i(220,220);
glVertex2i(240,240);
glVertex2i(260,260);
glVertex2i(280,280);
glVertex2i(520,520);
glVertex2i(500,500);
82

83. glVertex2i(480,480);
glVertex2i(460,460);
glVertex2i(440,440);
glVertex2i(420,420);
glVertex2i(400,400);
glVertex2i(380,380);
glVertex2i(360,360);
glVertex2i(340,340);
glVertex2i(100,520);
glVertex2i(120,500);
glVertex2i(140,480);
glVertex2i(160,460);
glVertex2i(180,440);
glVertex2i(200,420);
glVertex2i(220,400);
glVertex2i(240,380);
glVertex2i(260,360);
glVertex2i(280,340);
glVertex2i(340,280);
glVertex2i(360,260);
glVertex2i(380,240);
glVertex2i(400,220);
glVertex2i(420,200);
83

84. glVertex2i(440,180);
glVertex2i(460,160);
glVertex2i(480,140);
glVertex2i(500,120);
glVertex2i(520,100);
glEnd();
glFlush(); //forza dibujo
}
Salida:
84