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.

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

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

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.

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?

Glut.h Math-h Stdlib.h

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

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

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:

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

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

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

glPointSize(50);

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

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

glPointSize(50);

glColor3f(0.0 ,0.0 ,0.0);

glPointSize(50);

glColor3f(0.0 ,0.0 ,0.0);

glPointSize(50);

glColor3f(0.0 ,0.0 ,1.0);

glPointSize(50);

glEnd();

glFlush(); //forza dibujo

Como quedo al final

Estrella

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

Borrador

Código:

void dibuja(void) //funcion dibuja

glColor3f(0.0 , 0.0 , 1.0);

glBegin(GL_LINES);

glEnd();

Como quedo

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

Cubo con líneas

Borrador:

Código:

glColor3f(0.0 , 0.0 , 0.0);

glLineWidth(4);

glBegin(GL_LINES);

glEnd();

Como quedo

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:

Código:

void dibuja(void) //función dibuja

glBegin(GL_QUADS);

// parte de frente

glColor3f(1.0,0.0,0.0);

// parte de lado

glColor3f(0.0,1.0,0.0);

// parte de arriba

glColor3f(0.0,0.0,1.0);

glEnd();

glLineWidth(5);

glBegin(GL_LINES);

glColor3f(0.0,0.0,0.0);

glEnd();

Resultado:

27Muñ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:

Código:

glColor3f(1.0 , 0.0 , 0.0);

// triangulo de la cabeza

glBegin(GL_TRIANGLES);

glColor3f(0.0,0.0,1.0);

//triangulo de la cabeza 2

glColor3f(0.0,1.0,0.0);

//triangulo pequeño del cuerpo

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

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

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

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

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

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

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

Borrador:

Código:

Casita

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

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

// parte de la casa (roja)

glColor3f(1.0,0.0,0.0);

glVertex2i(50,600);

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

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

//ventanas 3 y 4

glColor3f(0.0,0.0,0.0);

// ventanas 5 y 6

glColor3f(0.0,0.0,0.0);

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

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

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

glLineWidth(7);

glColor3f(1.0,1.0,1.0);

glLineWidth(7);

glColor3f(1.0,1.0,1.0);

// lineas de la ventana 5 y 6

glLineWidth(7);

glColor3f(1.0,1.0,1.0);

// lineas de la ventana 7 y 8

glEnd();

glBegin(GL_QUADS);

glColor3f(0.6,0.5,0.4);

glEnd();

glLineWidth(3);

glBegin(GL_LINES);

glColor3f(0.0,0.5,0.1);

glEnd();

glBegin(GL_QUADS);

glColor3f(0.7,0.1,0.5);

glVertex2i(100,50);

glVertex2i(300,50);

glColor3f(0.0,0.0,0.0);

glEnd();

glBegin(GL_QUADS);

glColor3f(0.0,0.2,0.4);

glVertex2i(700,50);

glEnd();

Resultado:

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

Borrador:

Código:

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

circulo(250,250,50);

//boca

circulo(250,380,20);

glFlush();

Resultado:

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:

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

for(int k=0;k<=8;k++){

cubo(245-20*k*.8,407-20*k*.6,20,5);

cubo(245-20*k*.8,207-20*k*.6,20,5);

//columna izquierda frente

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

cubo(100,100+20*i,20,5);

//abajo frente

for(int j=0;j<=10;j++){

cubo(120+20*j,100,20,5);

//arriba frente

cubo(120+20*j,300,20,5);

//diagonales derecha

for(int k=0;k<=8;k++){

cubo(466-20*k*.8,408-20*k*.6,20,5);

cubo(466-20*k*.8,208-20*k*.6,20,5);

//columna derecha frente

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

cubo(320,100+20*i,20,5);

glFlush();

Resultado:

Muñeco con formas

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

Borrador:

Código:

glColor3f(1.0 , 0.0 , 0.0);

// triangulo de la cabeza

glColor3f(0.0,0.0,1.0);

//triangulo de la cabeza 2

glColor3f(0.0,1.0,0.0);

//triangulo pequeño del cuerpo

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

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

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

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

Animación circulo

Borrador:

Código:

void dibuja(void)

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

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

circulo(100+x,100,40);

glFlush();

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

circulo(600,100+y,40);

glFlush();

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

circulo(600-z,600,40);

glFlush();

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

circulo(100,600-k,40);

glFlush();

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

glutSwapBuffers();

Resultado:

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

Borrador:

Código:

Animacion sistema solar

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

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;

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:

70Movimiento ocho

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

Borrador

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;

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:

Piramide

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

Borrador:

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

glEnd();

Resultado:

Semaforo

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:

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

glEnd();

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

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

Resultado:

Nombre en 3D

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

Borrador:

Código:

void dibuja( void )

if(ejes) creaEjes();

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

glColor3f(1.0,1.0,0.0);

glTranslatef(-8.0,0.0, 0.0);

glutSolidCube(1);

glTranslatef(0.0,1.0, 0.0);

glutSolidCube(1);

glTranslatef(1.0,-1.0, 0.0);

glutSolidCube(1);

// AQUI PONES TU NOMBRE

//AQUI

//AQUI//AQUI

//AQUI//AQUI//AQUI

//AQUI

glPopMatrix ();

glFlush();

Resultado:

Cubo en 3D

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

Borrador:

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

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

glutSolidCube(1);

glTranslatef(-6.0,-6.0, 2.0);

glutSolidCube(1);

// AQUI PONES TU NOMBRE

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

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

glutCreateWindow ("Objetos 3D");

//init ( );

glutDisplayFunc (dibuja);

//glutIdleFunc(dibuja);

glutReshapeFunc ( reshape );

glutKeyboardFunc(teclado);

glutSpecialFunc(flechas);

glutMotionFunc(activo);

glutMainLoop( );

return 0;

Resultado:

Estela y naye

Education

Transcript of Estela y naye

Plásticos - Estela Patricia

Pepo y Estela

Estela tarjeta navidad

estela duarte

Topologias y tipos de redes naye

Estela Schindel

Banquetes naye

Noticia Naye

Lucías y Estela - El sistema solar

Tarea NAYE

Alba Estela y Melanie Cardona.

Esteban y estela

Gracias Estela

Actividades naye

1 conferencia proyectos comunitarios estela y alejandro

Examen Estela

Presentacion Naye Suecia

Estela h Maya

Estela 16: Interpretación preliminar Proyecto Arqueológico ... · Estela 16: Interpretación preliminar Proyecto Arqueológico La Florida-Namaan La Estela 16 se encontró en el

9 Estela turbulenta