Manual de Practicas de Open GL con Dev C++

Colegio de Estudios Científicos Y Tecnológicos del Estado de México

Cecytem Plantel Tecámac

Materia: Utilización de Software de Diseño

Profesor: Rene Domínguez Escalona

Alumno(s): Karen Alin Simón García y Brandon Cervantes García

Titulo:

“Manual de prácticas de Open GL”

Proyecto 2° parcial

Informática

1


3° Semestre

¿Qué es OpenGL?

Las librerías gráficas OpenGL, son un software que facilita el interface con el hardware gráfico de nuestra máquina. Consta de unas 120 funciones distintas, que especifican los objetos y las operaciones necesarias para producir aplicaciones interactivas en las que intervienen gráficos en tres dimensiones.

Esta diseñado de forma completamente independiente del hardware por lo que puede implementarse en plataformas muy diversas (PC, SGI, Digital, Sun, etc…. El precio que hay que pagar en aras de esta portabilidad, es que OpenGL no incluye comandos para gestionar el sistema de ventanas, ni para capturar órdenes de los usuarios, ya sea por ratón o por teclado. En lugar de esto, debemos trabajar con la ayuda de cualquier sistema de ventanas que se utilice en la máquina en concreto en la que estemos trabajando. En nuestro caso utilizaremos el sistema de ventanas de Windows.

Librerías De OpenGL.

La librería principal de OpenGL nos suministra todas las funciones necesarias para mostrar un entorno 3D aunque hay algunas operaciones que son algo tediosas de realizar utilizando solo esta librería. Estas son por ejemplo calcular la matriz de proyección. Para esto se han desarrollado también unas librerías auxiliares:

GLU: Esta librería acompaña a la OpenGL principal. Incluye funciones más complejas que GL por ejemplo definir un cilindro o un disco con un solo comando, también contiene funciones para trabajar con splines y operaciones con matrices.

GLUT: Esta librería es independiente de la librería OpenGL de cada plataforma. Esta librería no incluye funciones adiconales para OpenGL :( pero nos permite utilizar funciones para el tratamiento de ventanas, teclado y ratón. Para trabajar con OpenGL en cualquier plataforma, primero tenemos que inicializar una ventana (y esto es diferente entre Windows y Linux por ejemplo). GLUT nos permite crear ventanas y controlar la entrada independientemente de la plataforma utilizada :). Aunque también contiene comandos para crear conos, tazas de té...

GLAUX: Esta librería, muy parecida a GLUT, es la que Microsoft ha desarrollado para Windows. Mantiene prácticamente la misma estructura que la GLUT con el

2


defecto de que solo sirve para Windows, mientras que GLUT sirve para cualquier plataforma.

GLX: Esta es la librería utilizada para trabajar en un sistema de X-Windows (Linux), permite no sólo rende rizar en la máquina local, sino también a través de una red.

Configuración de Dev-C++ en Windows para OpenGL

Los programas de ejemplo están hechos bajo lenguaje C, así que se requiere un compilador. Si se trabaja en alguna distribución de Linux, seguro cuenta con los compiladores GCC y G++.

Si se trabaja en ambiente Win32 se puede usar un compilador de Borland, de Microsoft y también un compilador de software libre como el Bloodshed Dev-C++ el cual usa el Mingw y se puede obtener en http://www.bloodshed.net/dev/devcpp.html.

Cualquiera de ellos al momento de instalarse ya incluyen las librerías gl y glu, por lo cual sólo nos hace falta la librería de glut, que es la usada para el manejo de ventanas y eventos. En la página http://www.opengl.org/resources/libraries/glut.html viene información de donde bajar glut, es importante hacer notar que los archivos .a son creados para cada compilador, por lo tanto es necesario bajar la librería apropiada de acuerdo al que se haya instalado.

SourceForge, mantiene una versión de glut más actualizada llamada openglut, información y archivos para descargar se encuentran en http://openglut.sourceforge.net/index.html. Otro sitio donde se puede encontrar glut y openglut para Dev-C++ es: http://www.nigels.com/glt/devpak.

Una vez que se han descargado los archivos para glut, la instalación es muy sencilla: El archivo glut32.dll se coloca bajo el directorio Windows/system32, el archivo glut.h se coloca bajo include/GL y libglut32.a se coloca bajo lib, ambos del directorio de instalación del Dev-C++

Una vez colocados los archivos donde corresponde, sólo hace falta configurar el Dev-C++ para compilar los programas. Existen varias formas, una es creando un proyecto y se puede consultar en la página de Linux de Acatlán: http://www.acatlan.unam.mx/linux/graficacion/compilawindows.html.Otra manera es sólo compilar el programa con las opciones apropiadas, para esto se abre el menú Herramientas>Opciones del Compilador:

3


Después se marca el recuadro junto a “Añadir estos comandos a la línea de comandos del linker” y se agregan los nombres de las librerías -lglut32 -lglu32 -l opengl32. Esto sólo se hace una vez y después se puede compilar cualquier programa de OpenGL con glut.

Índice

1. Tablero de Ajedrez2. Estrella3. Cubo con líneas 4. Cubo delineado5. Muñeco con triángulos6. Casita7. Oso8. Cubo con cubitos9. Muñeco con formas10.Animación circulo11.Animación circulo rotando12.Animación sistema solar 13.Movimiento en ocho14.Semáforo15.Objetos 3D Wire (9)16.Objetos 3D Solid (9)17. Interacción Teclado18. Interacción con mouse19. Interacción de objetos 3D con mouse y teclado20.Cubo 3D con líneas

4


PracticasTablero de Ajedrez:

//tablero de ajedrez

#include <GL/glut.h>

#include <GL/gl.h>

#include <GL/glu.h>

void inicializa(void)

{

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

glMatrixMode(GL_PROJECTION); //Modo de proyeccion

glLoadIdentity(); //Establece los parametros de proyeccion

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

}

void dibuja(void) //funcion dibuja

{

glClear(GL_COLOR_BUFFER_BIT); //borra pantalla

glColor3f(0.0 , 0.0 , 0.0);

glPointSize(60);

glBegin(GL_POINTS);

glVertex2i(100,100);


5




























6


glEnd();

glColor3f(1.0 , 1.0 , 1.0);

glPointSize(60);

glBegin(GL_POINTS);























7








glEnd();

glFlush(); //forza dibujo

}

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

{

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

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

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

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

glutCreateWindow("TABLERO DE 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

}

8


Estrella

//estrella


#include <GL/gl.h>

#include <GL/glu.h>


{





}


{

9



glLineWidth(2);

glBegin(GL_LINES);

glVertex2i(50,50);



glVertex2i(400,50);

glVertex2i(400,50);

glVertex2i(50,300);

glVertex2i(50,300);



glVertex2i(50,50);

glEnd();


}


{





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

inicializa();

10





}

Cubo con líneas

//cubo con lineas


#include <GL/gl.h>

#include <GL/glu.h>


{




11



}


{


glLineWidth(2);

glBegin(GL_LINES);

//enfrente

glVertex2i(50,50);

glVertex2i(50,300);

glVertex2i(50,300);



glVertex2i(300,50);

glVertex2i(300,50);

glVertex2i(50,50);

//atras






12





//linea izquierda

glVertex2i(50,300);


//linea derecha



//linea izquierda abajo

glVertex2i(50,50);


//linea derecha abajo

glVertex2i(300,50);


glEnd();


}


{


13





glutCreateWindow("mi primera ventana"); //nombre de la ventana

inicializa();




}

Cubo delineado

//cubo delineado


14


#include <GL/gl.h>

#include <GL/glu.h>


{





}


{


glColor3f(1.0 , 0.0 , 0.0);

glPointSize(50);

glBegin(GL_QUADS);

//ATRAS

glColor3f(0.0 , 0.0 , 0.0);

glVertex2d(100,150);




//ABAJO

glColor3f(0.0 , 0.0 , 0.0);

15






//izquierdo

glColor3f(0.0 , 0.1 , 0.1);





//derecho

glColor3f(1.1 , 1.1 , 1.1);





//arriba

glColor3f(1.2 , 0.0 , 0.0);





//enfrente

glColor3f(1.5 , 1.5 , 0.0);

16






glEnd();


}


{





glutCreateWindow("mi primera ventana"); //nombre de la ventana

inicializa();




}

17


Muñeco con Triángulos


#include <GL/gl.h>

#include <GL/glu.h>


{





}

18



{


glColor3f(1.0 , 0.0 , 1.0);

glLineWidth(5);

glBegin(GL_TRIANGLES);

glVertex2i(97,12);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(167,12);

glColor3f(0.0 , 0.0 , 1.0);

glVertex2i(167,54);

glVertex2i(140,55);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(190,55);

glColor3f(0.0 , 0.0 , 1.0);


glVertex2i(260,12);

glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(333,12);

glColor3f(0.0 , 0.0 , 1.0);

glVertex2i(260,54);

glVertex2i(240,54);

glColor3f(1.0 , 0.0 , 1.0);

19


glVertex2i(290,54);

glColor3f(0.0 , 0.0 , 1.0);



glColor3f(1.0 , 0.0 , 1.0);


glColor3f(0.0 , 0.0 , 1.0);



glColor3f(1.0 , 0.0 , 1.0);


glColor3f(0.0 , 0.0 , 1.0);



glColor3f(1.0 , 0.0 , 1.0);


glColor3f(0.0 , 0.0 , 1.0);



glColor3f(1.0 , 0.0 , 1.0);


glColor3f(0.0 , 0.0 , 1.0);


20



glColor3f(1.0 , 0.0 , 1.0);


glColor3f(0.0 , 0.0 , 1.0);


glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(340,30);

glVertex2i(395,30);


glColor3f(1.0 , 0.0 , 1.0);

glVertex2i(340,30);

glVertex2i(395,30);


glColor3f(1.0 , 0.0 , 1.0);



glColor3f(0.0 , 0.0 , 1.0);


glColor3f(1.0 , 0.0 , 1.0);


glVertex2i(59,179);

glColor3f(0.0 , 0.0 , 1.0);


glEnd();

21


glBegin(GL_QUADS);


glColor3f(1.0 , 0.0 , 1.0);



glColor3f(1.0 , 0.0 , 1.0);


glColor3f(010 , 1.0 , .0);


glColor3f(0.0 , 1.0 , .0);


glColor3f(0.0 , 1.0 , .0);


glColor3f(1.0 , 1.0 , .0);


glEnd();


}


{




22



glutCreateWindow("Muñeco con triangulos"); //nombre de la ventana

inicializa();




}

Casita


#include <GL/gl.h>

#include <GL/glu.h>

23



{

glClearColor(0.0,0.0,1.0,1.0);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluOrtho2D(0.0, 900.0, 0.0, 900.0);

}

void dibuja(void)

{

glClear(GL_COLOR_BUFFER_BIT);

glColor3f(0.12 ,0.12 ,0.12 );

glLineWidth(2);

glBegin(GL_QUADS);

glVertex2i(0,80);


glVertex2i(1000,0);

glVertex2i(0,0);

glEnd();

glColor3f(1.0,1.0,1.0);

glBegin(GL_LINES);

glVertex2i(0,40);

glVertex2i(50,40);

glVertex2i(70,40);

glVertex2i(120,40);

24


glVertex2i(140,40);

glVertex2i(190,40);

glVertex2i(210,40);

glVertex2i(260,40);

glVertex2i(280,40);

glVertex2i(330,40);

glVertex2i(350,40);

glVertex2i(400,40);

glVertex2i(420,40);

glVertex2i(470,40);

glVertex2i(490,40);

glVertex2i(540,40);

glVertex2i(560,40);

glVertex2i(610,40);

glVertex2i(630,40);

glVertex2i(680,40);

glVertex2i(700,40);

glVertex2i(750,40);

glVertex2i(770,40);

glVertex2i(820,40);

glVertex2i(840,40);

glVertex2i(890,40);

glEnd();

glColor3f(1.0 ,1.0 ,0.0 );

25


glLineWidth(5);

glBegin(GL_LINES);

glVertex2i(0,84);


glEnd();

glColor3f(0.21,0.21,0.21);

glBegin(GL_POLYGON);

glVertex2i(0,118);







glVertex2i(0,88);

glEnd();

glColor3f(0.0,1.0,0.0);


glVertex2i(0,118);

glVertex2i(0,238);

glVertex2i(75,238);

glVertex2i(75,193);


26



glVertex2i(0,118);

glEnd();

glColor3f(0.0,1.0,0.0);









glEnd();

glColor3f(1.0,0.52,0.05);

glBegin(GL_QUADS);

glVertex2i(75,193);

glVertex2i(75,313);

glVertex2i(90,313);

glVertex2i(90,193);

glEnd();

glColor3f(1.0,0.0,0.0);


glVertex2i(61,313);

27


glVertex2i(75,345);



glEnd();

glColor3f(0.80,0.80,0.80);

glBegin(GL_QUADS);

glVertex2i(90,193);

glVertex2i(90,313);



glEnd();

glColor3f(1.0,1.0,0.28);

glBegin(GL_QUADS);





glEnd();

glColor3f(0.95,0.47,0.0);

glBegin(GL_QUADS);





28


glEnd();

glColor3f(0.95,0.47,0.0);

glBegin(GL_QUADS);





glEnd();

glColor3f(0.95,0.47,0.0);

glBegin(GL_QUADS);





glEnd();

glColor3f(0.77,0.0,0.0);





glEnd();

glColor3f(1.0,0.0,0.0);


29









glEnd();

glFlush();

}

int main (int argc, char** argv)

{

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);

glutInitWindowSize(1000,1000);

glutInitWindowPosition(0,0);

glutCreateWindow("Casa");

inicializa();

glutDisplayFunc(dibuja);

glutMainLoop();

return 0;

}

30


Oso

//oso


#include <GL/gl.h>

#include <math.h>


{





}

31


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


glEnd();

}

32



{


glColor3f(0.8,0.5,0.4); //borra pantalla

circulo(190,190,40);

glColor3f(0.7,0.2,0.4);

circulo(190,190,20);

glColor3f(0.8,0.5,0.4);

circulo(315,315,40);

glColor3f(0.7,0.2,0.4);

circulo(315,315,20);

glColor3f(0.8,0.5,0.4);

circulo(190,315,40);

glColor3f(0.7,0.2,0.4);

circulo(190,315,20);

glColor3f(0.8,0.5,0.4);

circulo(315,190,40);

glColor3f(0.7,0.2,0.4);

circulo(315,190,20);

glColor3f(0.8,0.5,0.4);

circulo(250,360,60);

glColor3f(1.0,1.0,1.0);

circulo(270,380,15);

glColor3f(0.0,0.0,0.0);

33


circulo(270,380,10);

glColor3f(1.0,1.0,1.0);

circulo(230,380,15);

glColor3f(0.0,0.0,0.0);

circulo(230,380,10);

glColor3f(0.0,0.0,0.0);

circulo(250,340,15);

glColor3f(0.8,0.5,0.4);

circulo(300,420,25);

glColor3f(0.7,0.2,0.4);

circulo(300,420,10);

glColor3f(0.8,0.5,0.4);

circulo(200,420,25);

glColor3f(0.7,0.2,0.4);

circulo(200,420,10);

glColor3f(0.7,0.2,0.6);

circulo(250,250,50);

glColor3f(0.8,0.5,0.4);

circuloc(250,250,5,50);


}


{


34





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

inicializa();




}

35


Cubo con Cubitos

//cubo de cubos


#include <GL/gl.h>


{





}

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

double a=.8,b=.6;

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_QUADS);

glVertex2f(x,y);

glVertex2f(x+t,y);

glVertex2f(x+t,y+t);

glVertex2f(x,y+t);

glColor3f(0.0 , 0.0 , 0.0);

36


glVertex2f(x,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.0);



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

glVertex2f(x+t,y);

glEnd();

glColor3f(1.0 , 0.0 , 0.0);

glLineWidth(.8);

glBegin(GL_LINES);

glVertex2f(x,y);

glVertex2f(x+t,y);

glVertex2f(x+t,y);



glVertex2f(x,y+t);

glVertex2f(x,y);

glVertex2f(x,y+t);




37




glVertex2f(x,y+t);








glVertex2f(x+t,y);


glEnd();

}


{


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++){

38


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

39


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

}


}


{






inicializa();


40




}

Muñeco con formas

//muñeco


#include <GL/gl.h>

#include <math.h>


41


{





}


{

int angulo=0;

glPointSize(t);

glBegin(GL_POINTS);

//glColor3f (1.0, 0.0, 1.0);

glVertex2f(x,y);

//glColor3f(0,0.0,0.0);


glEnd();

}


{

int angulo=0;


// glColor3f (1.0, 0.0, 1.0);

42


glVertex2f(x,y);


glEnd();

}


{


glColor3f(0.8,0.5,0.4); //borra pantalla

circulo(225,400,80);

glColor3f(0.0,0.0,0.0);

circulo(200,440,7);

glColor3f(0.0,0.0,0.0);

circulo(240,440,7);

glEnd();

glColor3f(0.0 , 0.0 , 0.0);





glEnd();

glColor3f(0.0 , 0.0 , 0.0);

43






glEnd();

glColor3f(0.0 , 0.0 , 0.0);





glEnd();

glBegin(GL_LINES);


glEnd();


glColor3f(0.8,0.1,0.1);








glEnd();

44






glVertex2i(80,200);

glEnd();






glEnd();

//di

glColor3f(1.0 , 1.0 , 0.0);






glEnd();

glColor3f(0.0 , 0.0 , 0.0);




45




glEnd();

glColor3f(0.0 , 0.2 , 0.6);



glVertex2i(100,40);

glVertex2i(160,20);


glEnd();

glColor3f(0.0 , 0.2 , 0.6);



glVertex2i(280,20);

glVertex2i(340,40);


glEnd();

glColor3f(0.0 , 0.0 , 0.0);


glVertex2i(275,20);

glVertex2i(380,10);

glVertex2i(340,40);

glEnd();

glColor3f(0.0 , 0.0 , 0.0);

46



glVertex2i(160,20);

glVertex2i(100,40);

glVertex2i(50,20);

glEnd();


}


{






inicializa();




}

47


Animación circulo

#include <unistd.h>


#include <GL/gl.h>

#include <math.h>

int x=1, y=1, z=1, a=1;


{



glLoadIdentity();

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

48


}


{

int angulo=0;

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

glVertex2f(x,y);

glColor3f(0,0.0,0.0);


glEnd();

}

void dibuja(void)

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

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

circulo(5+1*x,900,15);

glFlush();

x++;

}

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

{

circulo(805,900-y,15);

glFlush();

y++;

49


}

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

circulo(805-z,100,15);

glFlush();

z++;

}

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

circulo(5,100+a,15);

glFlush();

a++;

if(a==800){x=1; y=1; z=1;}

}

glutSwapBuffers();

}


{


glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA| GLUT_DEPTH);



glutCreateWindow("Movimiento de bolita");

inicializa();


glutIdleFunc(dibuja);

50


glutMainLoop();

return 0;

}

Animación Sistema solar

#include <unistd.h>


#include <GL/gl.h>

#include <math.h>

int rad=100;

double ang=0;

double a=0;

double b=0;

double c=0;

double d=0;

51


double e=0;

double f=0;

double g=0;


{



glLoadIdentity();


}


{

int angulo=0;


glVertex2f(x,y);

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

glEnd();

}


{

int angulo=0;

glPointSize(t);

glBegin(GL_POINTS);

52


//glColor3f (1.0, 0.0, 1.0);

glVertex2f(x,y);

//glColor3f(0,0.0,0.0);


glEnd();

}

void dibuja(void)

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//esto

glColor3f(1.0,1.0,1.0);

circuloc(500,500,1,100);

circuloc(500,500,1,200);

circuloc(500,500,1,300);

circuloc(500,500,1,400);

circuloc(500,500,1,55);

circuloc(500,500,1,150);

circuloc(500,500,1,250);

circuloc(500,500,1,350);

glColor3f(1.0,1.0,1.0);

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

glColor3f(1.0,0.0,0.0);

circulo( 500+ sin(a) * 55,500 + cos(a) * 55,10);

53


glColor3f(0.0,0.0,1.0);

circulo( 500+ sin(b) * 150,500 - cos(b) * 150,13);

glColor3f(0.0,1.0,0.0);

circulo( 500+ sin(c) * 200,500 + cos(c) * 200,10);

glColor3f(0.0,1.0,0.9);

circulo( 500+ sin(d) * 250,500 - cos(d) * 250,20);

glColor3f(0.0,1.0,1.0);

circulo( 500+ sin(g) * 300,500 + cos(g) * 300,10);

glColor3f(0.0,1.0,0.5);

circulo( 500+ sin(e) * 350,500 - cos(e) * 350,20);

glColor3f(1.0,1.0,0.0);

circulo( 500+ sin(f) * 400,500 + cos(f) * 400,10);

ang=ang+0.06;

a=a+0.07;

b=b+0.01;

c=c+0.03;

d=d+0.05;

e=e+0.04;

f=f+0.05;

g=g+0.06; //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

54


glColor3f(1.0,0.9,0.0);

circulo(500,500,35);//sol

glFlush(); //forzar dibujado

glutSwapBuffers(); //y esto

}


{


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



glutCreateWindow("Sistema Solar");

inicializa();


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

glutMainLoop();

return 0;

}

55


Movimiento en Ocho

#include <unistd.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){



glLoadIdentity();


}

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

int angulo=0;


56


glVertex2f(x,y);


glEnd();}

void dibuja(void)

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glColor3f (1.0,0.9, 0.0);

circulo(500,300,250);

glColor3f (0.0,0.0, 0.0);

circulo(500,300,150);

glColor3f (1.0,0.9, 0.0);

circulo(500,700,250);

glColor3f (0.0,0.0, 0.0);

circulo(500,700,150);//ocho

//la otra bolita

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

circulo(500 - sin (a)*200,700 - cos(a)*200,40);

a=a+ 0.031;

}

else{

circulo(500 - sin (b) *200,300 - cos(b)*-200,40);

b=b + 0.1;

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

57


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

}

// se repite idefinidamente



}


{





glutCreateWindow("Movimiento en 8");

inicializa();



glutMainLoop();

return 0;

}

58


Semáforo

Nombre 3D

#include <GL/gl.h>

#include <GL/glu.h>


#include <stdio.h>

#include <math.h>

#include <stdlib.h>

GLfloat anguloEsfera = 0.0f;

GLfloat girax=0,giray=0,zoom=0,e,f;

GLboolean malla=GL_FALSE, ejes=GL_TRUE;

void mover(void){

glTranslated(0,0,zoom);

glRotated(girax,1.0,0.0,0.0);

glRotated(giray,0.0,1.0,0.0);

}

59


void creaMalla(void){

int i, long_eje=10;

glColor3f(1.0,1.0,0.0);

glBegin(GL_LINES);

for(i=-long_eje;i<=long_eje;i++){

glVertex3f(i,-long_eje,0);

glVertex3f(i,long_eje,0);

glVertex3f(-long_eje,i,0);

glVertex3f(long_eje,i,0);

glVertex3f(i,0,-long_eje);

glVertex3f(i,0,long_eje);

glVertex3f(-long_eje,0,i);

glVertex3f(long_eje,0,i);

}

glEnd();

}

void creaEjes(void){

glColor3f(0.0,0.0,0.0);

glBegin(GL_LINES);

glColor3f(0.0,0.0,1.0);

glVertex3f(-11.0,0.0,0.0);

glVertex3f(11.0,0.0,0.0);

glColor3f(1.0,0.0,0.0);

60


glVertex3f(0.0,-11.0,0.0);

glVertex3f(0.0,11.0,0.0);

glColor3f(0.0,1.0,0.0);

glVertex3f(0.0,0.0,-11.0);

glVertex3f(0.0,0.0,11.0);

glEnd();


glColor3f(0.0,0.0,1.0);

glVertex3f(11.0,0.0,0.0);

glVertex3f(10.5,0.0,-.50);

glVertex3f(10.5,0.0,.50);

glColor3f(1.0,0.0,0.0);

glVertex3f(0.0,11.0,0.0);

glVertex3f(-.50,10.5,0.0);

glVertex3f(.50,10.5,0.0);

glColor3f(0.0,1.0,0.0);

glVertex3f(0.0,0.0,11.0);

glVertex3f(-.50,0.0,10.5);

glVertex3f(.50,0.0,10.5);

//puntas otras

glColor3f(0.0,0.0,1.0);

glVertex3f(-11.0,0.0,0.0);

glVertex3f(-10.5,0.0,.50);

glVertex3f(-10.5,0.0,-.50);

61


glColor3f(1.0,0.0,0.0);

glVertex3f(0.0,-11.0,0.0);

glVertex3f(.50,-10.5,0.0);

glVertex3f(-.50,-10.5,0.0);

glColor3f(0.0,1.0,0.0);

glVertex3f(0.0,0.0,-11.0);

glVertex3f(.50,0.0,-10.5);

glVertex3f(-.50,0.0,-10.5);

glEnd();

}

void init ( void )

{

glClearColor(1.0,1.0,1.0,0.0) ;// Definimos el negro como color de fondo

glEnable(GL_DEPTH_TEST); // Activamos el z-Buffer

glEnable(GL_LIGHTING); // Activamos la iluminaciÃ³n

glEnable(GL_LIGHT0); // Activamos la luz 0

glMatrixMode(GL_PROJECTION); // set the view volume shape

glLoadIdentity(); glOrtho(-15,15,-15,15,-30,30);

glMatrixMode(GL_MODELVIEW); // position and aim the camera

glLoadIdentity();

gluLookAt(5.0, 5.0, 5.0, 0.0, 0.0, 0.0, 0.0, 2.0, 0.0);

62


}

void dibuja( void )

{

glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

glEnable(GL_DEPTH_TEST); // Activamos el z-Buffer

glEnable(GL_LIGHTING); // Activamos la iluminaciÃ³n

glEnable(GL_LIGHT0); // Activamos la luz 0

//glShadeModel(GL_FLAT);

glShadeModel (GL_SMOOTH);

// Cargamos la matriz identidad para reiniciar las transformaciones

/* float angulo;

int i;

glLineWidth(20);

glBegin(GL_LINES);

glColor3d(1,1,1);

for (i=0; i<360; i+=10) {

angulo = (GLfloat)i*3.14159f/180.0f; // grados a radianes

glColor3d(1,1,1);

glVertex3i(0,0,-3);

glVertex3f(0+cos(angulo)*45, 0+sin(angulo)*45,0);

}

glEnd();*/

// Colocamos una luz

63


glLightfv(GL_LIGHT0,GL_DIFFUSE,(GLfloat []){1.0f,1.0f,1.0f,0.0f}); // Color de la luz

glLightfv(GL_LIGHT0,GL_AMBIENT,(GLfloat []){1.0, 1.0, 1.0, 4.0}); // Luz ambiente

glLightfv(GL_LIGHT0,GL_POSITION,(GLfloat []){0.0f,12.0f,5.0f,0.0f}); // PosiciÃ³n de la luz

glLightfv(GL_LIGHT0,GL_EMISSION,(GLfloat []){0.5,0.5,0.5,1.0});

//glShadeModel (GL_SMOOTH);

// esfera

glPushMatrix();

mover();

if(malla) creaMalla();

if(ejes) creaEjes();

//glRotatef(anguloEsfera, 1.0f, 1.0f,0.0f);

glColor3f(1.0,1.0,0.0);

//A

glTranslatef(-7.2,0.0, 0.0);

glutSolidCube(1);

glTranslatef(0.0,-0.9, 0.0);

glutSolidCube(1);

glTranslatef(0.9,0.0, 0.0);

glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);

64



glutSolidCube(1);


glutSolidCube(1);

//l


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);

//i


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);

//n


glutSolidCube(1);


65


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);

// AQUI PONES TU NOMBRE

//AQUI

//AQUI

//AQUI//AQUI

//AQUI//AQUI//AQUI

//AQUI

glPopMatrix ();

glFlush();

glutSwapBuffers ();

//anguloEsfera+=2.0f;

}

void reshape(int w, int h){



glLoadIdentity();

glOrtho(-15,15,-15,15,-30,30);

glMatrixMode(GL_MODELVIEW);

66


glLoadIdentity();

glClear(GL_DEPTH_TEST);

}

void activo(int x,int y){

// x= e;

//y= f;

girax=y;

giray=700-x;

glutPostRedisplay();

}

void teclado(unsigned char key, int x, int y){

switch(key){

case 27:

exit(0);

case '+':

zoom++;

break;

case '-':

zoom--;

break;

case 'p':


67


glLoadIdentity();

gluPerspective(45,1,10,100);

zoom=-40;

break;

case 'o':


glLoadIdentity();

glOrtho(-15,15,-15,15,-30,30);

zoom=0;

break;

case 'm':

malla= !malla;

break;

case 'e':

ejes= !ejes;

default: break;

}


}

void flechas(int key, int x, int y){

switch(key){

case GLUT_KEY_LEFT:

giray-=15;

68


break;

case GLUT_KEY_RIGHT:

giray+=15;

break;

case GLUT_KEY_UP:

girax-=15;

break;

case GLUT_KEY_DOWN:

girax+=15;

break;

default: break;

}


}

int main ( int argc, char** argv )

{

glutInit (&argc, argv);

glutInitDisplayMode (GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);

glutInitWindowSize (600,600);

glutInitWindowPosition (100,100);

glutCreateWindow ("Objetos 3D");

//init ( );

glutDisplayFunc (dibuja);

69


//glutIdleFunc(dibuja);

glutReshapeFunc ( reshape );

glutKeyboardFunc(teclado);

glutSpecialFunc(flechas);

glutMotionFunc(activo);

glutMainLoop( );

return 0;

}

70


Semáforo.

SEMAFORO

En esta práctica realizaremos un semáforo en el cual los colores se cambien según la ubicación de dicho semáforo, para ello utilizaremos, rectángulos y círculos así como se muestra a continuación:

Código:

#include <unistd.h>


#include <GL/gl.h>

#include <math.h>

int rad=100;

double ang=0,a=0,b=0,c=0,d=0,e=0,f=0,g=0;


{



glLoadIdentity();


}


{

int angulo=0;

glPointSize(t);

71


glBegin(GL_POINTS);

//glColor3f (1.0, 0.0, 1.0);

glVertex2f(x,y);

//glColor3f(0,0.0,0.0);


glEnd();

}


{

int angulo=0;


glVertex2f(x,y);

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

glEnd();

}

void dibuja(void)

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//esto

glBegin(GL_QUADS);//Cuadros fondo semaforo

glColor3f(0.2 , 0.6 , 0.);




72





glVertex2i(278,3);

glVertex2i(229,3);

glEnd();

glColor3f(0.0,0.0,0.0);//Luces Roja

circulo(247,226,34);

glColor3f(0.0,0.0,0.0);//Luces Amarrilla

circulo(247,302,34);

glColor3f(0.0,0.0,0.0);//Luces Verde

circulo(247,381,34);

a=a+1; //velocidad entre mas grande mas rapido y entre menos mas lento

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

if(a>1 && a<20){


circulo(247,381,34);

}// se repite idefinidamente

73


if(a>20 && a<40){


circulo(247,226,34);


if(a>40 && a<50){


circulo(247,302,34);


if(a>55 && a<50){


circulo(247,302,34);


if(a>60 && a<55){


circulo(247,302,34);


if(a>60){a=0;}



}

74



{





glutCreateWindow("Ventana");

inicializa();



glutMainLoop();

return 0;

}

75

Manual de Practicas de Open GL con Dev C++

Documents

Transcript of Manual de Practicas de Open GL con Dev C++