1. 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
2. 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.
3. 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
4. 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);
8. 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
9.
10. 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)
{
11. 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);
13. 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
}
15. CUBO CON LINEAS
Este cubo se realizara mediante líneas para que lo formaran en tresd.
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);
16. // 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);
17. 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
18. 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
19. 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);
22. 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
23. 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
24. 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
25. 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
34. 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
35.
36. 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)
{
42. 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);
43. 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);
44. 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
53. //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);
54. 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
55. glutMainLoop(); //muestra todo y espera
return 0; //retorna un valor de cero
}
SALIDA
56. 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)
57. {
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);
61. }
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
62. 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
63. 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
67. //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);
68. }
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
}
70. 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
71. #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)
86. 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
87. 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;
88. 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
89. 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;
}
90. 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>
91. #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
92. 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;
}
93. 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>
94. #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);
98. 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);
99. 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();
}
104. 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);
109. 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