1. COLEGIO DE ESTUDIOS CIENTIFICOS Y TECNOLOGICOS
DEL ESTADO DE MEXICO
LEIDY VIVANI OLVERA LEON
ROSARIO GUTIERREZ URBINA
GRUPO: 303
PROFESOR: RENE DOMINGUEZ ESCALONA
MANUAL DE OPEN GL

2. INTRODUCCION
OpenGL es una interfaz software de hardware gráfico, es decirdefine las funciones
que se pueden utilizar en una aplicación para acceder a las prestaciones de un
dispositivo gráfico. Es un motor 3D cuyas rutinas están integradas en tarjetas
gráficas 3D. Fue desarrollado por Sillicon Graphics, Inc. (SGI) con el afán de hacer
un estándar de representación en 3D. Es compatible con prácticamente cualquier
plataforma hardware así como con muchos lenguajes de programación (C,C++,
Visual Basic, Visual Fortran, Java)
En este manual aprenderemos a realizar algunas prácticas en el programa Open
Gl Dev c++, asi mismo aprenderemos las partes que lo componen y las primitivas
que se deben de usar para la realización de distintos dibujos y animaciones en
dicho programa.

3. TABLERO DE AJEDREZ
En esta práctica realizaremos un tablero de ajedrez utilizando las primitivas
glBegin(GL_POINTS); esta primitiva nos servirá para realizar los puntos en los que
estará situado cada uno de los cuadros, así mismo utilizaremos la primitiva
glPointSize(); para ponerle un tamaño especifico a los puntos que se realizarán
para los cuadros utilizados en esta actividad.
Recuerda que los tableros de ajedrez tienen 8 cuadros por cada lado del tablero
así que tendrás que definir bien las coordenadas para cada uno de los cuadros
para que esta actividad salga de la forma en que la quieres.
BORRADOR
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,1.0); //color de fondo
glMatrixMode(GL_PROJECTION); //Modo de proyeccion
glLoadIdentity(); //Establece los parametros de proyeccion
gluOrtho2D(0.0, 1050.0, 0.0, 1000.0); //vista ortogonal
}
void dibuja(void) //funcion dibuja
{

4. glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(0.0 , 0.0 , 0.0);
glPointSize(60);
glBegin(GL_POINTS);
glVertex2i(100,100);
glVertex2i(347,100);
glVertex2i(597,100);
glVertex2i(848,100);
glVertex2i(220,220);
glVertex2i(473,220);
glVertex2i(723,220);
glVertex2i(970,220);
glVertex2i(100,340);
glVertex2i(347,340);
glVertex2i(597,340);
glVertex2i(848,340);
glVertex2i(220,460);
glVertex2i(473,460);
glVertex2i(723,460);
glVertex2i(970,460);
glVertex2i(100,580);
glVertex2i(347,580);
glVertex2i(597,580);
glVertex2i(848,580);
glVertex2i(220,700);
glVertex2i(473,700);

5. glVertex2i(723,700);
glVertex2i(970,700);
glVertex2i(100,820);
glVertex2i(347,820);
glVertex2i(597,820);
glVertex2i(848,820);
glEnd();
glColor3f(1.0 , 1.0 , 1.0);
glPointSize(60);
glBegin(GL_POINTS);
glVertex2i(220,100);
glVertex2i(473,100);
glVertex2i(723,100);
glVertex2i(970,100);
glVertex2i(100,220);
glVertex2i(347,220);
glVertex2i(597,220);
glVertex2i(848,220);
glVertex2i(220,340);
glVertex2i(473,340);
glVertex2i(723,340);
glVertex2i(970,340);
glVertex2i(100,460);
glVertex2i(347,460);
glVertex2i(597,460);
glVertex2i(848,460);

6. glVertex2i(220,580);
glVertex2i(473,580);
glVertex2i(723,580);
glVertex2i(970,580);
glVertex2i(100,700);
glVertex2i(347,700);
glVertex2i(597,700);
glVertex2i(848,700);
glVertex2i(220,820);
glVertex2i(473,820);
glVertex2i(723,820);
glVertex2i(970,820);
glEnd();
glFlush(); //forza dibujo
}
int main (int argc, char** argv) //metodo main
{
glutInit(&argc, argv); //incializa GLUT
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

7. }

8. CUBO CON LINEAS
En esta actividad realizaremos un cubo con puras líneas para ello ocuparemos la
primitiva (GL_LINES) con esta podremos realizar todas las líneas del cubo, así
mismo utilizaremos la primitiva, glLineWidth (); con la cual podremos ponerle el
tamaño que deseemos a la líneas que conformaran el cubo, con las primitivas
anteriores realizaremos el cubo como el que se muestra a continuación:
El código de dicho cubo nos quedara de la siguiente forma:
//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
gluOrtho2D(50.0, 500.0, 50.0, 500.0); //vista ortogonal
}
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT);
glLineWidth (10);

9. glBegin(GL_LINES);
// atras
glColor3f (1.0 , 1.0 , 1.0);
glLineWidth (20);
glVertex2i (100,200);
glVertex2i (300,200);
glVertex2i (300,200);
glVertex2i (300,400);
glVertex2i (300,400);
glVertex2i (100,400);
glVertex2i (100,400);
glVertex2i (100,200);
// frente
glColor3f (1.0,1.0, 1.0);
glVertex2i (200,100);
glVertex2i (200,300);
glVertex2i (200,300);
glVertex2i (400,300);
glVertex2i (400,300);
glVertex2i (400,100);
glVertex2i (400,100);
glVertex2i (200,100);
glColor3f (1.0,1.0, 1.0);
glVertex2i (400,100);
glVertex2i (300,200);

10. glVertex2i (200,100);
glVertex2i (100,200);
glVertex2i (400,300);
glVertex2i (300,400);
glVertex2i (200,300);
glVertex2i (100,400);
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
}

11. El siguiente paso después de la realización del código es compilarlo para verificar
que el código ha sido escrito correctamente y funciona de la forma adecuada
como se muestra a continuación:
ESTRELLA
En esta actividad realizaremos una estrella con puras líneas, para ello utilizaremos
la primitiva (GL_LINES) para realizar las líneas de dicha estrella, así mismo
utilizaremos la primitiva glLineWidth (); la cual nos servirá para colocar el tamaño
de la línea en que se quiera tener la estrella; tenemos que tener en cuenta la
ubicación de las coordenadas de cada punto para que la estrella salga de la forma
en la que esperamos como la que se muestra a continuación:

12. Se darán cuenta de que es muy sencillo realizar una estrella con este programa lo
único que se tiene que hacer es poner atención en las coordenadas que llevara
cada punto y e código quedara de la siguiente forma:
//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
gluOrtho2D(50.0, 500.0, 50.0, 500.0); //vista ortogonal
}
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT);
glLineWidth (5);
glBegin(GL_LINES);
// atras
glColor3f(1.0 , 1.0 , 0.0);

13. glVertex2i(200,100);
glVertex2i(300,400);
glVertex2i(300,400);
glVertex2i(400,100);
glVertex2i(400,100);
glVertex2i (100,300);
glVertex2i (100,300);
glVertex2i (500,300);
glVertex2i (500,300);
glVertex2i (200,100);
glEnd();
glFlush(); //forza dibujo
}
int main (int argc, char** argv) //metodo main
{
glutInit(&argc, argv); //incializa GLUT
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de
visualización
glutInitWindowSize(500,500); //tamaño de la ventana
glutInitWindowPosition(0,0); //posicion inicial de la ventana
glutCreateWindow("MI primer ventana"); //nombre de la ventana
inicializa();
glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización

14. glutMainLoop(); //muestra todo y espera
return 0; //retorna un valor de cero
}
El siguiente paso después de la realización del código es compilarlo para verificar
que el código ha sido escrito correctamente y funciona de la forma adecuada
como se muestra a continuación:

15. PIRAMIDE
En esta actividad realizaremos una pirámide vista desde arriba, para ello
utilizaremos la primitiva (GL_LINES) que nos servirá para la realización de las
líneas correspondientes a la pirámide, así mismo utilizaremos la primitiva
for(i=1;i<=10;i++){ la cual nos servirá para multiplicar las líneas o escalones de la
pirámide, también utilizaremos la primitiva glLineWidth (); para el grosor de las
líneas de nuestra pirámide; en esta practica tendremos cuidado al colocar las
coordenadas que tendrá cada uno de los puntos de nuestra pirámide ya que si no
lo hacemos a si no saldrá de la forma en que esperamos como la que se muestra
a continuación:
Como se abran dado cuenta esta actividad no es sencilla ya que ha y que colocar
distintas coordenadas en cada uno de los puntos de la pirámide para que con la
primitiva for podamos multiplicar las líneas o escalones de la pirámide a
continuación les presentamos el código para la realización de esta práctica:
//mi primer ventana
#include <GL/glut.h>

16. #include <GL/gl.h>
#include <GL/glu.h>
void inicializa(void)
{
glClearColor(0.0,0.0,1.0,0.0); //color de fondo
glMatrixMode(GL_PROJECTION); //Modo de proyeccion
glLoadIdentity(); //Establece los parametros de proyeccion
gluOrtho2D(0.0, 1000.0, 0.0, 1000.0); //vista ortogonal
}
void dibuja(void) //funcion dibuja
{
int i,a=25;
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(1.0 , 0.0 , 0.0);
glLineWidth(5);
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

17. 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);
//lineas
glVertex2i (450,450);
glVertex2i (300,300);
glVertex2i (200,200);
glVertex2i (50,50);
glVertex2i (450,50);
glVertex2i (300,200);
glVertex2i (50,450);
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

18. 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
}
El siguiente paso después de la realización del código es compilarlo para verificar
que el código ha sido escrito correctamente y funciona de la forma adecuada
como se muestra a continuación:

19. CUBO DELINEADO Y RELLENO
En esta actividad realizaremos un cubo relleno y delineado, para ello utilizaremos
la primitiva (GL_QUADS) Con la cual podremos realizar cada una de las caras del
cubo, con esta primitivaglColor3f (0.0, 0.0, 0.0);podemos ponerle color de fondo a
las caras del nuestro cubo, así mismo utilizaremos la primitiva (GL_LINES) ya que
con ella podremos darle el delineado a el cubo, también utilizaremos la primitiva
glLineWidth (); para el grosor de las líneas como el que se muestra a
continuación:
Esta práctica no es muy difícil de hacer ya que utilizamos lo antes visto, lo único
nuevo es la primitiva (GL_QUADS) la cual es muy sencilla de utilizar, siempre y
cuando las coordenadas que se están dando sean las correctas a continuación les
presentamos el código para la realización de esta actividad:
//mi primer ventana
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>

20. void inicializa(void)
{
glClearColor(1.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(0.0 , 0.0 , 0.0);
glBegin(GL_QUADS);
//ATRAS
glColor3f(1.0 , 0.9 , 1.0);
glVertex2d(100,200);
glVertex2d(300,200);
glVertex2d(300,400);
glVertex2d(100,400);
// lado derecho
glColor3f(1.0 , 0.5 , 1.0);
glVertex2d (100,400);
glVertex2d (100,200);

21. glVertex2d (200,100);
glVertex2d (200,300);
// Arriba
glColor3f (1.0, 0.9, 1.0);
glVertex2d (100,400);
glVertex2d (200,300);
glVertex2d (400,300);
glVertex2d (400,300);
// Abajo
glColor3f (1.0, 0.0, 0.5);
glVertex2d (100,200);
glVertex2d (200,100);
glVertex2d (400,100);
glVertex2d (300,200);
// Lado izquierdo
glColor3f (1.0, 0.0, 0.9);
glVertex2d (400,100);
glVertex2d (400,300);
glVertex2d (300,400);
glVertex2d (300,200);
// Frente
glColor3f (1.5, 1.0, 0.0);
glVertex2d (200,100);
glVertex2d (200,300);
glVertex2d (400,300);
glVertex2d (400,100);

22. glEnd();
glColor3f (0.0 , 0.0 , 0.0);
glLineWidth (5);
glBegin(GL_LINES);
// atras
glColor3f (0.0 , 0.0 , 0.0);
glLineWidth (20);
glVertex2i (100,200);
glVertex2i (300,200);
glVertex2i (300,200);
glVertex2i (300,400);
glVertex2i (300,400);
glVertex2i (100,400);
glVertex2i (100,400);
glVertex2i (100,200);
// frente
glColor3f (0.0, 0.0, 0.0);
glVertex2i (200,100);
glVertex2i (200,300);
glVertex2i (200,300);
glVertex2i (400,300);
glVertex2i (400,300);
glVertex2i (400,100);
glVertex2i (400,100);
glVertex2i (200,100);

23. glColor3f (0.0,0.0, 0.0);
glVertex2i (400,100);
glVertex2i (300,200);
glVertex2i (200,100);
glVertex2i (100,200);
glVertex2i (400,300);
glVertex2i (300,400);
glVertex2i (200,300);
glVertex2i (100,400);
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
}

24. El siguiente paso después de la realización del código es compilarlo para verificar
que el código ha sido escrito correctamente y funciona de la forma adecuada
como se muestra a continuación:

25. MUÑECO CON TRIANGULOS
En esta actividad realizaremos un muñequito hecho con triángulos, para ello
utilizaremos la primitiva (GL_TRIANGLES) con la cual realizaremos los triángulos
que llevara el muñeco, así mismo utilizaremos la primitiva (GL_QUADS) para el
cuerpo del muñeco, también ocuparemos la primitiva (GL_POLYGON) que nos
servirá para la realización del trofeo y del balón. A continuación les presentamos
un borrador de las coordenadas que podrán utilizar para realizar esta práctica:
Esta actividad esta un poco complicada ya que estamos utilizando nuevas
primitivas con las cuales no habíamos trabajado antes, pero que no son muy
difíciles de realizarlas solo tienes que prestar atención a las coordenadas que
estas estableciendo para que todo te salga bien A continuación les presentamos el
código para la realización de esta práctica:
//mi primer dibujo
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>

26. void inicializa(void)
{
glClearColor(1.0,0.0,1.0,0.0); //color de fondo
glMatrixMode(GL_PROJECTION); //Modo de proyeccion
glLoadIdentity(); //Establece los parametros de proyeccion
gluOrtho2D(0.0, 2000.0, 0.0, 2000.0); //vista ortogonal
}
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glBegin(GL_TRIANGLES);
glColor3f (0.0, 0.0, 0.0);
//gorro
glVertex2f (440,760);
glVertex2f (600,880);
glVertex2f (760,760);
glEnd();
//cabeza
glColor3f (1.0, 0.0, 0.0);
glBegin(GL_TRIANGLES);
glVertex2f (520,760);
glVertex2f (600,640);
glVertex2f (680,760);
glEnd();

27. //corbata
glColor3f (0.0, 0.0, 0.0);
glBegin(GL_TRIANGLES);
glVertex2f (560,640);
glVertex2f (600,600);
glVertex2f (640,640);
glEnd();
//cuerpazo
glBegin(GL_QUADS);
glVertex2f (480,640);
glVertex2f (480,360);
glVertex2f (720,360);
glVertex2f (720,640);
glEnd();
//brazo izquierdp
glColor3f (1.0 , 1.5 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2f (480,640);
glVertex2f (360,360);
glVertex2f (280,440);
glEnd();
//brazo derecho
glColor3f (1.0, 1.5, 0.0);
glBegin(GL_TRIANGLES);
glVertex2f (720,640);
glVertex2f (920,400);

28. glVertex2f (840,360);
glEnd();
//mano izquierda
glColor3f (1.0, 1.5, 0.0);
glBegin(GL_TRIANGLES);
glVertex2f (240,520);
glVertex2f (280,440);
glVertex2f (240,400);
glEnd();
//mano derecha
glColor3f (1.0, 1.5, 0.0);
glBegin(GL_TRIANGLES);
glVertex2f(960,520);
glVertex2f (960,400);
glVertex2f (920,400);
//pata derecha
glColor3f (0.0, 0.0, 0.0);
glBegin(GL_TRIANGLES);
glVertex2f (640,360);
glVertex2f (800,280);
glVertex2f (640,280);
glEnd();
//abajo pata
glColor3f (1.0, 1.5, 0.0);
glBegin(GL_TRIANGLES);
glVertex2f (800,120);

29. glVertex2f (720,200);
glVertex2f (800,280);
glEnd();
//pata abjao abajo
glColor3f (1.0, 1.5, 0.0);
glBegin(GL_TRIANGLES);
glVertex2f (800,120);
glVertex2f (880,160);
glVertex2f (960,120);
glEnd();
//pata abajo izquierda
glColor3f (1.0, 1.5, 0.0);
glBegin(GL_TRIANGLES);
glVertex2f (400, 40);
glVertex2f (480, 80);
glVertex2f (560, 40);
glEnd();
glColor3f (1.0, 00, 0.0);
glBegin(GL_POLYGON);
glVertex2f (840,120);
glVertex2f (880,120);
glVertex2f (920,80);
glVertex2f (920,40);
glVertex2f (880,0);
glVertex2f (840,0);
glVertex2f (800,40);

30. glVertex2f (800,80);
glEnd();
//trofeo
glColor3f (1.0, 00, 0.5);
glBegin(GL_POLYGON);
glVertex2f (920,600);
glVertex2f (1000,600);
glVertex2f (960,560);
glVertex2f (1040,440);
glVertex2f (1040,360);
glVertex2f (1000,400);
glVertex2f (920,560);
glEnd();
glColor3f (1.0, 1.5, 0.0);
glBegin(GL_TRIANGLES);
glVertex2f (1000, 600);
glVertex2f (1120, 600);
glColor3f (1.0, 0.0, 0.0);
glVertex2f (1060, 360);
glEnd();
glColor3f (1.0, 00, 0.5);
glBegin(GL_POLYGON);
glVertex2f (1080, 360);
glVertex2f (1080, 440);
glVertex2f (1160, 560);
glVertex2f (1160, 560);

31. glVertex2f (1120, 600);
glVertex2f (1200, 600);
glVertex2f (1200, 560);
glEnd();
glColor3f (1.0, 1.5, 0.0);
glBegin(GL_TRIANGLES);
glVertex2f (560,360);
glVertex2f (560,40);
glVertex2f (480,280);
glEnd();
glColor3f (1.0, 00, 0.5);
glBegin(GL_TRIANGLES);
glVertex2f (1000, 320);
glVertex2f (1060, 360);
glVertex2f (1120, 320);
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 primera ventana"); //nombre de la ventana

32. inicializa();
glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización
glutMainLoop(); //muestra todo y espera
return 0; //retorna un valor de cero
}
El siguiente paso después de la realización del código es compilarlo para verificar
que el código ha sido escrito correctamente y funciona de la forma adecuada
como se muestra a continuación:

33. CASITA
En esta práctica se ocuparan los cuadrados, triángulos, polígonos, líneas y si es
necesario círculos y degradados, para crear una casa.
Código:
#include <GL/glut.h>
#include <GL/gl.h>
#include <math.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
gluOrtho2D(0.0, 2000.0, 0.0, 2000.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();
}

34. 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);
glColor3f(1.0,0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(0,680);
glVertex2f(0,640);
glVertex2f(1640,640);
glVertex2f(1640,680);
glEnd();
//techo
glColor3f(1.0 , 00, 0.0);
glBegin(GL_POLYGON);
glVertex2f(920,1200);
glVertex2f(840,1280);

35. glVertex2f(400,1280);
glVertex2f(320,1200);
glEnd();
//cuerpo de casa
glColor3f(0.0 , 0.0, 0.0);
glBegin(GL_QUADS);
glVertex2f(360,1200);
glVertex2f(880,1200);
glVertex2f(880,600);
glVertex2f(360,600);
glEnd();
//ventana izquierda
glColor3f(1.0 , 1.0, 1.0);
glBegin(GL_QUADS);
glVertex2f(360,1120);
glVertex2f(360,1000);
glVertex2f(480,1000);
glVertex2f(480,1120);
glEnd();
//ventana derecha
glColor3f(1.0 , 1.0, 1.0);
glBegin(GL_QUADS);
glVertex2f(760,1120);
glVertex2f(760,1000);
glVertex2f(880,1000);
glVertex2f(880,1120);

36. glEnd();
//linea cuerpo izquierda
glColor3f(0.0 , 1.0, 0.0);
glBegin(GL_QUADS);
glVertex2f(480,1160);
glVertex2f(480,600);
glVertex2f(520,600);
glVertex2f(520,1160);
glEnd();
glColor3f(0.0 , 1.0, 0.0);
glBegin(GL_QUADS);
glVertex2f(720,1160);
glVertex2f(720,600);
glVertex2f(760,600);
glVertex2f(760,1160);
glEnd();
//triangulo ttecho
glColor3f(1.0 , 1.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2f(480,1160);
glVertex2f(600,1240);
glVertex2f(760,1160);
glEnd();
//cuadro abajo de triangulo techo
glColor3f(1.0, 0.0,0.0);
glBegin(GL_QUADS);

37. glVertex2f(520,1160);
glVertex2f(520,1000);
glColor3f(0.0 , 0.0,1.0);
glVertex2f(720,1000);
glColor3f(0.0 , 0.0,0.0);
glVertex2f(720,1160);
glEnd();
glColor3f(0.0, 1.0,0.0);
glBegin(GL_QUADS);
glVertex2f(600,1160);
glVertex2f(600,1000);
glVertex2f(640,1000);
glVertex2f(640,1160);
glEnd();
//vcentanales
glColor3f(1.0,1.0,0.0);
glBegin(GL_QUADS);
glVertex2f(520,1000);
glVertex2f(520,920);
glVertex2f(560,920);
glVertex2f(560,1000);
glEnd();
glColor3f(1.0,1.0,1.0);
glBegin(GL_QUADS);
glVertex2f(560,1000);
glVertex2f(560,920);

38. glVertex2f(600,920);
glVertex2f(600,1000);
glEnd();
glColor3f(1.0,1.0,0.0);
glBegin(GL_QUADS);
glVertex2f(600,1000);
glVertex2f(600,920);
glVertex2f(640,920);
glVertex2f(640,1000);
glEnd();
glColor3f(1.0,1.0,1.0);
glBegin(GL_QUADS);
glVertex2f(640,1000);
glVertex2f(640,920);
glVertex2f(680,920);
glVertex2f(680,1000);
glEnd();
glColor3f(1.0,1.0,0.0);
glBegin(GL_QUADS);
glVertex2f(680,1000);
glVertex2f(680,920);
glVertex2f(720,920);
glVertex2f(720,1000);
glEnd();
//linea horizontal cuerpo casa
glColor3f(0.0,1.0,0.0);

39. glBegin(GL_QUADS);
glVertex2f(360,920);
glVertex2f(360,880);
glVertex2f(880,880);
glVertex2f(880,920);
glEnd();
//ventana izquierda abajao
glColor3f(1.0,1.0,1.0);
glBegin(GL_QUADS);
glVertex2f(360,800);
glVertex2f(360,680);
glVertex2f(480,680);
glVertex2f(480,800);
glEnd();
//ventana derecha abajo
glColor3f(1.0,1.0,1.0);
glBegin(GL_QUADS);
glVertex2f(760,800);
glVertex2f(760,680);
glVertex2f(880,680);
glVertex2f(880,800);
glEnd();
//puerta
glColor3f(1.0,0.0,1.0);
glBegin(GL_QUADS);
glVertex2f(520,840);

40. glVertex2f(520,600);
glVertex2f(720,600);
glVertex2f(720,840);
glEnd();
//dentro de puerta
glColor3f(1.0,0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(560,800);
glVertex2f(560,640);
glVertex2f(640,640);
glVertex2f(640,800);
glEnd();
//manija
glColor3f(0.0,0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(640,720);
glVertex2f(640,680);
glVertex2f(680,680);
glVertex2f(680,720);
glEnd();
//cochera
glColor3f(1.0 , 00, 0.0);
glBegin(GL_POLYGON);
glVertex2f(360,880);
glVertex2f(80,880);
glVertex2f(40,800);

41. glVertex2f(360,800);
glEnd();
glColor3f(1.0 , 00, 0.0);
glBegin(GL_QUADS);
glVertex2f(0,320);
glVertex2f(0,280);
glColor3f(1.0 , 1.0,0.0);
glVertex2f(1680,280);
glColor3f(1.0 , 1.0,0.0);
glVertex2f(1680,320);
glEnd();
glColor3f(1.0 , 00, 0.0);
glBegin(GL_QUADS);
glVertex2f(520,320);
glVertex2f(520,600);
glColor3f(1.0 , 1.0,0.0);
glVertex2f(720,600);
glColor3f(1.0 , 1.0,0.0);
glVertex2f(720,320);
glEnd();//cuerpo cochera
glColor3f(1.0,0.0,1.0);
glBegin(GL_POLYGON);
glVertex2f(80,800);
glVertex2f(80,600);
glVertex2f(360,600);
glVertex2f(360,800);

42. glEnd();
glColor3f(1.0 , 1.0,0.0);
glBegin(GL_QUADS);
glVertex2f(0,280);
glVertex2f(0,240);
glVertex2f(1680,240);
glVertex2f(1680,280);
glEnd();
//carretera
glColor3f(0.0 , 0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(0,240);
glVertex2f(0,0);
glVertex2f(1680,0);
glVertex2f(1680,240);
glEnd();
//barras de carretyera
glColor3f(1.0 , 1.0,1.0);
glBegin(GL_QUADS);
glVertex2f(40,160);
glVertex2f(40,120);
glVertex2f(440,120);
glVertex2f(440,160);
glEnd();
glColor3f(1.0 , 1.0,1.0);

43. glBegin(GL_QUADS);
glVertex2f(520,160);
glVertex2f(520,120);
glVertex2f(920,120);
glVertex2f(920,160);
glEnd();
glColor3f(1.0 , 1.0,1.0);
glBegin(GL_QUADS);
glVertex2f(1080,160);
glVertex2f(1080,120);
glVertex2f(1560,120);
glVertex2f(1560,160);
glEnd();
//pasto
glColor3f(0.0 , 1.0,0.0);
glBegin(GL_QUADS);
glVertex2f(0,600);
glVertex2f(0,320);
glVertex2f(520,320);
glVertex2f(520,600);
glEnd();
glColor3f(0.0 , 1.0,0.0);
glBegin(GL_QUADS);
glVertex2f(720,600);
glVertex2f(720,320);
glVertex2f(1680,320);

44. glVertex2f(1680,600);
glEnd();
//carro izquierda
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);
glVertex2f(400,440);
glVertex2f(240,440);
glVertex2f(160,360);
glVertex2f(480,360);
glEnd();
glColor3f(1.0 , 0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(160,360);
glVertex2f(160,280);
glVertex2f(600,280);
glVertex2f(600,360);
glEnd();
//ventanas carro izquierdo
glColor3f(0.0 , 0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(200,400);
glVertex2f(200,320);
glVertex2f(280,320);
glVertex2f(280,400);
glEnd();
glColor3f(0.0 , 0.0,0.0);

45. glBegin(GL_QUADS);
glVertex2f(320,400);
glVertex2f(320,320);
glVertex2f(400,320);
glVertex2f(400,400);
glEnd();
//trailer
glColor3f(1.0,0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(920,360);
glVertex2f(920,240);
glVertex2f(1160,240);
glVertex2f(1160,360);
glEnd();
glColor3f(1.0 , 1.0 , 1.0);
glBegin(GL_TRIANGLES);
glVertex2f(960,360);
glVertex2f(1000,440);
glVertex2f(1000,360);
glEnd();
glColor3f(1.0,0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(1000,440);
glVertex2f(1000,360);
glVertex2f(1160,360);

46. glVertex2f(1160,440);
glEnd();
//ventana trailer cuadrada
glColor3f(1.0,1.0,1.0);
glBegin(GL_QUADS);
glVertex2f(1040,440);
glVertex2f(1040,360);
glVertex2f(1120,360);
glVertex2f(1120,440);
glEnd();
//base de treaileer
glColor3f(1.0,0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(880,240);
glVertex2f(880,160);
glVertex2f(1440,160);
glVertex2f(1440,240);
glEnd();
//caja de trailer
glColor3f(1.0,0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(1200,520);
glVertex2f(1200,240);
glVertex2f(1440,240);
glVertex2f(1440,520);

47. glEnd();
//cosa que le sale al trailer
glColor3f(1.0,0.0,1.0);
glBegin(GL_QUADS);
glVertex2f(840,320);
glVertex2f(840,160);
glVertex2f(880,160);
glVertex2f(880,320);
glEnd();
//a estoes parte de las ventanas de la casa
glColor3f(1.0,0.0,1.0);
glBegin(GL_QUADS);
glVertex2f(360,1080);
glVertex2f(360,1040);
glVertex2f(480,1040);
glVertex2f(480,1080);
glEnd();
glColor3f(1.0,0.0,1.0);
glBegin(GL_QUADS);
glVertex2f(360,760);
glVertex2f(360,720);
glVertex2f(480,720);
glVertex2f(480,760);
glEnd();
glColor3f(1.0,0.0,1.0);
glBegin(GL_QUADS);

48. glVertex2f(760,1080);
glVertex2f(760,1040);
glVertex2f(880,1040);
glVertex2f(880,1080);
glEnd();
glColor3f(1.0,0.0,1.0);
glBegin(GL_QUADS);
glVertex2f(760,760);
glVertex2f(760,720);
glVertex2f(880,720);
glVertex2f(880,760);
glEnd();
//barandal
glColor3f(1.0,0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(0,720);
glVertex2f(0,600);
glVertex2f(40,600);
glVertex2f(40,720);
glEnd();
glColor3f(1.0,0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(920,720);
glVertex2f(920,600);
glVertex2f(960,600);
glVertex2f(960,720);

49. glEnd();
glColor3f(1.0,0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(1000,720);
glVertex2f(1000,600);
glVertex2f(1040,600);
glVertex2f(1040,720);
glEnd();
glColor3f(0.6,0.4,0.2);
glBegin(GL_QUADS);
glVertex2f(1080,720);
glVertex2f(1080,600);
glVertex2f(1240,600);
glVertex2f(1240,720);
glEnd();
//tronco
glColor3f(0.6,0.4,0.2);
glBegin(GL_QUADS);
glVertex2f(1120,720);
glVertex2f(1120,600);
glVertex2f(1160,600);
glVertex2f(1160,720);
glEnd();
//ramas
glBegin(GL_LINES);
//llantas

50. glColor3f(0.6,0.4,0.2);
circulo(240,240,50);
circulo(240,240,25);
glEnd();
glColor3f(0.6,0.4,0.2);
circulo(520,240,50);
circulo(520,240,25);
glEnd();
glColor3f(0.6,0.4,0.2);
circulo(1000,80,100);
circulo(1000,80,50);
glEnd();
glColor3f(0.6,0.4,0.2);
circulo(1360,80,100);
circulo(1360,80,50);
glColor3f(0.0,0.6,0.2);
glBegin(GL_QUADS);
glVertex2f(1000,760);
glVertex2f(1000,720);
glVertex2f(1400,720);
glVertex2f(1400,760);
glEnd();
glColor3f(0.0,0.6,0.2);
glBegin(GL_QUADS);

51. glVertex2f(1040,840);
glVertex2f(1040,800);
glVertex2f(1320,800);
glVertex2f(1320,840);
glEnd();
glColor3f(0.0,0.6,0.2);
glBegin(GL_QUADS);
glVertex2f(1080,920);
glVertex2f(1080,880);
glVertex2f(1280,880);
glVertex2f(1280,920);
glEnd();
glColor3f(0.0,0.6,0.2);
glBegin(GL_QUADS);
glVertex2f(1120,1000);
glVertex2f(1120,960);
glVertex2f(1240,960);
glVertex2f(1240,1000);
glEnd();
glColor3f(0.0,0.6,0.2);
glBegin(GL_QUADS);
glVertex2f(1160,1080);
glVertex2f(1150,1040);
glVertex2f(1200,1040);
glVertex2f(1200,1080);
glEnd();

52. //barandal, despues del tronco
glColor3f(1.0,0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(1280,720);
glVertex2f(1280,600);
glVertex2f(1320,600);
glVertex2f(1320,720);
glEnd();
glColor3f(1.0,0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(1360,720);
glVertex2f(1360,600);
glVertex2f(1400,600);
glVertex2f(1400,720);
glEnd();
glColor3f(1.0,0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(1440,720);
glVertex2f(1440,600);
glVertex2f(1480,600);
glVertex2f(1480,720);
glEnd();
glColor3f(1.0,0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(1520,720);
glVertex2f(1520,600);

53. glVertex2f(1560,600);
glVertex2f(1560,720);
glEnd();
glColor3f(1.0,0.0,0.0);
glBegin(GL_QUADS);
glVertex2f(1600,720);
glVertex2f(1600,600);
glVertex2f(1640,600);
glVertex2f(1640,720);
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("tablero"); //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

54. }
OSO
Primera práctica en la cual oficialmente se ocuparan los círculos para crear con
solo círculos un oso.
Código:
#include <GL/glut.h>
#include <GL/gl.h>
#include <math.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

55. gluOrtho2D(0.0, 2000.0, 0.0, 2000.0); //vista ortogonal
}
void circuloc(int x, int y, int t, int radio)
{
int angulo=0;
glPointSize(t);
glBegin(GL_POINTS);
//glColor3f (1.0, 0.0, 1.0);
glVertex2f(x,y);
//glColor3f(0,0.0,0.0);
for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) * radio, y +
cos(angulo) * radio);}
glEnd();
}
void circulo(int x, int y, int radio)
{
int angulo=0;
glBegin(GL_TRIANGLE_FAN);
// glColor3f (1.0, 0.0, 1.0);
glVertex2f(x,y);
for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) * radio, y +
cos(angulo) * radio);}
glEnd();
}
void dibuja(void) //funcion dibuja

56. {
//cara y orejas
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.6 , 0.4, 0.2);
circulo(400,1000,120);
circulo(800,1000,120);
circulo(600,840,200);
glEnd();
//cuerpo
glColor3f(0.6 , 0.4, 0.2);
glBegin(GL_QUADS);
glVertex2f(520,640);
glVertex2f(520,360);
glVertex2f(680,360);
glVertex2f(680,640);
glEnd();
//brazos
glColor3f(0.6 , 0.4, 0.2);
glBegin(GL_QUADS);
glVertex2f(360,640);
glVertex2f(360,560);
glVertex2f(520,560);
glVertex2f(520,640);
glEnd();
glColor3f(0.6 , 0.4, 0.2);
glBegin(GL_QUADS);

57. glVertex2f(680,640);
glVertex2f(680,560);
glVertex2f(840,560);
glVertex2f(840,640);
glEnd();
//piernas
glColor3f(0.6 , 0.4, 0.2);
glBegin(GL_QUADS);
glVertex2f(440,360);
glVertex2f(440,280);
glVertex2f(520,280);
glVertex2f(520,360);
glEnd();
glColor3f(0.6 , 0.4, 0.2);
glBegin(GL_QUADS);
glVertex2f(680,360);
glVertex2f(680,280);
glVertex2f(760,280);
glVertex2f(760,360);
glEnd();
//patas
glColor3f(0.6 , 0.4, 0.2);
circulo(360,320,120);
circulo(840,320,120);
glEnd();
//manos

58. glColor3f(0.6 , 0.4, 0.2);
circulo(320,600,120);
circulo(880,600,120);
glEnd();
//ojos
glColor3f(0.0 , 0.0, 0.0);
circulo(520,920,40);
circulo(680,920,40);
glEnd();
//ocico
glColor3f(1.0 , 1.0, 1.0);
circulo(600,800,80);
glEnd();
glColor3f(0.0 , 0.0, 0.0);
circulo(600,800,40);
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

59. glutInitWindowPosition(0,0); //posicion inicial de la ventana
glutCreateWindow("tablero"); //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
}

60. CUBO CON CUBITOS
Se realizara un cubo hecho de cubos más pequeños y delineados, hasta crear una
práctica parecida a la de cubo con líneas, sustituyendo estas por cubos.
Código:
#include <GL/glut.h>
#include <GL/gl.h>
void inicializa(void)
{
glClearColor(1.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, 800.0, 0.0, 800.0); //vista ortogonal
}
void cubo (int x, int y,int t,int l){
double a=.8,b=.6;
glColor3f(1.0 , 1.0 , 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));

61. glColor3f(1.0 , 0.0 , 0.0);
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(l);
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);

62. 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();
}
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(1.0 , 0.0 , 0.0);
for(int k=0;k<=7;k++){
cubo(240-20*k*.8,200-20*k*.6,20,5);
}
for(int j=0;j<=12;j++){
cubo(260+20*j,220,20,5);
}
for(int i=0;i<=9;i++){
cubo(260,240+20*i,20,5);

63. }
for(int k=0;k<=9;k++){
cubo(260-20*k*.8,420-20*k*.6,20,5);
}
for(int j=0;j<=10;j++){
cubo(280+20*j,420,20,5);
}
for(int k=0;k<=9;k++){
cubo(500-20*k*.8,220-20*k*.6,20,5);
}
for(int i=0;i<=8;i++){
cubo(500,240+20*i,20,5);
}
for(int k=0;k<=10;k++){
cubo(500-20*k*.8,420-20*k*.6,20,5);
}
for(int i=0;i<=10;i++){
cubo(100,100+20*i,20,5);
}
for(int j=0;j<=10;j++){
cubo(120+20*j,100,20,5);
cubo(120+20*j,300,20,5);

64. }
for(int i=0;i<=10;i++){
cubo(340,100+20*i,20,5);
}
glFlush(); //forza dibujo
}
int main (int argc, char** argv) //metodo main
{
glutInit(&argc, argv); //incializa GLUT
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de
visualización
glutInitWindowSize(500,500); //tamaño de la ventana
glutInitWindowPosition(100,100); //posicion inicial de la ventana
glutCreateWindow("Ventana"); //nombre de la ventana
inicializa();
glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización
glutMainLoop(); //muestra todo y espera
return 0; //retorna un valor de cero
}

65. MUÑECO CON FORMAS
En esta práctica realizaremos un muñeco con los conocimientos vistos antes, para
ello utilizaremos triángulos, polígonos, círculos, rectángulos, cuadrados y líneas.
Codigo:
//mi primer ventana
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <math.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

66. gluOrtho2D(0.0, 2000.0, 0.0, 2000.0); //vista ortogonal
}
void circuloc(int x, int y, int t, int radio)
{
int angulo=0;
glPointSize(t);
glBegin(GL_POINTS);
//glColor3f (1.0, 0.0, 1.0);
glVertex2f(x,y);
//glColor3f(0,0.0,0.0);
for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) *
radio, y + cos(angulo) * radio);}
glEnd();
}
void circulo(int x, int y, int radio)
{
int angulo=0;
glBegin(GL_TRIANGLE_FAN);
// glColor3f (1.0, 0.0, 1.0);
glVertex2f(x,y);
for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) *
radio, y + cos(angulo) * radio);}
glEnd();
}

67. void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0 , 00, 0.0);
// cabeza
glColor3f(0.8,0.7,0.6); //borra pantalla
circulo(1000,1000,200);
// ojos
glColor3f(0.0,0.0,0.0);
circulo(950,1050,10);
circulo(1100,1050,10);
glEnd();
//orejas
glColor3f(0.8,0.7,0.6);
circulo(800,1000,50);
circulo(1200,1000,50);
glEnd();
//cuello
glBegin(GL_POLYGON);
glColor3f(0.8,0.7,0.6);
glVertex2f(1050,750);
glVertex2f(1050,820);
glVertex2f(950,820);
glVertex2f(950,750);

68. glVertex2f(1000,650);
// Playera
glBegin(GL_POLYGON);
glColor3f(1.0,0.0,0.0);
glVertex2f(1200,350);
glVertex2f(1200,550);
glVertex2f(1250,450);
glVertex2f(1350,450);
glVertex2f(1200,750);
glVertex2f(1050,750);
glVertex2f(1000,650);
glVertex2f(950,750);
glVertex2f(800,750);
glVertex2f(705,450);
glVertex2f(800,450);
glVertex2f(850,550);
glVertex2f(850,350);
glEnd();
//CUERPO
glBegin(GL_TRIANGLES);
glColor3f(1.0,0.0,0.0);
glVertex2f(1200,350);
glVertex2f(1000,650);
glVertex2f(850,350);
glEnd();
glBegin(GL_QUADS);

69. glColor3f(0.3,0.17,0.16);
glVertex2f(950,650);
glVertex2f(1050,650);
glVertex2f(1050,550);
glVertex2f(950,550);
glVertex2f(950,500);
glVertex2f(1050,500);
glVertex2f(1050,400);
glVertex2f(950,400);
glVertex2f(1200,350);
glVertex2f(850,350);
glVertex2f(850,300);
glVertex2f(1200,300);
glColor3f(0.0,0.0,0.0);
glVertex2f(950,350);
glVertex2f(1050,350);
glVertex2f(1050,300);
glVertex2f(950,300);
// BRAZOS
glColor3f(0.8,0.5,0.4);
glVertex2f(750,450);
glVertex2f(780,450);

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

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

72. glVertex2f(1270,320);
glVertex2f(1280,360);
glVertex2f(1280,360);
glVertex2f(1290,320);
glVertex2f(1290,320);
glVertex2f(1300,360);
glVertex2f(1300,360);
glVertex2f(1310,320);
glVertex2f(1310,320);
glVertex2f(1320,360);
glVertex2f(1320,360);
glVertex2f(1340,350);
glVertex2f(1340,350);
glVertex2f(1305,380);
// NARIZ
glColor3f(0.0,0.0,0.0);

73. glVertex2f(1020,1020);
glVertex2f(1000,1000);
glVertex2f(1000,1000);
glVertex2f(1040,1000);
// BOCA
glVertex2f(975,900);
glVertex2f(975,880);
glVertex2f(975,880);
glVertex2f(1050,880);
glVertex2f(1050,880);
glVertex2f(1050,900);
glEnd();
// CABELLO
glBegin(GL_TRIANGLES);
glColor3f(0.0 , 0.0 , 0.0);
glVertex2f(950,1190);
glVertex2f(1100,1250);
glVertex2f(1050,1190);
glEnd();
// PANTALON

74. glBegin(GL_POLYGON);
glColor3f(0.1,0.4,0.7);
glVertex2f(850,300);
glVertex2f(750,100);
glVertex2f(900,50);
glVertex2f(1020,250);
glVertex2f(1020,300);
glEnd();
glBegin(GL_POLYGON);
glColor3f(0.1,0.4,0.7);
glVertex2f(1020,300);
glVertex2f(1020,250);
glVertex2f(1100,50);
glVertex2f(1250,100);
glVertex2f(1200,300);
glEnd();
glBegin(GL_TRIANGLES);
glColor3f(0.0 , 0.0 , 0.0);
glVertex2f(750,100);
glVertex2f(900,50);
glVertex2f(650,50);
glVertex2f(1100,50);
glVertex2f(1250,100);
glVertex2f(1350,50);

75. glEnd();
glFlush(); //forza dibujo
}
//funcion dibuja
//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(900,900); //tamaño de la ventana
glutInitWindowPosition(0,0); //posicion inicial de la ventana
glutCreateWindow("tablero"); //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
}

76. ANIMACIÓN CÍRCULO
Al hacer un círculo, se le pondrá movimiento, para que cubra su recorrido las
orillas de la pantalla.
Código:
#include <unistd.h>
#include <GL/glut.h>
#include <GL/gl.h>
#include <math.h>
int x=1, y=1,z=1,w=1;
void inicializa(void){
glClearColor(0.0,0.0,1.0,0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, 700.0, 0.0, 700.0);// el ancho y largo de nuestra pantalla
}
void circulo(int x, int y, int radio){

77. int angulo=0;
glBegin(GL_TRIANGLE_FAN); glColor3f (0.5, 0.5, 0.5);
glVertex2f(x,y);
glColor3f(0,0.0,0.0);
for (angulo=0;angulo<=360; angulo+=6){ glVertex2f(x + sin(angulo) * radio, y +
cos(angulo) * radio);}
glEnd();}
void dibuja(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//abajo
if(x>=1 && x<500){circulo(100+1*x,100,40);x++;}
// derecha para arriba
if (x==500 && y>=1 && y<500 ) {circulo(600,100+1*y,40);y++;}
//arriba para izquierda
if (x==500 && y==500 && z>=1 && z<500) {circulo (600-z,600,40);z++;}
//izquerda hacia abajo
if (x==500 && y==500 && z==500 && w>=1 && w<500){circulo (100,600-w,40);w++;}
if(w==500){ x=1;y=1; z=1; w=1;}
glFlush();
glutSwapBuffers();
}
int main (int argc, char** argv)
{

78. 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;
}

79. ANIMACIÓN SISTEMA SOLAR.
Movimiento circular, será lo que tendrán nuestros planetas (círculos). Se realizaran
las “orbitas” y sobre su circunferencia de estas, giraran.
Código:
#include <unistd.h>
#include <GL/glut.h>
#include <GL/gl.h>
#include <math.h>
int rad=100;
double ang=0,a=0,b=0,c=0, d=0, e=0, f=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);
glVertex2f(x,y);
for (angulo=0;angulo<=360; angulo++){ glVertex2f(x + sin(angulo) * radio, y +
cos(angulo) * radio);}
glEnd();

80. }
void circuloc(int x, int y, int t, int radio)
{
int angulo=0;
glPointSize(t);
glBegin(GL_POINTS);
glVertex2f(x,y);
for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) * radio, y +
cos(angulo) * radio);}
glEnd();
}
void dibuja(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//esto
glColor3f(1.0,0.0,0.0);
circulo( 500+ sin(ang) * 0,500 + cos(ang) * 0,50); //funcion circulo
glColor3f(1.0,1.0,1.0);
circuloc(500,500,1,100);
circuloc(500,500,1,150);
circuloc(500,500,1,200);
circuloc(500,500,1,250);
circuloc(500,500,1,300);
circuloc(500,500,1,350);
circuloc(500,500,1,400);

81. circuloc(500,500,1,450);
glColor3f(0.8,0.4,0.1);
circulo( 500+ sin(a) * 100,500 + cos(a) * 100,5);
glColor3f(0.6,0.3,0.1);
circulo( 500+ sin(b) * 150,500 - cos(b) * 150,7);
glColor3f(0.1,0.7,0.8);
circulo( 500+ sin(c) * 200,500 + cos(c) * 200,10);
glColor3f(0.8,0.07,0.2);
circulo( 500+ sin(d) * 250,500 - cos(d) * 250,10);
glColor3f(0.9,0.6,0.2);
circulo( 500+ sin(e) * 300,500 + cos(e) * 300,18);
glColor3f(0.2,0.9,0.7);
circulo( 500+ sin(f) * 350,500 - cos(f) * 350,14);
glColor3f(0.2,0.7,0.9);
circulo( 500+ sin(ang) * 400,500 + cos(ang) * 400,12);
glColor3f(0.0,0.1,0.9);
circulo( 500+ sin(a) * 450,500 - cos(a) * 450,12);
a+=0.01; //a=a+0.1;
b+=0.02;
c+=0.03;
d+=0.04;
e+=0.05;
f+=0.06;
ang=ang+0.01; //velocidad entre mas grande mas rapido y entre menos mas lento

82. 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;
}

83. MOVIMIENTO EN OCHO.
Con círculos, se simulara un ocho, es decir pegar los círculos, para que dentro de
estos, se mueva una pequeña bolita, que hará un movimiento en forma de ocho.
Código:
#include <unistd.h>
#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(0.0,0.0,0.0,0.0);
glMatrixMode(GL_PROJECTION);

84. glLoadIdentity();
gluOrtho2D(0.0, 700.0, 0.0, 700.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(1.0, 1.0, 1.0);
circulo(300, 300, 70);
circulo(300,180,70);
glColor3f(0.0,0.0,0.0);
circulo(300,300,50);
circulo(300,180,50);
glColor3f(1.0,0.0,0.0);
if(a>=6.15 && a<=12.41){
circulo(300+ sin (a)*60,300- cos(a)*60,10);
a=a+0.01;
}
else{
circulo(300 + sin (b) *60,180-cos(b)*-60,10);

85. b=b + 0.14;
if(b>12.4){a=6.15;b=6.15;}
for(int j=0; j<=10000000; j++) {}
}
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;
}

86. SEMAFORO
En esta práctica realizaremos un semáforo en el cual los colores se cambien
según la ubicación de dicho semáforo, para ello utilizaremos, rectángulos y
círculos así como se muestra a continuación:
Código:
#include <unistd.h>
#include <GL/glut.h>
#include <GL/gl.h>
#include <math.h>
int rad=100;
double ang=0,a=0,b=0,c=0,d=0,e=0,f=0,g=0;
void inicializa(void)
{
glClearColor(0.2,0.6,0.8,1.0);
glMatrixMode(GL_PROJECTION);

87. glLoadIdentity();
gluOrtho2D(0.0, 500.0, 0.0, 500.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);
glVertex2f(x,y);
for (angulo=0;angulo<=360; angulo++){ glVertex2f(x + sin(angulo) *
radio, y + cos(angulo) * radio);}
glEnd();
}
void dibuja(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//esto

88. glBegin(GL_QUADS);//Cuadros fondo semaforo
glColor3f(0.2 , 0.6 , 0.);
glVertex2i(170,437);
glVertex2i(320,437);
glVertex2i(320,182);
glVertex2i(170,182);
glVertex2i(229,183);
glVertex2i(278,183);
glVertex2i(278,3);
glVertex2i(229,3);
glEnd();
glColor3f(0.0,0.0,0.0);//Luces Roja
circulo(247,226,34);
glColor3f(0.0,0.0,0.0);//Luces Amarrilla
circulo(247,302,34);
glColor3f(0.0,0.0,0.0);//Luces Verde
circulo(247,381,34);
a=a+1; //velocidad entre mas grande mas rapido y entre menos mas lento

89. for(int j=1;j<=10000000;j++){}//pausa
if(a>1 && a<20){
glColor3f(1.0,0.0,0.0);//Luces Roja
circulo(247,381,34);
}// se repite idefinidamente
if(a>20 && a<40){
glColor3f(0.0,1.0,0.0);//Luces Roja
circulo(247,226,34);
}// se repite idefinidamente
if(a>40 && a<50){
glColor3f(1.0,1.0,0.0);//Luces Roja
circulo(247,302,34);
}// se repite idefinidamente
if(a>55 && a<50){
glColor3f(1.0,1.0,0.0);//Luces Roja
circulo(247,302,34);
}// se repite idefinidamente
if(a>60 && a<55){
glColor3f(1.0,1.0,0.0);//Luces Roja
circulo(247,302,34);
}// se repite idefinidamente
if(a>60){a=0;}
glFlush(); //forzar dibujado

90. 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(10,10);
glutCreateWindow("Ventana");
inicializa();
glutDisplayFunc(dibuja);
glutIdleFunc(dibuja);//esto es lo que cambia
glutMainLoop();
return 0;
}

91. CONCLUSION
Nos dimos cuenta que utilizar este programa no es muy difícil ya que
lo único que se tiene que hacer es colocar bien las coordenadas y las
primitivas para que los archivos salgan de la manera que uno quiere
por que si no se hace de la forma anterior no saldrán los trabajos
como se desean, lo único que se nos dificulto fue la realización de
algunas animaciones ya que se necesitan primitivas espaciales para
que ocurra cierta animación.