Manual de prácticas en OPEN GL Dev C

CECyTEM PLANTEL TECÁMAC

Manual de prácticas en OPEN GL “Dev
C++”

Alumnos: Belmonte Vargas Baruch Isaí
Ponce Serrano Carlos Andrés

Prof.: René Domínguez Escalona

Grupo: 303

Introducción.
En este manual se podrá apreciar algunas de las principales
funciones del lenguaje de programación de OPEN GL y así
se podrá aplicar para diseño gráfico, se mostraran
funciones principales o primitivas del programa para la
realización de objetos en el programa se verá desde lo más
básico hasta lo más avanzado como puede ser desde la
elaboración de un cuadro hasta la animación de un objeto
en 2D & 3D.

Índice.

1°- Tablero de Ajedrez

2°-Estrella

3°- Cubo con líneas

4°-Cubo delineado

5°-Muñeco con triángulos

6°-Piramide

7°-Casita

8°- Oso

9°-Cubo con Cubitos

10°-Muñeco con formas

11°-Animación circulo

12°- Nombre 3D

13°-Animación sistema solar

14°-Movimiento en ocho

15°-Semaforo

16°- Cubo 3D con líneas.

1° TABLERO DE AJEDREZ

En esta práctica aremos un tablero de ajedrez con cuadros unos negro y uno blanco de
8*8. La realizaremos con la primitiva GL_POINTS, comenzaremos por definir el color de
cada cuadro con glColor3f(0.0 , 0.0 , 0.0) que sería negro, luego el tamaño del punto
glPointSize(50) y en seguida anotaremos la primitiva ya mencionada
glBegin(GL_POINTS).

Luego de esto se pondrán las coordenadas glVertex2i(100,800); por ejemplo deberán de
ser 4 coordenadas para insertar un cuadro

glVertex2i(100,500);




y así lo haremos consecutivamente hasta lograr hacer el tablero indicado.

CODIGO:

void dibuja(void) //funcion dibuja

{

glClear(GL_COLOR_BUFFER_BIT); //borra pantalla

glColor3f(0.0 , 0.0 , 0.0);

glPointSize(50);

glBegin(GL_POINTS);





glColor3f(1.0 , 1.0 , 1.0);

glPointSize(50);

glBegin(GL_POINTS);





glColor3f(1.0 , 1.0 , 1.0);

glPointSize(50);

glBegin(GL_POINTS);





glColor3f(0.0 , 0.0 , 0.0);

glPointSize(50);

glBegin(GL_POINTS);





glColor3f(0.0 , 0.0 , 0.0);

glPointSize(50);

glBegin(GL_POINTS);





glColor3f(0.0 , 0.0 , 0.0);

glPointSize(50);

glBegin(GL_POINTS);





glColor3f(1.0 , 1.0 , 1.0);

glPointSize(50);

glBegin(GL_POINTS);





glColor3f(1.0 , 1.0 , 1.0);

glPointSize(50);

glBegin(GL_POINTS);





glColor3f(0.0 , 0.0 , 0.0);

glPointSize(50);

glBegin(GL_POINTS);





glColor3f(0.0 , 0.0 , 0.0);

glPointSize(50);

glBegin(GL_POINTS);





glColor3f(1.0 , 1.0 , 1.0);

glPointSize(50);

glBegin(GL_POINTS);





glColor3f(1.0 , 1.0 , 1.0);

glPointSize(50);

glBegin(GL_POINTS);





glColor3f(0.0 , 0.0 , 0.0);

glPointSize(50);

glBegin(GL_POINTS);





glColor3f(0.0 , 0.0 , 0.0);

glPointSize(50);

glBegin(GL_POINTS);





glColor3f(1.0 , 1.0 , 1.0);

glPointSize(50);

glBegin(GL_POINTS);





glColor3f(1.0 , 1.0 , 1.0);

glPointSize(50);

glBegin(GL_POINTS);





glColor3f(0.0 , 0.0 , 0.0);

glPointSize(50);

glBegin(GL_POINTS);





glEnd();

2° ESTRELLA

En esta práctica haremos una estrella a base de líneas con la primitiva glBegin(GL_LINES),
definiremos en tamaño de la línea y el color con:

glPointSize(10);

glColor3f(0.0 , 0.0 , 0.0);

y comenzaremos a anotar cada una de las coordenadas para así llegar a la forma de la estrella.

CODIGO:


{


glBegin(GL_LINES);

glPointSize(10);

glColor3f(0.0 , 0.0 , 0.0);



glBegin(GL_LINES);

glPointSize(10);

glColor3f(0.0 , 0.0 , 0.0);



glBegin(GL_LINES);

glPointSize(10);

glColor3f(0.0 , 0.0 , 0.0);



glBegin(GL_LINES);

glPointSize(10);

glColor3f(0.0 , 0.0 , 0.0);



glBegin(GL_LINES);

glPointSize(10);

glColor3f(0.0 , 0.0 , 0.0);



glEnd();

3° CUBO CON LÍNEAS

En esta práctica utilizaremos 2 primitivas glBegin(GL_QUADS) para hacer cuadros y
glBegin(GL_LINES); para hacer las líneas igual que practicas anteriores definiremos el color de
la línea o cuadro con glColor3f(1.0 , 0.0 , 0.0);.

Primero haremos la parte trasera del cubo para que se noten las líneas de enfrente y no estén
cubiertas por las demás líneas o cuadros.

Y de igual forma definiremos cada coordenada hasta lograr el cubo con líneas.

CODIGO:


{


glColor3f(0.0 , 0.0 , 0.0);

glPointSize(50);

glBegin(GL_LINES);

glVertex2i(200, 100);


glVertex2i(200, 100 );






















glEnd();

4°CUBO DELINEADO

Esta práctica la haremos como la práctica de CUBO CON LÍNEAS lo único que modificaremos será
el grosor de la línea con la instrucción glLineWidth(3) el tamaño de la línea será colocado dentro
del paréntesis y le modificaremos el color de cada lado para ver así la separación de cada lado.

CODIGO:


{


glLineWidth(5);

//enfrente

glBegin(GL_QUADS);

glColor3f(1.0 , 0.0 , 0.0);









//derecha

glColor3f(0.0 , 0.0 , 1.0);









//arriba

glColor3f(.0 , 1.0 , 0.0);









glEnd();

//enfrente

glLineWidth(5);

glBegin(GL_LINES);

glColor3f(0.0 , 0.0 , 0.0);









//derecha









//arriba









glEnd();

5°MUÑECO CON TRIÁNGULOS

En esta práctica haremos un muñeco utilizando una nueva primitiva glBegin(GL_TRIANGLES) y
también primitivas ya utilizadas antes.

Para esta instrucción se necesitan 3 coordenadas ya no 2 como en las instrucciones
glBegin(GL_QUADS) o glBegin(GL_LINES)

De igual forma trataremos de encontrar cada una de las coordenadas para lograr el dibujo a base
de triángulos y si es necesario ocuparemos otras primitivas.

Como en el caso del balón también se utiliza una nueva primitiva glBegin(GL_POLYGON) a
base de 8 coordenadas.

También utilizamos colores degradados. Estos se logran colocando la instrucción de color entre
las coordenadas y no solo poniéndole hasta arriba de cada grupo de coordenadas por ejemplo:

glColor3f(1.0 , 1.0 , 0.0);



glColor3f(1.0 , 1.0 , 1.0);

glVertex2i(360,80);

glVertex2i(360,60);

glVertex2i(340,40);

glVertex2i(320,40);

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(300,60);

glVertex2i(300,80);

CODIGO:


{


glPointSize(10);

//pasto

glBegin(GL_QUADS);

glColor3f(0.0 , 1.0 , 0.0);

glVertex2i(0,60);


glVertex2i(1000,0);

glVertex2i(0,0);

glEnd();

// pie izquierdo

glBegin(GL_TRIANGLES);

glColor3f(1.0 , 0.0 , 0.0);

glVertex2i(140,40);

glVertex2i(200,40);

glVertex2i(160,60);

//pie derecho

glColor3f(1.0 , 0.0 , 0.0);




glEnd();


glColor3f(1.0 , 0.0 , 1.0);

//pierna izquierda

glVertex2i(200,40);

glColor3f(1.0 , 1.0 , 1.0);



glEnd();

//muslo derecho


glColor3f(1.0 , 1.0 , 1.0);



glColor3f(1.0 , 0.0 , 1.0);


glEnd();


glColor3f(0.0 , 1.0 , 0.0);

//brazo izquierdo


glColor3f(1.0 , 0.0 , 1.0);



glEnd();


glColor3f(0.0 , 1.0 , 0.0);

//brazo derecho


glColor3f(1.0 , 0.0 , 1.0);



glEnd();


glColor3f(1.0 , 0.0 , 1.0);

//chamorro derecho




//mano izq


glVertex2i(60,240);

glVertex2i(80,280);

//mano derecha




//cabeza




glEnd();

//gorro


glColor3f(1.0 , 1.0 , 0.0);




glEnd();

//base trofeo


glColor3f(1.0 , 1.0 , 0.0);




//trofeo izq







//trofeo der







//trofeo




glEnd();

glBegin(GL_QUADS);

glColor3f(0.0 , 1.0 , 0.0);

//cuerpo





glEnd();

//cuello


glColor3f(1.0 , 0.0 , 1.0);




glEnd();

glBegin(GL_POLYGON);

glColor3f(1.0 , 1.0 , 0.0);

//balon



glColor3f(1.0 , 1.0 , 1.0);

glVertex2i(360,80);

glVertex2i(360,60);

glVertex2i(340,40);

glVertex2i(320,40);

glColor3f(1.0 , 1.0 , 0.0);

glVertex2i(300,60);

glVertex2i(300,80);

glEnd();

6° PIRAMIDE

Esta práctica la haremos con una nueva instrucción llamada FOR: for (i=0;i<=10;i++){ dentro de
ella podemos cambiar los valores, esta instrucción funciona para repetir alguna primitiva, ya sea
cuadros, líneas etc….

En esta ocasión la utilizaremos para repetir un cuadro pero que vaya aumentando su tamaño a
cierta distancia

La instrucción va antes de que empecemos a colocar las coordenadas, y pondremos la variable
dentro de las coordenadas, en este caso la variable es i y colocando esta variable hará la
instrucción for.

Por ejemplo:

glVertex2i(240-20*i,240-20*i);

glVertex2i(260+20*i,240-20*i);

El 240 en el valor de x, el -20 es la separación entre el cuadro y se multiplicara por i que es la
variable con la cual se efectuara el mismo cuadro.

Luego de Esto haremos las líneas diagonales para simular la pirámide vista desde arriba.

CODIGO:


{

int i;


glPointSize(10);

glColor3f(0.0 , 0.0 , 0.0);

glBegin(GL_LINES);

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

//ABAJO

glVertex2i(240-20*i,240-20*i);

glVertex2i(260+20*i,240-20*i);

//derecha

glVertex2i(260+20*i,240-20*i);

glVertex2i(260+20*i,260+20*i);

//izquierda

glVertex2i(240-20*i,240-20*i);

glVertex2i(240-20*i,260+20*i);

//ARRIBA

glVertex2i(240-20*i,260+20*i);

glVertex2i(260+20*i,260+20*i);

}

















glVertex2i(80, 80);

glVertex2i(60, 60);







glVertex2i(420,80);

glVertex2i(440,60);

glEnd();

7° CASITA.

Esta práctica es como un repaso de todas las primitivas e instrucciones vistas anteriormente. Para
lograr dicho dibujo empezaremos por hacer los objetos de atrás para delante para que se puedan
notar todas las figuras.

Por ejemplo primero haremos la cerca con la instrucción for y se haga repetitiva la figura y esta
figura será hecha con la primitiva POLYGON.

De igual forma ocuparemos for para los pinos, pero primero tenemos que hacer el pasto como ya
antes mencionamos haremos primero lo que se encuentra atrás.

Rejas, pasto, banqueta, calle, piedras y así sucesivamente, hasta llegar a los detalles de la casa
que serían las ultimas figuras que haremos.

CODIGO:

void dibuja(void)

{

int i,j=0;

/* borra la pantalla */

glClear(GL_COLOR_BUFFER_BIT);

//rejas

for(i=0;i<50;i++){

glBegin(GL_POLYGON);

glColor3f (2.0, 0.3, 0.0);

glVertex2f(0+20*i,292);





glEnd();

}

glBegin(GL_QUADS);

glVertex2i(0,289);



glVertex2i(0,280);

//pasto

glColor3f (0.0, 0.5, 0.0);

glVertex2i(0,240);



glVertex2i(0,120);

//banqueta

glColor3f (0.6, 0.6, 0.6);

glVertex2i(0,120);



glVertex2i(0,90);

glColor3f (1.0, 1.0, 0.0);

glVertex2i(0,90);



glVertex2i(0,82);

//calle

glColor3f (0.3, 0.3, 0.3);

glVertex2i(0,82);


glVertex2i(1000,0);

glVertex2i(0,0);

//piedras

glColor3f (0.6, 0.6, 0.6);

















//entrada





// Casa

glColor3f (0.2, 0.5, 1.0);





// Techo casa

glColor3f (0.7, 0.6, 1.0);





// Techo cochera

glVertex2i(75,345);



glVertex2i(60,315);

//Cortina

glColor3f (0.9, 0.9, 0.9);

glVertex2i(90,315);



glVertex2i(90,195);

//Puerta

glColor3f (1.0, 1.0, 1.0);





//Columnas

glColor3f (0.0, 1.0, 1.0);

glVertex2i(75,315);

glVertex2i(90,315);

glVertex2i(90,195);

glVertex2i(75,195);













//Ventanas izq

glColor3f (0.8, 0.8, 1.0);









//Ventanas der









//Ventanas balcon





//Ventanas puerta





//Tallos

glColor3f (0.6, 0.4, 0.2);









glEnd();


// Techo balcon

glColor3f (0.7, 0.3, 1.0);




glEnd();

//arboles

glLineWidth (4);

glBegin(GL_LINES);

glColor3f (0.0, 0.7, 0.0);

for(i=0;i<32;i++){

glVertex2i(680-3*i,540-10*j);

glVertex2i(690+3*i,540-10*j);

glVertex2i(685-3*i,535-10*j);

glVertex2i(695+3*i,535-10*j);

glVertex2i(885-3*i,540-10*j);

glVertex2i(895+3*i,540-10*j);

glVertex2i(890-3*i,535-10*j);

glVertex2i(900+3*i,535-10*j);

j=j+1;

}

glEnd();

//Linea Calle

glLineWidth (4);

glColor3f (1.0, 1.0, 1.0);

glBegin(GL_LINES);

for(i=0;i<50;i++){

glVertex2i(0+120*i,41);


}

//Barandal



for(i=0;i<7;i++){



}

//Divicion Ventana



















glEnd();

//Contorno ventanas

glBegin(GL_LINE_LOOP);





glEnd();






glEnd();






glEnd();






glEnd();

//Chapa

glPointSize(4);

glColor3f (0.0, 0.0, 0.0);

glBegin(GL_POINTS);



glEnd();

8°- Oso

Esta practica la logramos hacer por medio de una nueva instruccion, la instruccion la
llamaremos circulo.

Para lograr esto incluiremos la paqueteria #include <math.h> para que formule nuestras
operaciones matematicas.

nuestras instrucción se llamara circuloc devido a que solo será la circunferencia

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

}

y con circulo haremos un circulo con area

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

}

Y así juntaremos las coordenadas hasta lograr hacer un oso.

CODIGO:


{

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

glVertex2f(x,y);


glEnd();

}


{

glClear(GL_COLOR_BUFFER_BIT);

//panza

glColor3f(0.6,0.4,0.2); //borra pantalla

circulo(280,200,100);

glColor3f(0.7,0.5,0.4);

circulo(280,200,60);

//pie izq

glColor3f(0.6,0.4,0.2);

circulo(190,100,40);

glColor3f(0.7,0.5,0.4);

circulo(190,100,20);

//pie der

glColor3f(0.6,0.4,0.2);

circulo(370,100,40);

glColor3f(0.7,0.5,0.4);

circulo(370,100,20);

//mano derecha

glColor3f(0.6,0.4,0.2);

circulo(390,280,40);

glColor3f(0.7,0.5,0.4);

circulo(390,280,20);

//mano izq

glColor3f(0.6,0.4,0.2);

circulo(170,280,40);

glColor3f(0.7,0.5,0.4);

circulo(170,280,20);

//cabeza

glColor3f(0.6,0.4,0.2);

circulo(280,350,60);

//oreja izq

glColor3f(0.6,0.4,0.2);

circulo(220,400,20);

glColor3f(0.7,0.5,0.4);

circulo(220,400,10);

//oreja dere

glColor3f(0.6,0.4,0.2);

circulo(340,400,20);

glColor3f(0.7,0.5,0.4);

circulo(340,400,10);

//ojo izq

glColor3f(1.0,1.0,1.0);

circulo(260,370,20);

glColor3f(0.0,0.5,0.4);

circulo(260,370,5);

//ojo der

glColor3f(1.0,1.0,1.0);

circulo(300,370,10);

glColor3f(0.0,0.5,0.4);

circulo(300,370,5);

//nariz

glColor3f(0.0,0.0,0.0);

circulo(280,340,10);

glEnd();

glBegin(GL_LINES);

glColor3f(0.0,0.0,0.0);





glEnd();

9°-Cubo con Cubitos

Esta practica esta un poco complicada devido a que utilizaremos una funcion for pero
multiplicaremos todo un cubo. para arriba a los lados creando solo el prerimetro de uno
más grande pero tenemos que tomar en cuenta los cubos que ya estan hechos para que
no se deformen o salga una linea más grande que otra.

10°-Muñeco con formas.

Este muñeco es facil de hacer ya que utilizaremos todas las primitivas he instruciones ya
vistas pero las uniremos y cambiaremos su color.

11°-Animación circulo

Haremos que un circulo se mueva alrededor de la pantalla con una instruccion nueva.

CODIGO:

void circulo

(int x, int y, int radio)

{

int angulo=0;


glColor3f (0.12, 0.48, 0.62);

glVertex2f(x,y);

glColor3f(0.20,0.84,0.23);

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

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

circulo(100+x,100,40);

glFlush();

x++;

}

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

circulo(700,100+y,40);

glFlush();

y++;

}

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

circulo(700-z,700,40);

glFlush();

z++;

}

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

circulo(100,700-i,40);

glFlush();

i++;

if(i==600){i=1;z=1;x=1; y=1;}

}

glutSwapBuffers();

12°- Nombre 3D
Este nombre se hará a base se cubitos se ira poniendo uno tras otro, aquí las coordenadas
cambiaran, cada que se haga un cubo ese cubo tendra las coordenadas 0,0 y al ultimo
solo modificaremos los colores.

CODIGO:

void mover(void){

glTranslated(0,0,zoom);

glRotated(girax,1.0,0.0,0.0);

glRotated(giray,0.0,1.0,0.0);

}

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

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

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

13°-Animación sistema solar.

Esta animacion se podra hacer por medio de un movimiento del circulo pero circular.

comenzaremos por definir el sol, y aspi susecivamente hasta hacer todos los planetas le
modificaremos el color y la hubicacion de hacia donde dará la vuelta.

CODIGO:


{

int angulo=0;


//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 +

glEnd();

}


{

int angulo=0;

glPointSize(t);

glBegin(GL_POINTS);

glVertex2f(x,y);


glEnd();

}

void dibuja(void)

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//esta

glColor3f (1.0,1.0,1.0);

circuloc(1000,1000,1,150);

circuloc(1000,1000,1,250);

circuloc(1000,1000,1,350);

circuloc(1000,1000,1,450);

circuloc(1000,1000,1,570);

circuloc(1000,1000,1,690);

circuloc(1000,1000,1,820);

circuloc(1000,1000,1,930);

//Sol

glColor3f (1.0, 1.0, 0.0);

circulo( 1000,1000,100); //funcion circulo

glEnd();

//Mercurio

glColor3f (0.65, 0.93, 0.69);

circulo( 1000+ sin(ang) * 150,1000 + cos(ang) * 150,25);

ang==ang+0.05;

glEnd();

//Venus

glColor3f (0.50, 0.0, 1.0);

circulo( 1000- sin(ang) * 250,1000 - cos(ang) * 250,30);

ang==ang+0.01;

glEnd();

//Tierra

glColor3f (0.0, 0.0, 0.19);

circulo( 1000 + sin(ang) * 350,1000 - cos(ang) * 350,40);

ang==ang+0.01;

glEnd();

//Marte

glColor3f (1.0, 0.30, 0.0);


ang=ang+0.01;

glEnd();

//Jupiter

glColor3f (0.72, 0.19, 0.34);


ang=ang+0.01;

glEnd();

//Saturno

glColor3f (1.0, 0.0, 0.0);


ang=ang+0.01;

glEnd();

//Urano

glColor3f (0.0, 1.0, 1.0);


ang=ang+0.01;

glEnd();

//Neptuno

glColor3f (0.08, 0.67, 0.83);

circulo( 1000- sin(ang) * 930,1000 + cos(ang) * 930,20);

ang=ang+0.003;

glEnd();

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

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

glFlush(); //forzar dibujado

glutSwapBuffers(); //y esto

}

14°-Movimiento en ocho

Esta practica la haremos haciendo 4 circulos 2 seran solo la circunferencia y los
pondremos pegados, los otros 2 seran con area y los pondremos encima de modo que se
de la forma de un 8, haremos un circulo más pequeño que recorrera la circunferencia de
los primeros 2 circulos. Y así su recorrido será continuo.

CODIGO:

15°-Semaforo.

El objetivo de este será hacer la simulacion de un semaforo, dibujremos la estructura de
un semaforo normal y haremso que prenda de rojo a verde de verde a amarillo y a rojo,
y así sucesivamente.

CODIGO:


{

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;


glVertex2f(x,y);

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

glEnd();

}

void dibuja(void)

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//esto

glBegin(GL_QUADS);//Cuadros fondo semaforo

glColor3f(0.2 , 0.2 , 0.0);







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

// se repite idefinidamente

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


circulo(247,226,34);

}

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


circulo(247,226,34);

}

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


circulo(247,226,34);


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


circulo(247,302,34);


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

glFlush(); //forzar dibujado

glutSwapBuffers(); //y esto

}

16°- Cubo 3D con líneas.

Este cubo se lograra hacer con una malla, y con la intervencion del teclado la malla se
multiplicara y hará un cubo. y se podra mover con el teclado.

De igual forma tedra teclas para hacer un zoom.

CODIGO:

void mover(void){

glTranslated(0,0,zoom);

glRotated(girax,1.0,0.0,0.0);

glRotated(giray,0.0,1.0,0.0);

}

void creaMalla(void){

int i, long_eje=10,j;

glColor3f(1.0,1.0,0.0);

glBegin(GL_LINES);

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

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

glVertex3f(j,-long_eje,i);

glVertex3f(j,long_eje,i);

glVertex3f(-long_eje,j,i);

glVertex3f(long_eje,j,i);

glVertex3f(j,i,-long_eje);

glVertex3f(j,i,long_eje);

glVertex3f(-long_eje,j,i);

glVertex3f(long_eje,j,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);

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

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

}

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

glLightfv(GL_LIGHT0,GL_DIFFUSE,(GLfloat []){0.0f,2.0f,2.0f,1.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);

glPopMatrix ();

glFlush();

glutSwapBuffers ();

//anguloEsfera+=2.0f;

}

void reshape(int w, int h){

glClearColor(1.0,1.0,1.0,0.0);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

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

glMatrixMode(GL_MODELVIEW);

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':


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+=3;

break;

case GLUT_KEY_RIGHT:

giray-=3;

break;

case GLUT_KEY_UP:

girax-=3;

break;

case GLUT_KEY_DOWN:

girax+=3;

break;

default: break;

}


Manual de prácticas en OPEN GL Dev C

Manual de prácticas en OPEN GL Dev C

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a Manual de prácticas en OPEN GL Dev C

Semelhante a Manual de prácticas en OPEN GL Dev C (20)

Mais de Pachoon Vargas

Mais de Pachoon Vargas (8)

Último

Último (20)

Manual de prácticas en OPEN GL Dev C