Estela y naye

COLEGIO DE ESTUDIOS CIENTIFICOS Y
TECNOLOGICOS DEL ESTADO DE
MEXICO

Nombre del profesor: Rene Domínguez Escalona

Nombre de los integrantes:

• Estela Elizabeth Mendoza González

• Nayely Sugey Mejía García

Trabajo: Manual de practicas

Grado: 3° Semestre

Grupo: 303

Materia: Utilización de software de diseño para el manejo de
gráficos.

1

INDICE
Introduccion sobre Open_GL……………………..3

Código del movimiento circular…………………..8

Tablero de ajedrez……………………………………9

Estrella…………………………………………………..17

Cubo con lineas……………………………………20

Cubo delineado…………………………………24

Muñeco con triángulos……………………………29

Casita…………………………………………………..37

Oso……………………………………………………..55

Cubo con cubitos…………………………………..58

Muñeco con formas………………………………..62

Animación circulo rotando……………………….68

Animación sistema solar……………………………71

Movimiento ocho…………………………………...74

Piramide………………………………………77

Semáforo……………………………………………..80

Nombre en 3D………………………………………85

Cubo en 3D………………………………………….91

2

INVESTIGACION SOBRE
Open_GL:
¿Qué es Open_GL?

R= Es una especificación estándar que define una API
Multilenguaje y multiplataforma para escribir aplicaciones que
produzcan gráficos en 2D y 3D.

¿Cuáles son las primitivas geométricas?

R=Formas geométricas por su básica constitución en las partes
que la conforman se conoces también con el nombre de
primitivas geométricas cuyas formas son:

GL_POINTS Dibuja puntos.

GL_LINES Dibuja líneas no conectadas.

GL_TRIANGLES Dibuja una serie de triángulos.

GL_QUADS Dibuja una serie de cuadriláteros.

GL_TRIANGLE_FAN Dibuja triángulos pegados unos con otros en
forma de abanico.

¿Cómo se crea una ventana en Open:GL?

R=Los paso necesarios para crear una ventana en Open:GL, los
podemos clasificar como sigue:

• Creamos una ventana

• Establecemos de manera de visión y la perspectiva

• Inicializamos la variable del estado de Open_GL

3

• Crea Ventana GL: Se puede considerar como la función
principal. Crea una ventana de Windows, selecciona el

Formato de pixel, crea su RC y DC y posteriormente llama
a las funciones siguientes para asignarle propiedades

de OpenGL.

• Elimina Ventana GL: Libera todos los recursos usados por la
ventana.

• Inicializa Escena GL: Establece el marco de visión
(Viewport) de la escena, así como la perspectiva que
vamos a Utilizar.

¿Qué es el GLVector?

R= En OpenGL los objetos los definimos como un conjunto
ordenado de vértices. Para especificar un vértice disponemos
del comando glVertex*(); void glVertex{234}{sifd} (TYPE coords);

Especifica un vértice para el uso en la descripción de un objeto
geométrico. El número de coordenadas puede ser de 2 (x,y), 3
(x,y,z) y 4 (x,y,z,w). Si se usa una versión en la que no se
especifica z o w, será entendido que a z se le asigna el valor 0 y
a w el valor 1.

¿Aplicaciones de Open_GL?

• Codificación del Color en modos RGBA (Rojo-Verde-Azul-
Alfa) o de color indexado.
4

• Visualización y Modelado que permite disponer objetos en
una escena tridimensional, mover nuestra cámara por el
espacio y seleccionar la posición ventajosa deseada para
visualizar la escena de composición.

• Mapeado de texturas que ayuda a traer realismo a
nuestros modelos por medio del dibujo de superficies
realistas en las caras de nuestros modelos poligonales

• La iluminación de materiales es una parte indispensable de
cualquier gráfico 3D. OpenGL provee de comandos para
calcular el color de cualquier punto dadas las propiedades
del material y las fuentes de luz en la habitación.

• El sombreado Gouraud es una técnica usada para aplicar
sombreados suaves a un objeto 3D y producir una sutil
diferencia de color por sus superficies.

• Efectos atmosféricos como la niebla, el humo y las neblinas
hacen que las imágenes producidas por ordenador sean
más realistas. Sin efectos atmosféricos las imágenes
aparecen a veces irrealmente nítidas y bien
definidas. Niebla es un término que en realidad describe
un algoritmo que simula neblinas, brumas, humo o polución
o simplemente el efecto del aire, añadiendo profundidad
a nuestras imágenes.

¿Cuáles son las tres librerías?

R=

• Glut.h

• Math-h

• Stdlib.h

5

¿Qué funciones tienen las librerías?

R= Las librerías disponen de utilidades o funciones para entrada
o salida implementadas en el propio lenguaje, son utilizados
para el programador.

¿Cómo configurar Opengl en Dev c++?

R= OpenGL (Open Graphics Library): Es una API estándar para el
manejo de gráficos en 2 y 3 dimensiones independiente de la
plataforma. Es estructurado y está escrito en C. OpenGL tiene
funciones para renderizado en 2 y 3 dimensiones, rotación,
traslación, pintado, etc. Pero OpenGL NO provee métodos para
creación de ventanas manejo de dispositivos como teclado,
ratón, etc. OpeGL está definido en los archivos de cabecera y ,
los cuales están incluidos en la mayoría de compiladores.

* GLUT: (OpenGL Utility Toolkit): Ante la incapacidad de OpenGL
para crear controles gráficos como ventanas y manejar
dispositivos Mark Kilgard's desarrolló GLUT la cual es una librería
auxiliar a OpenGL que permite crear ventanas y manejar
dispositivos como el teclado y ratón y está diseñada para
integrarse completamente con OpenGL. Esta librería es
multiplataforma y tiene versiones para Windows, Linux y otros.

Así que para empezar a trabajar tenemos que bajar Dev-C++
de Aquí e instalarlo, este trae a OpenGL por defecto, pero para
además trabajar con GLUT necesitamos bajar el siguiente Dev-
Package de (elegimos glut.3.7.6+.DevPak), abrimos Dev-C++
vamos a Herramientas -> Package Manager, nos saldrá una
nueva ventana y daremos click en el botón Install,
seleccionamos el paquete y lo instalamos. Luego de esto ya

6

podremos ir a Nuevo Proyecto -> Multimedia -> glut y creamos
un nuevo proyecto. Este nos creará un demo del uso de glut
con OpenGL. Si lo compilamos y ejecutamos tendremos el
siguiente resultado:

CODIGO DEL MOVIMIENTO CIRCULAR:

• Primero haces un GLPlushMatrix, para guardar la matriz de
rotatraslacion.

• Luego haces un GLTranslate con las coordenadas de tu
zeppelín a continuación un GLRotate con sus ángulos.

• Luego lo dibujas.

• Por ultimo restauras la matriz.

•

GLPlushMatrix();

GLTranslate( posición del circulo);

GLRotate(rotación del circulo);

Circulo();

GLpopMatriz();

7

TABLERO DE AJEDREZ

Descripción: Lo que tenemos que hacer es un tablero de
ajedrez no importa los colores, este tablero debe de ser de 8x8.

Borrador:

8

Código:

void inicializa(void)

{

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

glMatrixMode(GL_PROJECTION); //Modo de proyección

glLoadIdentity(); //Establece los parámetros de
proyección

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

}

void dibuja(void) //función dibuja

{

glClear(GL_COLOR_BUFFER_BIT); //borra pantalla

glColor3f(0.0 ,0.0 ,1.0);

glPointSize(50);

glBegin (GL_POINTS);

glVertex2i(100,100);


9



glColor3f(0.0 ,0.0 ,0.0);

glPointSize(50);






glColor3f(0.0 ,0.0 ,1.0);

glPointSize(50);






glColor3f(0.0 ,0.0 ,0.0);

glPointSize(50);


10





glColor3f(0.0 ,0.0 ,1.0);

glPointSize(50);






glColor3f(0.0 ,0.0 ,0.0);

glPointSize(50);






glColor3f(0.0 ,0.0 ,1.0);

11

glPointSize(50);






glColor3f(0.0 ,0.0 ,0.0);

glPointSize(50);






glColor3f(0.0 ,0.0 ,1.0);

glPointSize(50);






12

glColor3f(0.0 ,0.0 ,0.0);

glPointSize(50);






glColor3f(0.0 ,0.0 ,1.0);

glPointSize(50);






glColor3f(0.0 ,0.0 ,0.0);

glPointSize(50);




13



glColor3f(0.0 ,0.0 ,1.0);

glPointSize(50);






glColor3f(0.0 ,0.0 ,0.0);

glPointSize(50);






glColor3f(0.0 ,0.0 ,0.0);

glPointSize(50);



14




glColor3f(0.0 ,0.0 ,1.0);

glPointSize(50);






glEnd();

glFlush(); //forza dibujo

Como quedo al final

15

Estrella

Descripción: Lo que tenemos que hacer es una estrella con
líneas no importa el tamaño de la estrella.

Borrador

16

Código:

void dibuja(void) //funcion dibuja

{


glColor3f(0.0 , 0.0 , 1.0);

glBegin(GL_LINES);











glEnd();

17


}

Como quedo

18

Cubo con líneas

Descripción: Tenemos que realizar un cubo echo de líneas de
manera que se pueda visualizar todo completo.

Borrador:

19

Código:


{


glColor3f(0.0 , 0.0 , 0.0);

glLineWidth(4);

glBegin(GL_LINES);










20
















glEnd();


}

21

CUBO DELINEADO

Descripción: Tenemos que realizar un cubo per que el contorno
se vea y debe de estar relleno de manera que se pueda
visualizar tres caras.

Borrador:

23

Código:

void dibuja(void) //función dibuja

{


glBegin(GL_QUADS);

// parte de frente

glColor3f(1.0,0.0,0.0);


glColor3f(1.0,0.0,0.0);


glColor3f(1.0,0.0,0.0);


glColor3f(1.0,0.0,0.0);


// parte de lado

glColor3f(0.0,1.0,0.0);


24

glColor3f(0.0,1.0,0.0);


glColor3f(0.0,1.0,0.0);


glColor3f(0.0,1.0,0.0);


// parte de arriba

glColor3f(0.0,0.0,1.0);


glColor3f(0.0,0.0,1.0);


glColor3f(0.0,0.0,1.0);


glColor3f(0.0,0.0,1.0);


glEnd();

glLineWidth(5);

glBegin(GL_LINES);

glColor3f(0.0,0.0,0.0);




25





















26


glEnd();


}

Resultado:

27

Muñeco con triangulos

Descripción: Tenemos que realizar un muñeco echo por puros
triángulos de manera que se vea la forma del dibujo.

Borrador:

28

Código:


{


glColor3f(1.0 , 0.0 , 0.0);

// triangulo de la cabeza

glBegin(GL_TRIANGLES);

glColor3f(0.0,0.0,1.0);


glColor3f(0.0,0.0,1.0);


glColor3f(0.0,0.0,1.0);


//triangulo de la cabeza 2

glColor3f(0.0,1.0,0.0);


glColor3f(0.0,1.0,0.0);


glColor3f(0.0,1.0,0.0);


29

//triangulo pequeño del cuerpo

glColor3f(0.0,0.0,0.0);


glColor3f(0.0,0.0,0.0);


glColor3f(0.0,0.0,0.0);


// triangulos de la mano izquierda

glColor3f(1.0,0.0,0.0);


glColor3f(1.0,0.0,0.0);


glColor3f(1.0,.0,0.0);

glVertex2i(50,400);

glColor3f(0.0,1.0,0.0);

glVertex2i(50,400);

glColor3f(0.0,1.0,1.0);

glVertex2i(0,450);

glColor3f(1.0,1.0,0.0);

glVertex2i(0,350);

// triangulos de la mano derecha

30

glColor3f(0.0,0.0,1.0);


glColor3f(0.0,0.0,1.0);


glColor3f(0.0,0.0,1.0);


glColor3f(1.0,0.0,0.0);


glColor3f(1.0,0.0,0.0);


glColor3f(1.0,0.0,0.0);


// triangulos de la pierna y pie izquierdo

glColor3f(1.0,0.0,1.0);


glColor3f(1.0,0.0,0.0);


glColor3f(0.0,1.0,1.0);


glColor3f(1.0,1.0,0.0);

31


glColor3f(1.0,0.0,1.0);


glColor3f(1.0,1.0,1.0);


// triangulos de la pierna y pie derecho

glColor3f(1.0,1.0,0.0);


glColor3f(1.0,0.0,1.0);


glColor3f(0.0,1.0,1.0);


glColor3f(0.0,0.0,1.0);


glColor3f(0.0,1.0,0.0);


glColor3f(0.0,0.0,0.0);


glColor3f(1.0,1.0,0.0);


32

glColor3f(1.0,0.0,1.0);


glColor3f(0.0,1.0,1.0);


glEnd();

// cuerpo del muñeco

glBegin(GL_QUADS);

glColor3f(1.0,1.0,0.0);


glColor3f(1.0,0.0,1.0);


glColor3f(0.0,1.0,1.0);


glColor3f(0.0,1.0,1.0);


// balon

glBegin(GL_QUADS);

glColor3f(1.0,1.0,0.0);


glColor3f(1.0,0.0,1.0);


glColor3f(0.0,1.0,1.0);

33


glColor3f(0.0,1.0,1.0);


// balon 2

glBegin(GL_QUADS);

glColor3f(1.0,0.0,0.0);


glColor3f(.0,0.0,1.0);

glVertex2i(650,50);

glColor3f(0.0,1.0,0.0);

glVertex2i(700,50);

glColor3f(1.0,0.0,0.0);


glEnd();


}

Resultado:

34

Casita

Descripción: Tenemos que realizar una casa con todas las
figuras geométricas.

Borrador:

Código:


36

{


glBegin(GL_QUADS);

// calle

glColor3f(0.0,0.0,0.0);

glVertex2i(0,0);

glVertex2i(1000,0);


glVertex2i(0,100);

//guarnicion

glColor3f(1.0,1.0,0.0);

glVertex2i(0,100);



glVertex2i(0,150);

// gris

glColor3f(1.0,0.0,1.0);

glVertex2i(0,150);



glVertex2i(0,200);

// pasto

37

glColor3f(0.0,1.0,0.0);

glVertex2i(0,200);



glVertex2i(0,450);

// parte de la casa (anaranjado)

glColor3f(1.0,0.0,0.0);



glColor3f(1.0,1.0,0.0);



// parte de la casa (gris)

glColor3f(1.0,1.0,1.0);



glColor3f(1.0,1.0,1.0);



// parte de la casa (roja)

glColor3f(1.0,0.0,0.0);

glVertex2i(50,600);

38




// parte de la casa (anaranjada)

glColor3f(1.0,0.0,0.0);



glColor3f(1.0,1.0,0.0);



// parte de la casa1 (rosa)

glColor3f(1.0,0.0,1.0);






glColor3f(1.0,0.0,1.0);





39


glColor3f(1.0,0.0,0.0);





// parte de la casa (roja)

glColor3f(1.0,0.0,0.0);





// parte de la casa (rosa)

glColor3f(1.0,0.0,1.0);





// puerta (blanca)

glColor3f(1.0,1.0,1.0);



40



// puesta pequeña (azul)

glColor3f(0.0,0.0,1.0);





// chapa

glColor3f(0.0,0.0,0.0);





// ventasnas 1 y 2

glColor3f(0.0,0.0,0.0);





glColor3f(0.0,0.0,0.0);

41





//ventanas 3 y 4

glColor3f(0.0,0.0,0.0);





glColor3f(0.0,0.0,0.0);





// ventanas 5 y 6

glColor3f(0.0,0.0,0.0);





42

// ventana 7 y 8

glColor3f(0.0,0.0,0.0);





// ventanas 9 y 10

glColor3f(0.0,0.0,0.0);





// linea de las ventanas 9 y 10

glColor3f(1.0,1.0,1.0);





glEnd();

glLineWidth(5);

glBegin(GL_LINES);

glColor3f(1.0,1.0,1.0);

43

// lineas de la calle

glColor3f(1.0,1.0,1.0);

glVertex2i(0,50);

glVertex2i(50,50);

glColor3f(1.0,1.0,1.0);

glVertex2i(100,50);

glVertex2i(200,50);

glColor3f(1.0,1.0,1.0);

glVertex2i(250,50);

glVertex2i(350,50);

glColor3f(1.0,1.0,1.0);

glVertex2i(400,50);

glVertex2i(500,50);

glColor3f(1.0,1.0,1.0);

glVertex2i(550,50);

glVertex2i(650,50);

glColor3f(1.0,1.0,1.0);

44

glVertex2i(700,50);

glVertex2i(800,50);

glColor3f(1.0,1.0,1.0);

glVertex2i(850,50);

glVertex2i(950,50);

// lineas de la ventana 1

glLineWidth(7);

glColor3f(1.0,1.0,1.0);










glLineWidth(7);

glColor3f(1.0,1.0,1.0);



45








glLineWidth(7);

glColor3f(1.0,1.0,1.0);










glLineWidth(7);

glColor3f(1.0,1.0,1.0);



46







// lineas de la ventana 5 y 6

glLineWidth(7);

glColor3f(1.0,1.0,1.0);











// lineas de la ventana 7 y 8


47










glEnd();

glBegin(GL_QUADS);

glColor3f(0.6,0.5,0.4);





glEnd();

glLineWidth(3);

glBegin(GL_LINES);

glColor3f(0.0,0.5,0.1);


48












glEnd();

glBegin(GL_QUADS);

glColor3f(0.7,0.1,0.5);

glVertex2i(100,50);

glVertex2i(300,50);


49






glColor3f(0.0,0.0,0.0);





glEnd();

glBegin(GL_QUADS);

glColor3f(0.0,0.2,0.4);

glVertex2i(700,50);







50


glEnd();


}

Resultado:

51

Oso

Descripción: Tenemos que realizar un oso con círculos de
diferentes tamaños.

Borrador:

Código:

52


{

glClear(GL_COLOR_BUFFER_BIT);

glColor3f(0.0,0.0,0.0); //borra pantalla

//cuerpo

circulo(250,250,100);

//patitas

circulo(160,175,60);

circulo(340,175,60);

//bracito

circulo(160,325,50);

circulo(340,325,50);

//cabeza

circulo(250,400,70);

//orejas

circulo(215,470,20);

circulo(280,470,20);

glColor3f(1.0,1.0,1.0);

//ojos

circulo(220,430,10);

circulo(275,430,10);

//panza

53

circulo(250,250,50);

//boca

circulo(250,380,20);

glFlush();

Resultado:

54

Cubitos con cubos

Descripción: Tenemos que realizar un cubo echo por cubitos en
3D de manera que los cubitos sean el delineado para formar un
cubo mas grande.

Borrador:

Código:


55

{


glColor3f(0.4 , 0.1 , 0.4);

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

56

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

57

}

glFlush();

Resultado:

58

Muñeco con formas

Descripción: Tenemos que realizar un muñeco del cecytem con
todas las primitivas que hemos visto.

Borrador:

Código:


59

{


glColor3f(1.0 , 0.0 , 0.0);

// triangulo de la cabeza


glColor3f(0.0,0.0,1.0);


glColor3f(0.0,0.0,1.0);


glColor3f(0.0,0.0,1.0);


//triangulo de la cabeza 2

glColor3f(0.0,1.0,0.0);


glColor3f(0.0,1.0,0.0);


glColor3f(0.0,1.0,0.0);


//triangulo pequeño del cuerpo

glColor3f(0.0,0.0,0.0);


glColor3f(0.0,0.0,0.0);

60


glColor3f(0.0,0.0,0.0);


// triangulos de la mano izquierda

glColor3f(1.0,0.0,0.0);


glColor3f(1.0,0.0,0.0);


glColor3f(1.0,.0,0.0);

glVertex2i(50,400);

glColor3f(0.0,1.0,0.0);

glVertex2i(50,400);

glColor3f(0.0,1.0,1.0);

glVertex2i(0,450);

glColor3f(1.0,1.0,0.0);

glVertex2i(0,350);

// triangulos de la mano derecha

glColor3f(0.0,0.0,1.0);


glColor3f(0.0,0.0,1.0);


61

glColor3f(0.0,0.0,1.0);


glColor3f(1.0,0.0,0.0);


glColor3f(1.0,0.0,0.0);


glColor3f(1.0,0.0,0.0);


// triangulos de la pierna y pie izquierdo

glColor3f(1.0,0.0,1.0);


glColor3f(1.0,0.0,0.0);


glColor3f(0.0,1.0,1.0);


glColor3f(1.0,1.0,0.0);


glColor3f(1.0,0.0,1.0);


glColor3f(1.0,1.0,1.0);

62


// triangulos de la pierna y pie derecho

glColor3f(1.0,1.0,0.0);


glColor3f(1.0,0.0,1.0);


glColor3f(0.0,1.0,1.0);


Resultado:

63

Animación circulo

Descripción: Tenemos que realizar una animación de un circulo
que valla recorriendo la pantalla.

Borrador:

Código:

void dibuja(void)

64

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

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

circulo(100+x,100,40);

glFlush();

x++;

}

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

circulo(600,100+y,40);

glFlush();

y++;

}

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

circulo(600-z,600,40);

glFlush();

z++;

}

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

circulo(100,600-k,40);

glFlush();

k++;

if(k==500){ x=1, y=1, k=1, z=1; }

65

}

glutSwapBuffers();

}

Resultado:

66

Animacion sistema

Descripción: Tenemos que realizar el sistema solar de manera
que los planetas vallan girando.

Borrador:

68

Código:

void dibuja(void)

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//esto

glColor3f(1.0,0.9,0.0);

circulo( 500,500,20);

glColor3f(1.0,0.0,0.0);

circuloc(500,500,2,50);

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

glColor3f(0.0,0.0,1.0);

circuloc(500,500,2,150);

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

glColor3f(0.0,1.0,0.0);

circuloc( 500,500,2,100);

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

glColor3f(0.0,1.0,1.0);

circuloc( 500,500,2,150);

circulo( 500+ sin(e) * 150,500 + cos(e) * 150,15);

glColor3f(0.9,0.0,0.4);

69

circuloc( 500,500,2,200);

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

glColor3f(0.4,0.7,0.5);

circuloc( 500,500,2,250);

circulo( 500+ sin(g) * 250,500 + cos(g) * 250,13);

glColor3f(0.7,0.7,0.4);

circuloc( 500,500,2,300);

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

glColor3f(0.2,0.1,4.0);

circuloc( 500,500,2,300);

circulo( 500+ sin(a) * 300,500 + cos(a) * 300,25);

glColor3f(0.0,0.6,0.4);

circuloc( 500,500,2,350);

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

glColor3f(0.4,0.1,0.2);

circuloc( 500,500,2,400);

circulo( 500+ sin(r) * 400,500 + cos(r) * 400,20);

c+=0.02;

d+=0.03;

e+=0.04;

f+=0.07;

g+=0.09;

70

h+=0.02;

a+=0.05;

n+=0.08;

r+=0.04;

ang=ang+0.1; //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

}

Resultado:

71

Movimiento ocho

Descripción: Tenemos que realizar un acho pero que alrededor
valla girando un círculo.

Borrador

72

Código:

void dibuja(void)

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//esto

glColor3f (1.0, 1.0, 0.0);//primer circulo

circulo(500,500,150);

glColor3f (0.0, 0.0, 0.0);

circulo(500,500,100);

glColor3f (1.0, 1.0, 0.0);// segundo circulo

circulo(500,750,150);

glColor3f (0.0, 0.0, 0.0);

circulo(500,750,100);

//bolitas

glColor3f (1.0, 0.0, 0.0);

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

circulo(500 -sin(a) * 125,500 +cos(a) * 125,20);

a=a+0.09;

}

else{

73

circulo(500 -sin(b)* 125,750 +cos(b)* -125,20);

b=b+0.09;

if(b>12.40) (a=6.15, b=6.15);

}

glFlush(); //forzar dibujado

Resultado:

74

Piramid

Descripción: Tenemos que realizar un pirámide y ponerle sus
escalones debe ser echo por cuadrados.

Borrador:

75

Código:


int i,a=25;


glColor3f(1.0 , 0.0 , 0.0);

glLineWidth(2);

glBegin(GL_LINES);

//Valor incial --- Valor final o condicion --- incremento

for(i=1;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);

76

}

glEnd();


Resultado:

77

Semafor
o

Descripción: Tenemos que realizar un semáforo que valla
cambiando las luces el verde que parpadeé tres veces el
Amarillo y el rojo solo una vez.

Borrador:

78

Código:


{

glClear(GL_COLOR_BUFFER_BIT |
GL_DEPTH_BUFFER_BIT); //borra pantalla

glColor3f(0.1 , 0.0 , 0.4);

// semaforo parte grande

glColor3f(0.2,0.3,0.7);

glBegin(GL_QUADS);

glVertex2i(250,50);



glVertex2i(300,50);





79

glEnd();

glColor3f(0.0,0.0,0.0);

glColor3f(0.0,0.0,0.0);

glColor3f(0.0,0.0,0.0);

circulo(275,325,30);

circulo(275,425,30);

circulo(275,525,30);

a=a+1;

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

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

glColor3f(0.0,0.5,0.2);

circulo(275,325,30);

}

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

glColor3f(0.0,0.5,0.2);

circulo(275,325,30);

}

80

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

glColor3f(0.0,0.5,0.2);

circulo(275,325,30);

}

if(a>70 && a<95){

glColor3f(1.0,1.0,0.0);

circulo(275,425,30);

}

if(a>100 && a<125){

glColor3f(1.0,0.0,0.0);

circulo(275,525,30);

}

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

glEnd();

glFlush();

81

Nombre en 3D

Descripción: Tenemos que realizar con cubos nuestro nombre
pero va hacer en 3D.

Borrador:

83

Código:

void dibuja( void )

if(ejes) creaEjes();

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

glColor3f(1.0,1.0,0.0);

//R

glTranslatef(-8.0,0.0, 0.0);

glutSolidCube(1);

glTranslatef(0.0,1.0, 0.0);

glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);

glTranslatef(1.0,-1.0, 0.0);

glutSolidCube(1);


84

glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);

85


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);

86


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);

// AQUI PONES TU NOMBRE

//AQUI

//AQUI

//AQUI//AQUI

//AQUI//AQUI//AQUI

87

//AQUI

glPopMatrix ();

glFlush();

Resultado:

88

Cubo en 3D

Descripción: Tenemos que realizar un cubo echo por otros cubos
en 3D.

Borrador:

89

Código:

}

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

90

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

91

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

92

//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 []){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

93

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

//R


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


94

glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


95

glutSolidCube(1);


glutSolidCube(1);

glTranslatef(-6.0,-6.0, 2.0);

glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);

96


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);

97


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);

98


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


99

glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


glutSolidCube(1);


100

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

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

}

101

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

102

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:

103

giray-=15;

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

104

glutCreateWindow ("Objetos 3D");

//init ( );

glutDisplayFunc (dibuja);

//glutIdleFunc(dibuja);

glutReshapeFunc ( reshape );

glutKeyboardFunc(teclado);

glutSpecialFunc(flechas);

glutMotionFunc(activo);

glutMainLoop( );

return 0;

}

Resultado:

105

Estela y naye

Más contenido relacionado

La actualidad más candente

Destacado

Similar a Estela y naye

Más de Guillermo Mendoza

Último

Estela y naye