Post on 29-Jun-2015
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