1. Tablero de ajedrez
Con puntos se creara un tablero de ajedrez. Recordar que el
tablero consta de de 8 cuadros por ocho cuadros.
Código:
#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(0.0, 1000.0, 0.0, 1000.0); //vista ortogonal
}
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(1.0 , 1.0 , 1.0);
glPointSize(50);
glBegin(GL_POINTS);
glVertex2i(100,100);
glVertex2i(300,100);
glVertex2i(500,100);
glVertex2i(700,100);
glVertex2i(200,200);
glVertex2i(400,200);

2. glVertex2i(600,200);
glVertex2i(800,200);
glVertex2i(100,300);
glVertex2i(300,300);
glVertex2i(500,300);
glVertex2i(700,300);
glVertex2i(200,400);
glVertex2i(400,400);
glVertex2i(600,400);
glVertex2i(800,400);
glVertex2i(100,500);
glVertex2i(300,500);
glVertex2i(500,500);
glVertex2i(700,500);
glVertex2i(200,600);
glVertex2i(400,600);
glVertex2i(600,600);
glVertex2i(800,600);
glVertex2i(100,700);
glVertex2i(300,700);
glVertex2i(500,700);
glVertex2i(700,700);
glVertex2i(200,800);
glVertex2i(400,800);
glVertex2i(600,800);
glVertex2i(800,800);
glColor3f(0.0 , 0.0 , 0.0);
glColor3f(0.0 , 0.0 , 0.0);

3. glPointSize(50);
glVertex2i(200,100);
glVertex2i(400,100);
glVertex2i(600,100);
glVertex2i(800,100);
glVertex2i(100,200);
glVertex2i(300,200);
glVertex2i(500,200);
glVertex2i(700,200);
glVertex2i(200,300);
glVertex2i(400,300);
glVertex2i(600,300);
glVertex2i(800,300);
glVertex2i(100,400);
glVertex2i(300,400);
glVertex2i(500,400);
glVertex2i(700,400);
glVertex2i(200,500);
glVertex2i(400,500);
glVertex2i(600,500);
glVertex2i(800,500);
glVertex2i(100,600);
glVertex2i(300,600);
glVertex2i(500,600);
glVertex2i(700,600);
glVertex2i(200,700);
glVertex2i(400,700);
glVertex2i(600,700);
glVertex2i(800,700);

4. glVertex2i(100,800);
glVertex2i(300,800);
glVertex2i(500,800);
glVertex2i(700,800);
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
}

6. Estrella
Con solo utilizar líneas, se realizara una estrella con 5 lineas,
cruzadas.
Código:
//mi primer ventana
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
void inicializa(void)
{
glClearColor(0.0,0.0,0.0,0.0); //color de fondo
glMatrixMode(GL_PROJECTION); //Modo de proyeccion
glLoadIdentity(); //Establece los parametros de proyeccion
gluOrtho2D(0.0, 1000.0, 0.0, 1000.0); //vista ortogonal
}
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glLineWidth(2);
glBegin(GL_LINES);
glVertex2i(150,150);
glVertex2i(250,350);
glVertex2i(250,350);
glVertex2i(350,150);

7. glVertex2i(350,150);
glVertex2i(100,250);
glVertex2i(100,250);
glVertex2i(400,300);
glVertex2i(400,300);
glVertex2i(150,150);
glEnd();
glFlush(); //forza dibujo
}
int main (int argc, char** argv) //metodo main
{
glutInit(&argc, argv); //incializa GLUT
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización
glutInitWindowSize(500,500); //tamaño de la ventana
glutInitWindowPosition(0,0); //posicion inicial de la ventana
glutCreateWindow("mi primera ventana"); //nombre de la ventana
inicializa();
glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización
glutMainLoop(); //muestra todo y espera
return 0; //retorna un valor de cero
}

9. Cubo con líneas
De igual manera que otras prácticas realizadas, su utilizaran
líneas, para crear un cubo.
Código:
#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(0.0, 1000.0, 0.0, 1000.0); //vista ortogonal
}
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glLineWidth(2);
glBegin(GL_LINES);
//enfrente
glVertex2i(50,50);
glVertex2i(50,300);
glVertex2i(50,300);
glVertex2i(300,300);
glVertex2i(300,300);
glVertex2i(300,50);

10. glVertex2i(300,50);
glVertex2i(50,50);
//atras
glVertex2i(150,150);
glVertex2i(150,400);
glVertex2i(150,400);
glVertex2i(400,400);
glVertex2i(400,400);
glVertex2i(400,150);
glVertex2i(400,150);
glVertex2i(150,150);
//linea izquierda
glVertex2i(50,300);
glVertex2i(150,400);
//linea derecha
glVertex2i(300,300);
glVertex2i(400,400);
//linea izquierda abajo
glVertex2i(50,50);
glVertex2i(150,150);
//linea derecha abajo
glVertex2i(300,50);
glVertex2i(400,150);
glEnd();
glFlush(); //forza dibujo
}

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

12. Cubo delineado.
En esta práctica se utilizara (GL_QUADS). Se crearan las caras del
cuadro y se delineara con ayuda de los conocimientos de la
práctica anterior.
Código:
#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(0.0, 1000.0, 0.0, 1000.0); //vista ortogonal
}
void dibuja(void) //funcion dibuja
{
glClear(GL_COLOR_BUFFER_BIT); //borra pantalla
glColor3f(1.0 , 0.0 , 0.0);
glPointSize(50);
glBegin(GL_QUADS);
//ATRAS
glColor3f(0.0 , 0.9 , 0.0);
glVertex2d(100,150);
glVertex2d(300,100);
glVertex2d(300,350);

13. glVertex2d(100,350);
//ABAJO
glColor3f(0.0 , 0.0 , 0.0);
glVertex2d(200,100);
glVertex2d(400,100);
glVertex2d(300,150);
glVertex2d(100,150);
//izquierdo
glColor3f(0.0 , 0.0 , 0.0);
glVertex2d(100,150);
glVertex2d(200,100);
glVertex2d(200,300);
glVertex2d(100,350);
//derecho
glColor3f(1.1 , 1.1 , 1.1);
glVertex2d(300,150);
glVertex2d(400,100);
glVertex2d(400,300);
glVertex2d(300,350);
//arriba
glColor3f(1.2 , 0.0 , 0.0);
glVertex2d(200,300);
glVertex2d(400,300);
glVertex2d(300,350);

14. glVertex2d(100,350);
//enfrente
glColor3f(1.5 , 1.5 , 0.0);
glVertex2d(200,100);
glVertex2d(400,100);
glVertex2d(400,300);
glVertex2d(200,300);
glEnd();
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_LINES);
glLineWidth(3);
glVertex2i(100,150);
glVertex2i(200,100);
glVertex2i(200,300);
glVertex2i(100,350);
glVertex2i(200,100);
glVertex2i(400,100);
glVertex2i(400,300);
glVertex2i(200,300);
glEnd();
glColor3f(0.0 , 0.0 , 0.0);
glBegin(GL_LINES);
glLineWidth(3);
glVertex2i(200,300);
glVertex2i(400,300);
glVertex2i(300,350);
glVertex2i(100,350);

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

16. Muñeco con triángulos
En esta práctica, se ocuparan los triángulos y los polígonos.
Triángulos para crear el cuerpo, polígonos para crear la copa.
Código:
#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(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

17. glColor3f(1.0 , 0.0 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2f(520,760);
glVertex2f(600,640);
glVertex2f(680,760);
glEnd();
//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.1 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2f(480,640);
glVertex2f(360,360);
glVertex2f(280,440);
glEnd();
//brazo derecho
glColor3f(1.0 , 1.1 , 0.0);

18. glBegin(GL_TRIANGLES);
glVertex2f(720,640);
glVertex2f(920,400);
glVertex2f(840,360);
glEnd();
//mano izquierda
glColor3f(1.0 , 1.1 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2f(240,520);
glVertex2f(280,440);
glVertex2f(240,400);
glEnd();
//mano derecha
glColor3f(1.0 , 1.1 , 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.1 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2f(800,120);

19. glVertex2f(720,200);
glVertex2f(800,280);
glEnd();
//pata abjao abajo
glColor3f(1.0 , 1.1 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2f(800,120);
glVertex2f(880,160);
glVertex2f(960,120);
glEnd();
//pata abajo izquierda
glColor3f(1.0 , 1.1 , 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);
glVertex2f(800,80);
glEnd();

20. //trofeo feo
glColor3f(1.0 , 00, 0.0);
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.1 , 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.0);
glBegin(GL_POLYGON);
glVertex2f(1080,360);
glVertex2f(1080,440);
glVertex2f(1160,560);
glVertex2f(1160,560);
glVertex2f(1120,600);
glVertex2f(1200,600);

21. glVertex2f(1200,560);
glEnd();
glColor3f(1.0 , 1.1 , 0.0);
glBegin(GL_TRIANGLES);
glVertex2f(560,360);
glVertex2f(560,40);
glVertex2f(480,280);
glEnd();
glColor3f(1.0 , 00, 0.0);
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

22. glutInitWindowSize(500,500); //tamaño de la ventana
glutInitWindowPosition(0,0); //posicion inicial de la ventana
glutCreateWindow("mi primera 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
}

23. 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();
}
void circulo(int x, int y, int radio)

24. {
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);
glVertex2f(400,1280);
glVertex2f(320,1200);
glEnd();
//cuerpo de casa

25. 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);
glEnd();
//linea cuerpo izquierda
glColor3f(0.0 , 1.0, 0.0);
glBegin(GL_QUADS);
glVertex2f(480,1160);
glVertex2f(480,600);
glVertex2f(520,600);

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

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

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

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

30. glEnd();
//cochera
glColor3f(1.0 , 00, 0.0);
glBegin(GL_POLYGON);
glVertex2f(360,880);
glVertex2f(80,880);
glVertex2f(40,800);
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);

31. glVertex2f(80,800);
glVertex2f(80,600);
glVertex2f(360,600);
glVertex2f(360,800);
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();

32. glColor3f(1.0 , 1.0,1.0);
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);
glVertex2f(1680,600);
glEnd();

33. //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);
glBegin(GL_QUADS);
glVertex2f(320,400);
glVertex2f(320,320);
glVertex2f(400,320);
glVertex2f(400,400);

34. 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);
glVertex2f(1160,440);
glEnd();
//ventana trailer cuadrada
glColor3f(1.0,1.0,1.0);
glBegin(GL_QUADS);
glVertex2f(1040,440);
glVertex2f(1040,360);

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

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

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

38. glBegin(GL_QUADS);
glVertex2f(1120,720);
glVertex2f(1120,600);
glVertex2f(1160,600);
glVertex2f(1160,720);
glEnd();
//ramas
glBegin(GL_LINES);
//llantas
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);

39. glVertex2f(1000,720);
glVertex2f(1400,720);
glVertex2f(1400,760);
glEnd();
glColor3f(0.0,0.6,0.2);
glBegin(GL_QUADS);
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);

40. glVertex2f(1200,1040);
glVertex2f(1200,1080);
glEnd();
//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);

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

43. 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
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)
{

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

45. glVertex2f(360,560);
glVertex2f(520,560);
glVertex2f(520,640);
glEnd();
glColor3f(0.6 , 0.4, 0.2);
glBegin(GL_QUADS);
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);

46. circulo(840,320,120);
glEnd();
//manos
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

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

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

49. 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);
glVertex2f(x+t+(t*a),y+t+(t*b));
glVertex2f(x+(t*a),y+t+(t*b));

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

51. }
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);
}
for(int i=0;i<=10;i++){
cubo(340,100+20*i,20,5);
}

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

53. Muñeco con formas.

54. Animación circulo
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){
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

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

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

58. 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);
circuloc(500,500,1,450);
glColor3f(0.8,0.4,0.1);
circulo( 500+ sin(a) * 100,500 + cos(a) * 100,5);

59. 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
for(int j=1;j<=10000000;j++){}//pausa
if(ang==360){ang=0;}// se repite idefinidamente
glFlush(); //forzar dibujado
glutSwapBuffers(); //y esto
}

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

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

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

63. glutDisplayFunc(dibuja);
glutIdleFunc(dibuja);
glutMainLoop();
return 0;
}