Colegio de Estudios Cientificos y Tecnológicos del Estado de México

Utilización de Software de diseño para el manejo de gráficos

Diana Becerra Hernández

MANUAL DE PRACTICAS DE OPEN GL

Prof.: Rene Domínguez Escalona

Grupo: 303

Ciclo escolar 2012-2013

Introducción

En el presente trabajo podrás ver diversos ejercicios de open gl que es una especificación estándar que define una API multilenguaje y multiplataforma para escribir aplicaciones que produzcan gráficos 2D y 3D. La interfaz consiste en más de 250 funciones diferentes que pueden usarse para dibujar escenas tridimensionales complejas a partir de primitivas geométricas simples, tales como puntos, líneas y triángulos. Fue desarrollada originalmente por Silicón (SGI) en 1992 y se usa ampliamente en CAD, realidad virtual, representación científica, visualización de información y simulación de vuelo. También se usa en desarrollo de videojuegos, donde compite con Direct3D en plataformas Microsoft Windows.

En el siguiente trabajo podrás observar diversas prácticas que se realizaron en open gl y los resultados de las mismas, también podrás darte cuenta que en open gl las figuras geométricas y los planos cartesianos son esenciales para poder realizar una figura básica, que al paso del tiempo puede llegar a convertirse en una figura o personaje con movimiento en 3d.

En open gl los códigos son la principal fuente para poder realizar nuestros diseños estos códigos están basados generalmente en un plano cartesiano en el que ponemos nuestras coordenadas para poder formar una figura y de ello te darás cuenta en el siguiente proyecto, en donde los números y las figuras geométricas no han de faltar.

Bueno en el siguiente proyecto notaras borradores los cuales son hechos para facilitar realizar una figura ya que en ellos te vasas.

INDICE

1. TABLERO DE AJEDREZ……………………………………………………………4

2. ESTRELLA………………………………………………………………………..10

3. CUBO CON LINEAS………………………………………………………………..15

4. CUBO DELINEADO…………………………………………………………….19

5. MUÑECO CON TRIANGULOS……………………………………………………24

6. CASITA………………………………………………………………………………..36

7. OSO…………………………………………………………………………………..56

8. CUBO CON CUBITOS……………………………………………………………..62

9. MUÑECO CON FORMAS…………………………………………………………..70

10. ANIMACION CIRC ULO…………………………………………………………87

11. ANIMACION SISTEMA SOLAR……………………………………………………90

12. MOVIMIENTO EN 8…………………………………………………………………93

13. SEMAFORO………………………………………………………………………….98

14.PIRAMIDE……………………………………………………………………….104

Tablero de Ajedrez

En esta práctica deberás realizar un tablero en donde pondrás 8*8 de cuadro de dos diversos colores, no hay problema si quieres agregar más cuadros si es que lo quieres hacer más grande, siempre y cuando sean pares.

CODIGO

//mi primer ventana

#include <GL/glut.h>

#include <GL/gl.h>

#include <GL/glu.h>

void inicializa(void)

{

glClearColor(1.0,0.5,0.3); //color de fondo

glMatrixMode(GL_PROJECTION); //Modo de proyeccion

glLoadIdentity(); //Establece los parametros de proyeccion

gluOrtho2D(0.0, 1000.0, 0.0, 1000.0); //vista ortogonal

}

void dibuja(void) //funcion dibuja

{

glClear(GL_COLOR_BUFFER_BIT);

glColor3f(1.0 ,1.0 ,1.0 );

glPointSize(50);

glBegin(GL_POINTS);

glVertex2i(100,100);

glVertex2i(200,200);

glVertex2i(300,100);

glVertex2i(400,200);

glVertex2i(500,100);

glVertex2i(600,200);

glVertex2i(700,100);

glVertex2i(800,200);

glVertex2i(100,300);

glVertex2i(200,400);

glVertex2i(300,300);

glVertex2i(400,400);

glVertex2i(500,300);

glVertex2i(600,400);

glVertex2i(700,300);

glVertex2i(800,400);

glVertex2i(100,500);

glVertex2i(200,600);

glVertex2i(300,500);

glVertex2i(400,600);

glVertex2i(500,500);

glVertex2i(600,600);

glVertex2i(700,500);

glVertex2i(800,600);

glVertex2i(100,700);

glVertex2i(200,800);

glVertex2i(300,700);

glVertex2i(400,800);

glVertex2i(500,700);

glVertex2i(600,800);

glVertex2i(700,700);

glVertex2i(800,800);

glEnd();

glColor3f(0.0 ,0.0 ,0.0 );

glPointSize(50);

glBegin(GL_POINTS);

glVertex2i(200,100);

glVertex2i(300,200);

glVertex2i(400,100);

glVertex2i(500,200);

glVertex2i(600,100);

glVertex2i(700,200);

glVertex2i(800,100);

glVertex2i(100,200);

glVertex2i(200,300);

glVertex2i(300,400);

glVertex2i(400,300);

glVertex2i(500,400);

glVertex2i(600,300);

glVertex2i(700,400);

glVertex2i(800,300);

glVertex2i(100,400);

glVertex2i(200,500);

glVertex2i(300,600);

glVertex2i(400,500);

glVertex2i(500,600);

glVertex2i(600,500);

glVertex2i(700,600);

glVertex2i(800,500);

glVertex2i(100,600);

glVertex2i(200,700);

glVertex2i(300,800);

glVertex2i(400,700);

glVertex2i(500,800);

glVertex2i(600,700);

glVertex2i(700,800);

glVertex2i(800,700);

glVertex2i(100,800);

glEnd();

glColor3f(1.0 ,1.0 ,1.0 );

glPointSize(50);

glBegin(GL_LINE);

glVertex2i(500,900);

glVertex2i(500,100);

glEnd();

glFlush(); //forza dibujo

}

int main (int argc, char** argv) //metodo main

{

glutInit(&argc, argv); //incializa GLUT

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización

glutInitWindowSize(475,475); //tamaño de la ventana

glutInitWindowPosition(0,0); //posicion inicial de la ventana

glutCreateWindow("ajedrez"); //nombre de la ventana

inicializa();

glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización

glutMainLoop(); //muestra todo y espera

return 0; //retorna un valor de cero

}

SALIDA

Estrella

En esta práctica deberás realizar una estrella utilizando líneas como se puede observar en el código en este caso yo pondré tres estrellas, las puedes realizar del color que desees.

BORRADOR

CODIGO

//mi primer ventana

#include <GL/glut.h>

#include <GL/gl.h>

#include <GL/glu.h>

void inicializa(void)

{

glClearColor(0.0,0.0,1.0,0.0); //color de fondo

glMatrixMode(GL_PROJECTION); //Modo de proyeccion

glLoadIdentity(); //Establece los parametros de proyeccion

gluOrtho2D(0.0, 1000.0, 0.0, 1000.0); //vista ortogonal

}

void dibuja(void) //funcion dibuja

{

glLineWidth(5);

glClear(GL_COLOR_BUFFER_BIT); //borra pantalla

glColor3f(1.0 , 1.0 , 0.0);

glBegin(GL_LINES);

glVertex2i(100,200);

glVertex2i(700,700);

glVertex2i(700,700);

glVertex2i(100,700);

glVertex2i(100,700);

glVertex2i(700,200);

glVertex2i(700,200);

glVertex2i(400,900);

glVertex2i(400,900);

glVertex2i(100,200);

glLineWidth(10);

glClear(GL_COLOR_BUFFER_BIT); //borra pantalla

glColor3f(1.0 , 0.0 , 1.0);

glBegin(GL_LINES);

glVertex2i(150,250);

glVertex2i(750,750);

glVertex2i(750,750);

glVertex2i(150,750);

glVertex2i(150,750);

glVertex2i(750,250);

glVertex2i(750,250);

glVertex2i(450,950);

glVertex2i(450,950);

glVertex2i(150,250);

glLineWidth(10);

glClear(GL_COLOR_BUFFER_BIT); //borra pantalla

glColor3f(0.0 , 1.0 , 0.0);

glBegin(GL_LINES);

glVertex2i(200,300);

glVertex2i(800,800);

glVertex2i(800,800);

glVertex2i(200,800);

glVertex2i(200,800);

glVertex2i(800,300);

glVertex2i(800,300);

glVertex2i(500,1000);

glVertex2i(500,1000);

glVertex2i(200,300);

glEnd();

glFlush(); //forza dibujo

}

int main (int argc, char** argv) //metodo main

{

glutInit(&argc, argv); //incializa GLUT

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización

glutInitWindowSize(500,500); //tamaño de la ventana

glutInitWindowPosition(0,0); //posicion inicial de la ventana

glutCreateWindow("MI primer ventana"); //nombre de la ventana

inicializa();

glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización

glutMainLoop(); //muestra todo y espera

return 0; //retorna un valor de cero

}

SALIDA

CUBO CON LINEAS

Este cubo se realizara mediante líneas para que lo formaran en tres d.

CODIGO

//mi primer ventana

#include <GL/glut.h>

#include <GL/gl.h>

#include <GL/glu.h>

void inicializa (void)

{

glClearColor(0.0,1.0,0.0,3.0); //color de fondo

glMatrixMode(GL_PROJECTION); //Modo de proyeccion

glLoadIdentity(); //Establece los parametros de proyeccion

gluOrtho2D(0.0, 1000.0, 0.0, 1000.0); //vista ortogonal

}

void dibuja(void) //funcion dibuja

{

int i;

glClear(GL_COLOR_BUFFER_BIT);

glColor3f(0.0 ,0.0 ,0.0 );

glPointSize(50);

//linea de abajo

glBegin(GL_LINES);

glVertex2i(200,200);

glVertex2i(400,200);

// linea derecha de la derecha

glBegin(GL_LINES);

glVertex2i(200,200);

glVertex2i(200,400);

//linea de arriba

glBegin(GL_LINES);

glVertex2i(400,400);

glVertex2i(200,400);

//linea de la izquierda

glBegin(GL_LINES);

glVertex2i(400,400);

glVertex2i(400,200);

//otro cuadrado

//linea de abajo

glBegin(GL_LINES);

glVertex2i(350,350);

glVertex2i(550,350);

// linea derecha de la derecha

glBegin(GL_LINES);

glVertex2i(350,350);

glVertex2i(350,550);

//linea de arriba

glBegin(GL_LINES);

glVertex2i(550,550);

glVertex2i(350,550);

//linea de la izquierda

glBegin(GL_LINES);

glVertex2i(550,550);

glVertex2i(550,350);

//diagonales

glBegin(GL_LINES);

glVertex2i(400,400);

glVertex2i(550,550);

// diagonal 2

glVertex2i(200,200);

glVertex2i(350,350);

// diagonal 3

glVertex2i(200,400);

glVertex2i(350,550);

// diagonal 4

glVertex2i(400,200);

glVertex2i(550,350);

glEnd();

glFlush(); //forza dibujo

}

int main (int argc, char** argv) //metodo main

{

glutInit(&argc, argv); //incializa GLUT

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización

glutInitWindowSize(475,475); //tamaño de la ventana

glutInitWindowPosition(0,0); //posicion inicial de la ventana

glutCreateWindow("PIRAMIDE"); //nombre de la ventana

inicializa();

glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización

glutMainLoop(); //muestra todo y espera

return 0; //retorna un valor de cero

}

SALIDA

CUBO DELINEADO

En este cubo deberás de rellenarlo y delinearlo en este caso yo utilizare la fórmula del cuadrado y después de las líneas.

CODIGO

//mi primer ventana

#include <GL/glut.h>

#include <GL/gl.h>

#include <GL/glu.h>

void inicializa(void)

{

glClearColor(0.0,1.0,1.0,1.0); //color de fondo

glMatrixMode(GL_PROJECTION); //Modo de proyeccion

glLoadIdentity(); //Establece los parametros de proyeccion

gluOrtho2D(0.0, 1000.0, 0.0, 1000.0); //vista ortogonal

}

void dibuja(void) //funcion dibuja

{

glClear(GL_COLOR_BUFFER_BIT); //borra pantalla

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_POLYGON);

glVertex2i(100,200);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(100,450);

glColor3f(1.0 , 0.0 , 0.14);

glVertex2i(350,450);

glColor3f(1.0 , 0.10 , 1.0);

glVertex2i(350,200);

glColor3f(1.0 , 0.0 , 1.0);

glEnd();

//borra pantalla

glColor3f(0.0 , 1.0 , 0.0);

glBegin(GL_POLYGON);

glVertex2i(100,450);

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(225,575);

glColor3f(1.0 , 1.0 , 3.0);

glVertex2i(450,575);

glColor3f(1.0 , 5.0 , 0.0);

glVertex2i(350,450);

glColor3f(1.0 , 1.0 , 0.0);

glEnd();

glColor3f(0.0 , 0.0 , 1.0);

glBegin(GL_POLYGON);

glVertex2i(350,450);

glColor3f(0.0 , 3.0 , 2.0);

glVertex2i(450,575);

glColor3f(0.0 , 0.16 , 0.1);

glVertex2i(450,325);

glColor3f(0.0 , 0.17 , 0.143);

glVertex2i(350,200);

glColor3f(0.10 , 0.50 , 1.0);

glEnd();

glLineWidth(6);

glBegin(GL_LINES);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(100,200);

glVertex2i(100,450);

glVertex2i(95,450);

glVertex2i(355,450);

glVertex2i(350,450);

glVertex2i(350,200);

glVertex2i(355,200);

glVertex2i(95,200);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(350,200);

glVertex2i(450,325);

glVertex2i(450,325);

glVertex2i(450,575);

glVertex2i(450,575);

glVertex2i(350,450);

glVertex2i(350,450);

glVertex2i(350,200);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(455,575);

glVertex2i(215,575);

glVertex2i(215,575);

glVertex2i(95,455);

glEnd();

glFlush(); //forza dibujo

}

int main (int argc, char** argv) //metodo main

{

glutInit(&argc, argv); //incializa GLUT

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización

glutInitWindowSize(500,500); //tamaño de la ventana

glutInitWindowPosition(0,0); //posicion inicial de la ventana

glutCreateWindow("MI primer ventana"); //nombre de la ventana

inicializa();

glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización

glutMainLoop(); //muestra todo y espera

return 0; //retorna un valor de cero

}

SALIDA

MUÑECO CONTRIANGULOS

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

BORRADOR

CODIGO

//mi primer ventana

#include <GL/glut.h>

#include <GL/gl.h>

#include <GL/glu.h>

void inicializa(void)

{

glClearColor(0.0,1.0,1.0,0.0); //color de fondo

glMatrixMode(GL_PROJECTION); //Modo de proyeccion

glLoadIdentity(); //Establece los parametros de proyeccion

gluOrtho2D(0.0, 1000.0, 0.0, 1000.0); //vista ortogonal

}

void dibuja(void) //funcion dibuja

{

glClear(GL_COLOR_BUFFER_BIT); //borra pantalla

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(160,40);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(245,40);

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(200,80);

glEnd();

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(245,40);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(245,360);

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(180,280);

glEnd();

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(320,360);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(320,280);

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(420,280);

glEnd();

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(420,280);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(380,240);

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(420,180);

glEnd();

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(420,180);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(520,180);

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(440,220);

glEnd();

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(60,360);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(80,440);

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(100,400);

glEnd();

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(100,400);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(200,520);

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(140,340);

glEnd();

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(260,520);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(298,480);

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(320,520);

glEnd();

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(380,520);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(440,360);

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(480,400);

glEnd();

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(480,400);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(500,460);

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(520,360);

glEnd();

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(298,520);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(360,600);

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(220,600);

glEnd();

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(160,600);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(298,720);

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(420,600);

glEnd();

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(540,320);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(498,280);

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(560,280);

glEnd();

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(540,320);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(580,540);

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(520,540);

glEnd();

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(540,320);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(640,540);

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(620,540);

glEnd();

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(540,320);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(498,540);

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(478,540);

glEnd();

glBegin(GL_QUADS);

glColor3f(0.6 , 0.5 , 0.4);

glVertex2i(200,520);

glVertex2i(200,340);

glVertex2i(380,340);

glVertex2i(380,520);

glEnd();

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(260,520);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(298,480);

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(320,520);

glEnd();

glBegin(GL_POLYGON);

glVertex2i(520,100);

glVertex2i(520,140);

glVertex2i(480,180);

glVertex2i(440,180);

glVertex2i(400,140);

glVertex2i(400,100);

glVertex2i(440,60);

glVertex2i(480,60);

glEnd();

glBegin(GL_POLYGON);

glVertex2i(0,0);

glVertex2i(0,40);

glVertex2i(1440,40);

glVertex2i(1440,0);

glEnd();

glFlush(); //forza dibujo

}

int main (int argc, char** argv) //metodo main

{

glutInit(&argc, argv); //incializa GLUT

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización

glutInitWindowSize(500,500); //tamaño de la ventana

glutInitWindowPosition(0,0); //posicion inicial de la ventana

glutCreateWindow("MI primer ventana"); //nombre de la ventana

inicializa();

glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización

glutMainLoop(); //muestra todo y espera

return 0; //retorna un valor de cero

}

SALIDA

CASITA

Esta casa será realizada con diversas figuras geométricas que la irán formando para ello deberemos utilizar diversos códigos de figuras geométricas como (TRIANGLES) entre otras.

BORRADOR

CODIGO

#include <GL/glut.h>

#include <GL/gl.h>

#include <GL/glu.h>

void inicializa(void)

{

glClearColor(0.0,1.0,1.0,0.0); //color de fondo

glMatrixMode(GL_PROJECTION); //Modo de proyeccion

glLoadIdentity(); //Establece los parametros de proyeccion

gluOrtho2D(0.0, 1000.0, 0.0, 1000.0); //vista ortogonal

}

void dibuja(void) //funcion dibuja

{

//calle

glClear(GL_COLOR_BUFFER_BIT); //borra pantalla

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_POLYGON);

glVertex2i(0,0);

glVertex2i(0,120);

glVertex2i(998,120);

glVertex2i(998,0);

glEnd();

//raya amarilla

glColor3f(1.0 , 0.96 , 0.49);

glBegin(GL_POLYGON);

glVertex2i(0,120);

glVertex2i(0,140);

glVertex2i(998,140);

glVertex2i(998,120);

glEnd();

//rallita gris

glColor3f(0.66 , 0.66 , 0.66);

glBegin(GL_POLYGON);

glVertex2i(0,140);

glVertex2i(0,180);

glVertex2i(998,180);

glVertex2i(998,140);

glEnd();

//rallita gris

glColor3f(0.66 , 0.66 , 0.66);

glBegin(GL_POLYGON);

glVertex2i(320,180);

glVertex2i(320,300);

glVertex2i(360,300);

glVertex2i(360,180);

glEnd();

//pasto derecha

glColor3f(0.0 , 1.0 , 0.0);

glBegin(GL_POLYGON);

glVertex2i(0,180);

glVertex2i(0,300);

glVertex2i(320,300);

glVertex2i(320,180);

glEnd();

//cuadritos

glColor3f(0.66 , 0.66 , 0.66);

glBegin(GL_POLYGON);

glVertex2i(60,200);

glVertex2i(60,220);

glVertex2i(100,220);

glVertex2i(100,200);

glEnd();

//2 cuadritos

glColor3f(0.66 , 0.66 , 0.66);

glBegin(GL_POLYGON);

glVertex2i(60,240);

glVertex2i(60,260);

glVertex2i(100,260);

glVertex2i(100,240);

glEnd();

//3 cuadritos

glColor3f(0.66 , 0.66 , 0.66);

glBegin(GL_POLYGON);

glVertex2i(120,240);

glVertex2i(120,260);

glVertex2i(160,260);

glVertex2i(160,240);

glEnd();

//4 cuadritos

glColor3f(0.66 , 0.66 , 0.66);

glBegin(GL_POLYGON);

glVertex2i(120,200);

glVertex2i(120,220);

glVertex2i(160,220);

glVertex2i(160,200);

glEnd();

//pasto izquierda

glColor3f(0.0 , 1.0 , 0.0);

glBegin(GL_POLYGON);

glVertex2i(360,180);

glVertex2i(360,300);

glVertex2i(998,300);

glVertex2i(998,180);

glEnd();

//cochera

glColor3f(0.74 , 0.69 , 0.65);

glBegin(GL_POLYGON);

glVertex2i(60,280);

glVertex2i(60,440);

glVertex2i(160,440);

glVertex2i(160,280);

glEnd();

// rallita de la cochera

glColor3f(0.85 , 0.50 , 0.11);

glBegin(GL_POLYGON);

glVertex2i(40,280);

glVertex2i(40,440);

glVertex2i(60,440);

glVertex2i(60,280);

glEnd();

// techito de la cochera

glColor3f(0.85 , 0.14 , 0.11);

glBegin(GL_POLYGON);

glVertex2i(160,440);

glVertex2i(20,440);

glVertex2i(40,460);

glVertex2i(160,460);

glEnd();

// casa

glColor3f(1.0 , 1.00 , 0.0);

glBegin(GL_POLYGON);

glVertex2i(160,280);

glVertex2i(160,560);

glVertex2i(520,560);

glVertex2i(520,280);

glEnd();

// rallas de la casa

glColor3f(0.854 , 0.509 , 0.113);

glBegin(GL_POLYGON);

glVertex2i(300,280);

glVertex2i(300,520);

glVertex2i(320,520);

glVertex2i(320,280);

glEnd();

// 2 rallas de la casa

glColor3f(0.854 , 0.509 , 0.113);

glBegin(GL_POLYGON);

glVertex2i(360,280);

glVertex2i(360,520);

glVertex2i(380,520);

glVertex2i(380,280);

glEnd();

// 3 rallas de la casa

glColor3f(0.854 , 0.509 , 0.113);

glBegin(GL_POLYGON);

glVertex2i(160,420);

glVertex2i(160,440);

glVertex2i(520,440);

glVertex2i(520,420);

glEnd();

// techo grande de la casa

glColor3f(0.854 , 0.145 , 0.113);

glBegin(GL_POLYGON);

glVertex2i(100,560);

glVertex2i(160,600);

glVertex2i(520,600);

glVertex2i(580,560);

glEnd();

// techo chico de la casa

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_POLYGON);

glVertex2i(280,520);

glVertex2i(340,560);

glVertex2i(400,520);

glEnd();

//1 ventana de la casa

glColor3f(0.113 , 0.607 , 0.854);

glBegin(GL_POLYGON);

glVertex2i(200,340);

glVertex2i(200,400);

glVertex2i(260,400);

glVertex2i(260,340);

glEnd();

//2 ventana de la casa

glColor3f(0.113 , 0.607 , 0.854);

glBegin(GL_POLYGON);

glVertex2i(200,480);

glVertex2i(200,540);

glVertex2i(260,540);

glVertex2i(260,480);

glEnd();

//3 ventana de la casa

glColor3f(0.113 , 0.607 , 0.854);

glBegin(GL_POLYGON);

glVertex2i(420,480);

glVertex2i(420,540);

glVertex2i(480,540);

glVertex2i(480,480);

glEnd();

//4 ventana de la casa

glColor3f(0.113 , 0.607 , 0.854);

glBegin(GL_POLYGON);

glVertex2i(420,340);

glVertex2i(420,400);

glVertex2i(480,400);

glVertex2i(480,340);

glEnd();

//puerta

glColor3f(1.0 , 1.0 , 1.0);

glBegin(GL_POLYGON);

glVertex2i(320,280);

glVertex2i(320,400);

glVertex2i(360,400);

glVertex2i(360,280);

glEnd();

//relleno de la puerta

glColor3f(0.113 , 0.607 , 0.854);

glBegin(GL_POLYGON);

glVertex2i(330,320);

glVertex2i(330,380);

glVertex2i(350,380);

glVertex2i(350,320);

glEnd();

//1 tronco

glColor3f(0.560 , 0.360 , 0.188);

glBegin(GL_POLYGON);

glVertex2i(640,200);

glVertex2i(640,260);

glVertex2i(660,260);

glVertex2i(660,200);

glEnd();

//2 tronco

glColor3f(0.560 , 0.360 , 0.188);

glBegin(GL_POLYGON);

glVertex2i(800,200);

glVertex2i(800,260);

glVertex2i(820,260);

glVertex2i(820,200);

glEnd();

//1 cerca

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_POLYGON);

glVertex2i(0,320);

glVertex2i(0,340);

glVertex2i(40,340);

glVertex2i(40,320);

glEnd();

//2 cerca

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_POLYGON);

glVertex2i(520,320);

glVertex2i(520,340);

glVertex2i(998,340);

glVertex2i(998,320);

glEnd();

//3 cerca

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_POLYGON);

glVertex2i(20,280);

glVertex2i(20,380);

glVertex2i(35,380);

glVertex2i(35,280);

glEnd();

//4 cerca

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_POLYGON);

glVertex2i(540,280);

glVertex2i(540,380);

glVertex2i(560,380);

glVertex2i(560,280);

glEnd();

//5 cerca

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_POLYGON);

glVertex2i(740,280);

glVertex2i(740,380);

glVertex2i(760,380);

glVertex2i(760,280);

glEnd();

//6 cerca

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_POLYGON);

glVertex2i(900,280);

glVertex2i(900,380);

glVertex2i(920,380);

glVertex2i(920,280);

glEnd();

//7 cerca

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_POLYGON);

glVertex2i(940,280);

glVertex2i(940,380);

glVertex2i(960,380);

glVertex2i(960,280);

glEnd();

//7 cerca

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_POLYGON);

glVertex2i(980,280);

glVertex2i(980,380);

glVertex2i(998,380);

glVertex2i(998,280);

glEnd();

//1 arbol de tronco

glColor3f(0.187 , 0.854 , 0.113);

glBegin(GL_POLYGON);

glVertex2i(560,260);

glVertex2i(660,540);

glVertex2i(740,260);

glEnd();

//2 arbol de tronco

glColor3f(0.187 , 0.854 , 0.113);

glBegin(GL_POLYGON);

glVertex2i(750,260);

glVertex2i(820,480);

glVertex2i(900,260);

glEnd();

//rallas de la calle

glColor3f(1.0 , 1.0 , 1.0);

glBegin(GL_POLYGON);

glVertex2i(40,75);

glVertex2i(40,85);

glVertex2i(120,85);

glVertex2i(120,75);

glEnd();

//rallas de la calle

glColor3f(1.0 , 1.0 , 1.0);

glBegin(GL_POLYGON);

glVertex2i(200,75);

glVertex2i(200,85);

glVertex2i(280,85);

glVertex2i(280,75);

glEnd();

//rallas de la calle

glColor3f(1.0 , 1.0 , 1.0);

glBegin(GL_POLYGON);

glVertex2i(420,75);

glVertex2i(420,85);

glVertex2i(500,85);

glVertex2i(500,75);

glEnd();

//rallas de la calle

glColor3f(1.0 , 1.0 , 1.0);

glBegin(GL_POLYGON);

glVertex2i(640,75);

glVertex2i(640,85);

glVertex2i(720,85);

glVertex2i(720,75);

glEnd();

//rallas de la calle

glColor3f(1.0 , 1.0 , 1.0);

glBegin(GL_POLYGON);

glVertex2i(840,75);

glVertex2i(840,85);

glVertex2i(900,85);

glVertex2i(900,75);

glEnd();

//saguan

glColor3f(1.0 , 1.0 , 1.0);

glBegin(GL_POLYGON);

glVertex2i(320,470);

glVertex2i(360,470);

glVertex2i(360,440);

glVertex2i(320,440);

glEnd();

//cuadros de las ventanas

glColor3f(1.0 , 1.0 , 1.0);

glBegin(GL_POLYGON);

glVertex2i(200,480);

glVertex2i(260,480);

glVertex2i(260,500);

glVertex2i(200,500);

glEnd();

//cuadros de las ventanas

glColor3f(1.0 , 1.0 , 1.0);

glBegin(GL_POLYGON);

glVertex2i(200,340);

glVertex2i(260,340);

glVertex2i(260,360);

glVertex2i(200,360);

glEnd();

//cuadros de las ventanas

glColor3f(1.0 , 1.0 , 1.0);

glBegin(GL_POLYGON);

glVertex2i(420,480);

glVertex2i(420,500);

glVertex2i(480,500);

glVertex2i(480,480);

glEnd();

//cuadros de las ventanas

glColor3f(1.0 , 1.0 , 1.0);

glBegin(GL_POLYGON);

glVertex2i(420,340);

glVertex2i(420,360);

glVertex2i(480,360);

glVertex2i(480,340);

glEnd();

glFlush(); //forza dibujo

}

int main (int argc, char** argv) //metodo main

{

glutInit(&argc, argv); //incializa GLUT

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización

glutInitWindowSize(500,500); //tamaño de la ventana

glutInitWindowPosition(0,0); //posicion inicial de la ventana

glutCreateWindow("MI primer ventana"); //nombre de la ventana

inicializa();

glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización

glutMainLoop(); //muestra todo y espera

return 0; //retorna un valor de cero

}

SALIDA

OSO

Este oso se diseñara solo con círculos y para ello se agregara la biblioteca de mat para poder copilar nuestro código en él se mostraran colores cafés y ojos destellantes.

BORRADOR

CODIGO

//mi primer ventana

#include <GL/glut.h>

#include <GL/gl.h>

#include <math.h>

void inicializa(void)

{

glClearColor(2.2,0.0,1.0,0.0); //color de fondo

glMatrixMode(GL_PROJECTION); //Modo de proyeccion

glLoadIdentity(); //Establece los parametros de proyeccion

gluOrtho2D(0.0, 500.0, 0.0, 500.0); //vista ortogonal

}

void circuloc(int x, int y, int t, int radio)

{

int angulo=0;

glPointSize(t);

glBegin(GL_POINTS);

//glColor3f (1.0, 0.0, 1.0);

glVertex2f(x,y);

//glColor3f(0,0.0,0.0);

for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}

glEnd();

}

void circulo(int x, int y, int radio)

{

int angulo=0;

glBegin(GL_TRIANGLE_FAN);

// glColor3f (1.0, 0.0, 1.0);

glVertex2f(x,y);

for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}

glEnd();

}

void dibuja(void) //funcion dibuja

{

//cuerpo

glClear(GL_COLOR_BUFFER_BIT);

glColor3f(0.560,0.360,0.188);

circulo(250,150,100);

glColor3f(1.0,0.0,0.0);

circuloc(250,150,5,40);

//cabeza

glColor3f(0.560,0.360,0.188);

circulo(250,325,100);

glColor3f(0.560,0.360,0.188);

circulo(150,425,50);

glColor3f(0.560,0.360,0.188);

circulo(350,425,50);

//relleno de orejas

glColor3f(1.10,0.1,0.1);

circulo(150,425,20);

glColor3f(1.10,0.1,0.1);

circulo(350,425,20);

//extremidades

glColor3f(0.560,0.360,0.188);

circulo(325,75,45);

glColor3f(1.0,0.0,0.0);

circulo(325,75,20);

glColor3f(0.560,0.360,0.188);

circulo(175,75,45);

glColor3f(1.0,0.0,0.0);

circulo(175,75,20);

glColor3f(0.0,0.0,0.0);

circuloc(325,75,5,45);

glColor3f(0.0,0.0,0.0);

circuloc(175,75,5,45);

// 2 extremidades

glColor3f(0.560,0.360,0.188);

circulo(350,175,45);

glColor3f(1.0,0.0,0.0);

circulo(350,175,20);

glColor3f(0.560,0.360,0.188);

circulo(150,175,45);

glColor3f(1.0,0.0,0.0);

circulo(150,175,20);

glColor3f(0.0,0.0,0.0);

circuloc(350,175,5,45);

glColor3f(0.0,0.0,0.0);

circuloc(150,175,5,45);

// cara

glColor3f(1.0,1.0,1.0);

circulo(300,350,25);

glColor3f(1.0,1.0,1.0);

circulo(200,350,25);

// cara

glColor3f(0.0,0.0,0.0);

circulo(300,350,10);

glColor3f(0.0,0.0,0.0);

circulo(200,350,10);

//nariz

glColor3f(0.0,0.0,0.0);

circulo(250,325,20);

glFlush(); //forza dibujo

}

int main (int argc, char** argv) //metodo main

{

glutInit(&argc, argv); //incializa GLUT

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización

glutInitWindowSize(500,500); //tamaño de la ventana

glutInitWindowPosition(100,100); //posicion inicial de la ventana

glutCreateWindow("Ventana"); //nombre de la ventana

inicializa();

glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización

glutMainLoop(); //muestra todo y espera

return 0; //retorna un valor de cero

}

SALIDA

CUBO CON CUBITOS

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

BORRADOR

CODIGO

//mi primer ventana

#include <GL/glut.h>

#include <GL/gl.h>

void inicializa(void)

{

glClearColor(0.9,0.5,0.2,0.8); //color de fondo

glMatrixMode(GL_PROJECTION); //Modo de proyeccion

glLoadIdentity(); //Establece los parametros de proyeccion

gluOrtho2D(0.0, 600.0, 0.0, 600.0); //vista ortogonal

}

void cubo (int x, int y,int t,int l){

double a=.8,b=.6;

glColor3f(0.0 , 1.1 , 0.0);

glBegin(GL_QUADS);

glVertex2f(x,y);

glVertex2f(x+t,y);

glVertex2f(x+t,y+t);

glVertex2f(x,y+t);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2f(x,y+t);

glVertex2f(x+t,y+t);

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

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

glColor3f(0.0 , 0.0 , 0.9);

glVertex2f(x+t,y+t);

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

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

glVertex2f(x+t,y);

glEnd();

glColor3f(0.0 , 0.0 , 0.0);

glLineWidth(4);

glBegin(GL_LINES);

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

}

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

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

}

int main (int argc, char** argv) //metodo main

{

glutInit(&argc, argv); //incializa GLUT

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización

glutInitWindowSize(500,500); //tamaño de la ventana

glutInitWindowPosition(100,100); //posicion inicial de la ventana

glutCreateWindow("Ventana"); //nombre de la ventana

inicializa();

glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización

glutMainLoop(); //muestra todo y espera

return 0; //retorna un valor de cero

}

SALIDA

MUÑECO CON FORMAS

En este personaje utilizaremos diversas figuras geométricas al igual que líneas, polígonos y colores diversos.

BORRADOR

CODIGO

//mi primer ventana

#include <GL/glut.h>

#include <GL/gl.h>

#include <GL/glu.h>

#include <math.h>

void inicializa(void)

{

glClearColor(2.2,0.0,1.0,0.0); //color de fondo

glMatrixMode(GL_PROJECTION); //Modo de proyeccion

glLoadIdentity(); //Establece los parametros de proyeccion

gluOrtho2D(0.0, 500.0, 0.0, 500.0); //vista ortogonal

}

void circuloc(int x, int y, int t, int radio)

{

int angulo=0;

glPointSize(t);

glBegin(GL_POINTS);

//glColor3f (1.0, 0.0, 1.0);

glVertex2f(x,y);

//glColor3f(0,0.0,0.0);

for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}

glEnd();

}

void circulo(int x, int y, int radio)

{

int angulo=0;

glBegin(GL_TRIANGLE_FAN);

// glColor3f (1.0, 0.0, 1.0);

glVertex2f(x,y);

for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}

glEnd();

}

void dibuja(void) //funcion dibuja

{

glClear(GL_COLOR_BUFFER_BIT); //borra pantalla

glColor3f(1.0 , 1.0 , 0.0);

glBegin(GL_POLYGON);

glVertex2i(160,140);

glVertex2i(160,160);

glVertex2i(300,160);

glVertex2i(300,140);

glEnd();

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_POLYGON);

glVertex2i(220,140);

glVertex2i(220,160);

glVertex2i(240,160);

glVertex2i(240,140);

glEnd();

glColor3f(0.0 , 0.2 , 0.6);

glBegin(GL_POLYGON);

glVertex2i(160,140);

glVertex2i(100,40);

glVertex2i(160,20);

glVertex2i(225,140);

glEnd();

glColor3f(0.0 , 0.2 , 0.6);

glBegin(GL_POLYGON);

glVertex2i(225,140);

glVertex2i(280,20);

glVertex2i(340,40);

glVertex2i(300,140);

glEnd();

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(60,10);

glVertex2i(160,20);

glVertex2i(100,40);

glEnd();

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(275,20);

glVertex2i(380,10);

glVertex2i(340,40);

glEnd();

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_QUADS);

glVertex2i(160,160);

glVertex2i(160,320);

glVertex2i(300,320);

glVertex2i(300,160);

glEnd();

glColor3f(0.8 , 0.5 , 0.4);

glBegin(GL_TRIANGLES);

glVertex2i(200,320);

glVertex2i(225,280);

glVertex2i(260,320);

glEnd();

glColor3f(0.0 , 0.2 , 0.6);

glBegin(GL_POLYGON);

glVertex2i(225,140);

glVertex2i(280,20);

glVertex2i(340,40);

glVertex2i(300,140);

glEnd();

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_POLYGON);

glVertex2i(120,200);

glVertex2i(80,200);

glVertex2i(160,320);

glVertex2i(160,280);

glEnd();

glColor3f(1.0 , 0.0 , 0.0);

glBegin(GL_POLYGON);

glVertex2i(380,200);

glVertex2i(340,200);

glVertex2i(300,280);

glVertex2i(300,320);

glEnd();

glColor3f(0.8 , 0.5 , 0.4);

glBegin(GL_POLYGON);

glVertex2i(200,320);

glVertex2i(200,340);

glVertex2i(260,340);

glVertex2i(260,320);

glEnd();

//CUADRITOS

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_QUADS);

glVertex2i(220,260);

glVertex2i(240,260);

glVertex2i(240,280);

glVertex2i(220,280);

glEnd();

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_QUADS);

glVertex2i(220,225);

glVertex2i(240,225);

glVertex2i(240,250);

glVertex2i(220,250);

glEnd();

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_QUADS);

glVertex2i(220,170);

glVertex2i(240,170);

glVertex2i(240,190);

glVertex2i(220,190);

glEnd();

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_QUADS);

glVertex2i(220,200);

glVertex2i(240,200);

glVertex2i(240,220);

glVertex2i(220,220);

glEnd();

glColor3f(0.8 , 0.5 , 0.4);

glBegin(GL_POLYGON);

glVertex2i(110,200);

glVertex2i(100,160);

glVertex2i(80,160);

glVertex2i(90,200);

glEnd();

glColor3f(0.8 , 0.5 , 0.4);

glBegin(GL_POLYGON);

glVertex2i(350,200);

glVertex2i(360,160);

glVertex2i(380,160);

glVertex2i(370,200);

glEnd();

glColor3f(0.8 , 0.5 , 0.4);

glBegin(GL_POLYGON);

glVertex2i(350,200);

glVertex2i(360,160);

glVertex2i(380,160);

glVertex2i(370,200);

glEnd();

//cabeza

glColor3f(0.8,0.5,0.4);

circulo(225,405,80);

glColor3f(0.8,0.5,0.4);

circulo(150,405,25);

glColor3f(0.8,0.5,0.4);

circulo(300,405,25);

glColor3f(1.0,1.0,1.0);

circulo(200,415,20);

glColor3f(1.0,1.0,1.0);

circulo(260,415,20);

glColor3f(0.0,0.0,0.0);

circulo(200,415,10);

glColor3f(0.0,0.0,0.0);

circulo(260,415,10);

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(150,430);

glVertex2i(140,450);

glVertex2i(170,460);

glEnd();

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(170,460);

glVertex2i(160,498);

glVertex2i(200,480);

glEnd();

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(200,480);

glVertex2i(215,515);

glVertex2i(240,480);

glEnd();

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(220,480);

glVertex2i(250,515);

glVertex2i(260,475);

glEnd();

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(260,475);

glVertex2i(300,490);

glVertex2i(280,450);

glEnd();

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_TRIANGLES);

glVertex2i(280,450);

glVertex2i(330,480);

glVertex2i(305,420);

glEnd();

//BOCA

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_LINES);

glVertex2i(200,360);

glVertex2i(200,350);

glVertex2i(200,350);

glVertex2i(260,350);

glVertex2i(260,350);

glVertex2i(260,360);

//NARIZ

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_LINES);

glVertex2i(220,400);

glVertex2i(220,360);

glVertex2i(220,360);

glVertex2i(240,360);

//DEDOS

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_LINES);

glVertex2i(80,160);

glVertex2i(81,150);

glVertex2i(81,150);

glVertex2i(85,160);

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_LINES);

glVertex2i(85,160);

glVertex2i(86,150);

glVertex2i(86,150);

glVertex2i(90,160);

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_LINES);

glVertex2i(90,160);

glVertex2i(91,150);

glVertex2i(91,150);

glVertex2i(95,160);

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_LINES);

glVertex2i(95,160);

glVertex2i(96,150);

glVertex2i(96,150);

glVertex2i(100,160);

//DEDOGORDO ARREGLAR

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_LINES);

glVertex2i(85,180);

glVertex2i(75,180);

glVertex2i(75,180);

glVertex2i(85,170);

//mano derecha

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_LINES);

glVertex2i(362,160);

glVertex2i(363,150);

glVertex2i(363,150);

glVertex2i(368,160);

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_LINES);

glVertex2i(368,160);

glVertex2i(369,150);

glVertex2i(369,150);

glVertex2i(374,160);

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_LINES);

glVertex2i(374,160);

glVertex2i(375,150);

glVertex2i(375,150);

glVertex2i(380,160);

//dedo gordo

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_LINES);

glVertex2i(362,180);

glVertex2i(342,160);

glVertex2i(342,160);

glVertex2i(362,160);

glEnd();

glEnd();

glFlush(); //forza dibujo

}

int main (int argc, char** argv) //metodo main

{

glutInit(&argc, argv); //incializa GLUT

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización

glutInitWindowSize(500,500); //tamaño de la ventana

glutInitWindowPosition(0,0); //posicion inicial de la ventana

glutCreateWindow("MI primer ventana"); //nombre de la ventana

inicializa();

glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización

glutMainLoop(); //muestra todo y espera

return 0; //retorna un valor de cero

}

SALIDA

ANIMACION DEL CÍRCULO

Es esta animación simplemente aremos que el circulo gire con el siguiente código

CODIGO

#include <unistd.h>

#include <GL/glut.h>

#include <GL/gl.h>

#include <math.h>

int rad=100;

double ang=0;

void inicializa(void)

{

glClearColor(0.0,0.0,0.0,0.0);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluOrtho2D(0.0, 1000.0, 0.0, 1000.0);// el ancho y largo de nuestra pantalla

}

void circulo(int x, int y, int radio)

{

int angulo=0;

glBegin(GL_TRIANGLE_FAN); glColor3f (1.0,0.0,0.0);

glVertex2f(x,y);

glColor3f(1.0,1.0,1.0);

for (angulo=0;angulo<=360; angulo++){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}

glEnd();

}

void dibuja(void)

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//esto

circulo( 500+ sin(ang) * rad,500 + cos(ang) * rad,50); //funcion circulo

ang=ang+0.01; //velocidad entre mas grande mas rapido y entre menos mas lento

for(int j=1;j<=1000000;j++){}//pausa

if(ang==360){ang=0;}// se repite idefinidamente

glFlush(); //forzar dibujado

glutSwapBuffers(); //y esto

}

int main (int argc, char** argv)

{

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA| GLUT_DEPTH);//esto tambien

glutInitWindowSize(500,500);

glutInitWindowPosition(200,400);

glutCreateWindow("Ventana");

inicializa();

glutDisplayFunc(dibuja);

glutIdleFunc(dibuja);//esto es lo que cambia

glutMainLoop();

return 0;

}

SALIDA

SISTEMA SOLAR

En el siguiente trabajo podrás observar una simulación de los planetas cada uno de ellos llevar diversos tamaños y colores, y giraran en una órbita simulando la galaxia.

CODIGO

#include <unistd.h>

#include <GL/glut.h>

#include <GL/gl.h>

#include <math.h>

int rad=100;

double ang=0;

void inicializa(void)

{

glClearColor(0.0,0.0,1.0,0.0);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluOrtho2D(0.0, 1000.0, 0.0, 1000.0);// el ancho y largo de nuestra pantalla

}

void circulo(int x, int y, int radio)

{

int angulo=0;

glBegin(GL_TRIANGLE_FAN); glColor3f (0.5, 0.5, 0.5);

glVertex2f(x,y);

glColor3f(0,0.0,0.0);

for (angulo=0;angulo<=360; angulo++){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}

glEnd();

}

void dibuja(void)

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//esto

circulo( 500+ sin(ang) * rad,500 + cos(ang) * rad,10); //funcion circulo

circulo( 500+ sin(ang) * 50,500 + cos(ang) * 50,10);

circulo( 500+ sin(ang) * 150,500 + cos(ang) * 150,10);

ang=ang+0.01; //velocidad entre mas grande mas rapido y entre menos mas lento

for(int j=1;j<=10000000;j++){}//pausa

if(ang==360){ang=0;}// se repite idefinidamente

glFlush(); //forzar dibujado

glutSwapBuffers(); //y esto

}

int main (int argc, char** argv)

{

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA| GLUT_DEPTH);//esto tambien

glutInitWindowSize(1000,1000);

glutInitWindowPosition(10,10);

glutCreateWindow("Ventana");

inicializa();

glutDisplayFunc(dibuja);

glutIdleFunc(dibuja);//esto es lo que cambia

glutMainLoop();

return 0;

}

SALIDA

MOVIMIENTO EN 8

En esta práctica podrás ver a una bolita que Cruza en 8 esto a causa de la animación dada.

CODIGO

#include <unistd.h>

#include <GL/glut.h>

#include <GL/gl.h>

#include <math.h>

int x=1, x2=1,y=1;

double a=6.15, b=6.15;

void inicializa(void){

glClearColor(1.0,1.0,0.0,1.0);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluOrtho2D(0.0, 400.0, 0.0, 400.0);// el ancho y largo de nuestra pantalla

}

void circulo(int x, int y, int radio){

int angulo=0;

glBegin(GL_TRIANGLE_FAN);

glVertex2f(x,y);

for (angulo=0;angulo<=360; angulo+=6){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}

glEnd();}

void dibuja(void)

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glColor3f(0.5, 0.0, 1.0);

circulo(300, 300, 70);

circulo(300,180,70);

glColor3f(0.0,0.0,0.0);

circulo(300,300,50);

circulo(300,180,50);

glColor3f(1.0,0.3,1.0);

if(a>=6.15 && a<=12.41){

circulo(300+ sin (a)*60,300- cos(a)*60,10);

a=a +0.01;

}

else{

circulo(300 + sin (b) *60,180+cos(b)*60,10);

b=b + 0.01;

if(b>12.4){a=6.15;b=6.15;}

for(int j=0; j<=10; j++) {}

}

glFlush();

glutSwapBuffers();

}

int main (int argc, char** argv)

{

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA| GLUT_DEPTH);

glutInitWindowSize(700,700);

glutInitWindowPosition(10,10);

glutCreateWindow("Ventana");

inicializa();

glutDisplayFunc(dibuja);

glutIdleFunc(dibuja);

glutMainLoop();

return 0;

}

SALIDA

SEMAFORO

En este trabajo podrás hacer la simulación de un semáforo utilizando colores distintos , parecidos a los reales y se ara la simulación del cambio de color.

BORRADOR

CODIGO

#include <unistd.h>

#include <GL/glut.h>

#include <GL/gl.h>

#include <math.h>

int x=1,d=1, e=1,z=1,w=1, y=1;

void inicializa(void)

{

glClearColor(0.0,0.0,0.0,0.0);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluOrtho2D(0.0, 1000.0, 0.0, 800.0);// el ancho y largo de nuestra pantalla

}

void circuloc(int x, int y, int t, int radio)

{

int angulo=0;

glPointSize(t);

glBegin(GL_POINTS);

//glColor3f (1.0, 0.0, 1.0);

glVertex2f(x,y);

//glColor3f(0,0.0,0.0);

for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}

glEnd();

}

void circulo(int x, int y, int radio)

{

int angulo=0;

glBegin(GL_TRIANGLE_FAN);// glColor3f (0.5, 0.5, 0.5);

glVertex2f(x,y);

//glColor3f(0,0.0,0.0);

for (angulo=0;angulo<=360; angulo+=6){ glVertex2f(x + sin(angulo) * radio, y + cos(angulo) * radio);}

glEnd();

}

void dibuja(void)

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glColor3f(0.8,1.0,0.0);

glBegin(GL_QUADS);

glVertex2i(400,800);

glVertex2i(600,800);

glVertex2i(600,400);

glVertex2i(400,400);

glEnd();

glColor3f(0.8,1.0,0.0);

glBegin(GL_QUADS);

glVertex2i(480,400);

glVertex2i(530,400);

glVertex2i(530,50);

glVertex2i(480,50);

glEnd();

glColor3f(0,0.0,0.0);

circuloc(500,700,4,40);

circuloc(500,600,4,40);

circuloc(500,500,4,40);

glColor3f(0.0,0.0,0.0);

circulo(500,700,40);

circulo(500,600,40);

circulo(500,500,40);

glColor3f (1.0, 0.0, 0.0);

if(x>=1 && x<600){

circulo(500,700,40);

glFlush();

x++;

}

glColor3f (0.0, 1.0, 0.0);

if(y>=1 && y<800 && x==600){

circulo(500,500,40);

glFlush();

y++;

}

glColor3f(0.0,0.0,0.0);

if(w>=1 && w<600 && y==800 && x==600){

circulo(500,600,40);

glFlush();

w++;

}

glColor3f (0.0, 1., 0.0);

if(z>=1 && z<800 && y==800 && x==600 && w==600){

circulo(500,500,40);

glFlush();

z++;

}

glColor3f(0.0,0.0,0.0);

if(d>=1 && d<800 && y==800 && x==600 && w==600 && z==800){

circulo(500,500,40);

glFlush();

d++;

}

glColor3f (1.0, 1., 0.0);

if(e>=1 && e<800 && y==800 && x==600 && w==600 && d==800){

circulo(500,600,40);

glFlush();

e++;

}

if(e==800) {e=1;d=1;z=1;x=1;y=1;w=1;}

glutSwapBuffers();

}

int main (int argc, char** argv)

{

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA| GLUT_DEPTH);

glutInitWindowSize(800,600);

glutInitWindowPosition(10,10);

glutCreateWindow("Ventana");

inicializa();

glutDisplayFunc(dibuja);

glutIdleFunc(dibuja);

glutMainLoop();

return 0;

}

SALIDA

PIRAMIDE

En esta práctica se hará una pirámide utilizando solo líneas y colores que desees esto es una práctica sencilla y fácil aunque un poco tediosa.

CODIGO

//mi primer ventana

#include <GL/glut.h>

#include <GL/gl.h>

#include <GL/glu.h>

void inicializa(void)

{

glClearColor(0.0,0.1,4.0,0.0); //color de fondo

glMatrixMode(GL_PROJECTION); //Modo de proyeccion

glLoadIdentity(); //Establece los parametros de proyeccion

gluOrtho2D(0.0, 500.0, 0.0, 500.0); //vista ortogonal

}

void dibuja(void) //funcion dibuja

{

glLineWidth(4);

int i=0,a=20;

glClear(GL_COLOR_BUFFER_BIT); //borra pantalla

glColor3f(1.0 , 0.0 , 0.0);

glBegin (GL_LINES);

//Valor inicial--- Valor final o condicion--- incremento

for(i=1;i<=10; i++){

//abajo

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(240-a*i,240+a*i);

glVertex2i(260+a*i,240+a*i);

//derecha

glColor3f(1.0 , 0.0 , 0.0);

glVertex2i(240-a*i,240+a*i);

glVertex2i(240-a*i,220-a*i);

// izquierda

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(260+a*i,240+a*i);

glVertex2i(260+a*i,220-a*i);

//arriba

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(240-a*i,220-a*i);

glVertex2i(260+a*i,220-a*i);

}

glEnd();

glBegin(GL_LINES);

glVertex2i(42,20);

glVertex2i(62,40);

glVertex2i(82,60);

glVertex2i(102,80);

glVertex2i(122,100);

glVertex2i(142,120);

glVertex2i(162,140);

glVertex2i(182,160);

glVertex2i(202,180);

glVertex2i(222,200);

glVertex2i(282,260);

glVertex2i(302,280);

glVertex2i(322,300);

glVertex2i(342,320);

glVertex2i(362,340);

glVertex2i(382,360);

glVertex2i(402,380);

glVertex2i(422,400);

glVertex2i(442,420);

glVertex2i(462,440);

//derecha izquierda

glVertex2i(42,440);

glVertex2i(62,415);

glVertex2i(82,400);

glVertex2i(102,375);

glVertex2i(122,360);

glVertex2i(142,335);

glVertex2i(162,320);

glVertex2i(182,295);

glVertex2i(202,280);

glVertex2i(222,255);

glVertex2i(282,200);

glVertex2i(302,180);

glVertex2i(322,160);

glVertex2i(342,140);

glVertex2i(362,120);

glVertex2i(382,100);

glVertex2i(402,80);

glVertex2i(422,60);

glVertex2i(442,40);

glVertex2i(462,20);

glEnd();

glFlush(); //forza dibujo

}

int main (int argc, char** argv) //metodo main

{

glutInit(&argc, argv); //incializa GLUT

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //establece el modo de visualización

glutInitWindowSize(500,500); //tamaño de la ventana

glutInitWindowPosition(0,0); //posicion inicial de la ventana

glutCreateWindow("MI primer ventana"); //nombre de la ventana

inicializa();

glutDisplayFunc(dibuja); //Envia los graficos a la ventana de visualización

glutMainLoop(); //muestra todo y espera

return 0; //retorna un valor de cero

}

SALIDA