Manual de practicas segundo parcial

1

Colegio de Estudios Científicos y

Tecnológicos del Estado de México.

P l a n t e l: Tecámac

Carrera: Técnico en Informática

Asignatura: Utilización de Software de Diseño para el Manejo de Gráficos

Docente: René Domínguez Escalona

Alumno: Mendoza González Guillermo OctavioPérez Luna María Fernanda

Título: ”Manual de prácticas de OpenGl ”

2

Introducción ¿Qué es OpenGl?OpenGL (Open Graphics Library) 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 porSilicon Graphics Inc. (SGI) en 19922 y se usa ampliamente en CAD, realidad virtual, representación científica, visualización de información ysimulación de vuelo. También se usa en desarrollo de videojuegos, donde compite con Direct3D en plataformas Microsoft Windows.

¿Cuáles son la primitiva geométrica?

Formas geométricas consideradas primitivas por su básica constitución en las partes que la conforman, se conocen también con el nombre de primitivas geométricas cuyas formas son elCírculo, el Triángulo y el Cuadrado.

Las primitivas geométricas en un software 3D pueden ser editadas para conseguir formas geométricas más complejas, agregando nuevos vértices, aristas y polígonos.

Las primitivas son grupos de diversos objetos básicos, por ejemplo: los de tipo bidimensional o 2d: son el círculo, el cuadrado y otras formas básicas.

En cuanto a primitivas tridimensionales existen los cilindros, el tubo, el torus, la esfera y el cubo, entre otros.

¿Cómo se crea una ventana en open gl?

Descripción de las funciones principales y variables

http://es.wikipedia.org/wiki/Cilindro

http://es.wikipedia.org/wiki/Pol%C3%ADgono

http://es.wikipedia.org/wiki/Arista_(Geometr%C3%ADa)

http://es.wikipedia.org/w/index.php?title=V%C3%A9rtices&action=edit&redlink=1

http://es.wikipedia.org/wiki/Cuadrado

http://es.wikipedia.org/wiki/Tri%C3%A1ngulo

http://es.wikipedia.org/wiki/C%C3%ADrculo

3

Funciones Principales

Los pasos necesarios para crear una ventana en OpenGL los podemos clasificar como sigue:

- Creamos una ventana. - Establecemos el marco de visión y la perspectiva. - Inicializamos las variables de estado de OpenGL.

Las funciones principales necesarias para inicializar GL son: CreaVentanaGL: 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. EliminaVentanaGL: Libera todos los recursos usados por la ventana. InicializaEscenaGL: Establece el marco de visión (Viewport) de la escena, así como la perspectiva que vamos a utilizar. InicializaGL: Inicializamos todos los valores internos de OpenGL, como por ejemplo el tipo de sombreado y luces, si vamos a utilizar mapeado de texturas, el color de fondo de la escena,... De este modo la función CreaVentanaGL, después de crear la ventana, llamaría a InicializaEscenaGL y posteriormente a InicializaGL y ya tendríamos nuestra ventana creada. Si por algún motivo la llamada a las dos últimas funciones fallara, eliminariamos la ventana mediante EliminaVentanaGL y saldríamos de la aplicación.

Aplicaciones de open gl

Sin entrar en demasiados detalles, describiremos algunas de las características que OpenGL implementa:

Primitivas geométricas Permiten construir descripciones matemáticas de objetos. Las actuales primitivas son: puntos, líneas, polígonos, imágenes y bitmaps.

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 posicíon 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ágico 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 doble buffering ayuda a eliminar el parpadeo de las animaciones. Cada fotograma consecutivo en una animación se construye en un buffer separado de memoria y mostrado solo cuando está completo.

El Anti-alizado reduce los bordes escalonados en las líneas dibujadas sobre una pantalla de ordenador. Los bordes escalonados aparecen a menudo cuando las líneas se dibujan con baja resolución. El anti-alizado es una ténica común en gráficos de ordenador que modifica el color y la intensidad de los pixels cercanos a la línea para reducir el zig-zag artificial.

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 superfícies.

El Z-buffering mantiene registros de la coordenada Z de un objeto 3D. El Z-buffer se usa para registrar la proximidad de un objeto al observador, y es también crucial para el eliminado de superfícies ocultas.

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.

El Alpha blending usa el valor Alfa (valor de material difuso) del código RGBA, y permite combinar el color del fragmento que se procesa con el del pixel que ya está en el buffer. Imagina por ejemplo dibujar una ventana transparente de color azul claro enfrente de una caja roja. El Alpha blending permite simular la transparencia de la ventana, de manera que la caja vista a través del cristal aparezca con un tono magenta.

Los planos de plantilla permiten restringir el trazado a ciertas regiones de la pantalla.

Las listas de Display permiten almacenar comandos de dibujo en una lista para un trazado posterior, cuando las listas de display se usan

5

apropiadamente puedan mejorar mucho el rendimiento de nuestras aplicaciones.

Los Evaluadores Polinómicos sirven para soportar B-splines racionales no uniformes, esto es para ayudar a dibujar curvas suaves a través de unos cuantos puntos de referencia, ahorrándose la necesidad de acumular grandes cantidades de puntos intermedios.

Características de Feedback, Selección y Elección que ayudan a crear aplicaciones que permiten al usuario seleccionar una región de la pantalla o elegir un objeto dibujado en la misma. El modo de feedback permite al desarrollador obtener los resultados de los cálculos de trazado.

Primitivas de Raster (bitmaps y rectángulos de pixels) Operaciones con Pixels Transformaciones: rotación, escalado, perspectivas en 3D

¿Cuáles son las 3 librerías de Opengl y sus características?

Librería adicionales de OpenGL

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

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

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

GLAUX: Esta librería, muy parecida a GLUT, es la que Microsoft ha desarrollado para Windows. Mantiene practicamente la misma estructura que la GLUT con el defecto de que solo sirve para Windows, mientras que GLUT sirve para cualquier plataforma.

6

GLX: Esta es la librería utilizada para trabajar en un sistema de X-Windows (Linux), permite no sólo renderizar en la máquina local, sino tambien a travez de una red.

Tambien hay otras librerías más específicas para el control de entrada, sonido, red.... Evidentemente podemos utilizar las DX, aunque tambien debes saber que hay una colección de OpenXX que incluyen practicamente las mismas características (algunas menos, todo hay que decirlo) que DX, como son OpenAL (Audio), OpenNL (Red), OpenIN (Entrada)...

¿Cómo configurar open gl en dev c++?Instalar Opengl en Dev C++

1. Para empezar la instalacion primero abrimos Dev C++ luego nos vamos a la barra de menu y hacemos click en herramientas , luego hacemos click en Buscar Actulizaciones 2. Luego nos aparacera una ventana que dira WebUpadate Nos dirigimos a la parte roja asi como se muestra en la imagen ....

3. Luego expandimos las opciones y selecionamos devpak.org Comunity Dev Paks4. Luego hacemos click en Check for Updates5. Luego nos aparacera un monton de actualizaciones Bueno a nosotros nos interesa solo opengl .... Bueno entocnes solo marcamos el check de glut y freglut6. Luego le damos click en Dowload selected y empezaran a descargarse las opciones marcadas en nuestro caso el glut y freglut7. Y Por ultimo cuando se ayan descargado todos los paquetes selecionados nos aparacera una ventana como esta solo le damos click en install y listo :)

http://www.xprogramando.com/2010/11/instalar-opengl-en-dev-c.html

7

Índice

Portada………………………………………………………… 01Introducción……………………………………………………..02-06Índice……………………………………………………………07Practica 1: Tablero de Ajedrez………………………………..08-12Practica 2: Estrella……………………………………………..13-14Practica 3: Cubo con líneas……………………………………15-17Practica 4: Cubo delineado…………………………………….18-21Practica 5: Muñeco con triángulos…………………………….22-26Practica 6: Casita……………………………………………....27-39Practica 7: Oso………………………………………………….40-44Practica 8: Cubo con cubitos…………………………………..45-48Practica 9: Muñeco con formas………………………………..49-55Practica 10: Animación de circulo rotando……………………56-58Practica 11: Animación del Sistema Solar…………………….59-61Practica 12: Movimiento en ocho……………………………....62-64Practica 13: Semáforo…………………………………………..65-69Practica 14: Cubo en 3D………………………………………..70-73Practica 15: Nombres en 3D……………………………………74-80Practica Extra: Pirámide…………………………………………81-84

8

PracticasPractica No.1: Tablero de Ajedrez

Descripción: En esta práctica debemos de realizar un tablero de ajedrez de 8 X 8 en el cual allá dos colores diferentes y que se vayan combinando los colores entre sí.

Borrador con coordenadas utilizadas:

Código:void dibuja(void) //funcion dibuja{

9

glClear(GL_COLOR_BUFFER_BIT); //borra pantallaglColor3f(1.0 ,1.0 ,0.0); glPointSize(50); glBegin (GL_POINTS); glVertex2i(100,100); glVertex2i(300,100); glVertex2i(500,100); glVertex2i(700,100); glColor3f(0.0 ,0.0 ,0.0); glPointSize(50); glBegin (GL_POINTS); glVertex2i(200,100); glVertex2i(400,100); glVertex2i(600,100); glVertex2i(800,100); glColor3f(1.0 ,1.0 ,0.0); glPointSize(50); glBegin (GL_POINTS); glVertex2i(200,200); glVertex2i(400,200); glVertex2i(600,200); glVertex2i(800,200); glColor3f(0.0 ,0.0 ,0.0); glPointSize(50); glBegin (GL_POINTS); glVertex2i(100,200); glVertex2i(300,200); glVertex2i(500,200); glVertex2i(700,200); glColor3f(1.0 ,1.0 ,0.0); glPointSize(50); glBegin (GL_POINTS); glVertex2i(100,300); glVertex2i(300,300); glVertex2i(500,300); glVertex2i(700,300);

10

glColor3f(0.0 ,0.0 ,0.0); glPointSize(50); glBegin (GL_POINTS); glVertex2i(200,300); glVertex2i(400,300); glVertex2i(600,300); glVertex2i(800,300);

glColor3f(1.0 ,1.0 ,0.0); glPointSize(50); glBegin (GL_POINTS); glVertex2i(200,400); glVertex2i(400,400); glVertex2i(600,400); glVertex2i(800,400); glColor3f(0.0 ,0.0 ,0.0); glPointSize(50); glBegin (GL_POINTS); glVertex2i(100,400); glVertex2i(300,400); glVertex2i(500,400); glVertex2i(700,400); glColor3f(1.0 ,1.0 ,0.0); glPointSize(50); glBegin (GL_POINTS); glVertex2i(100,500); glVertex2i(300,500); glVertex2i(500,500); glVertex2i(700,500); glColor3f(0.0 ,0.0 ,0.0); glPointSize(50); glBegin (GL_POINTS); glVertex2i(200,500); glVertex2i(400,500); glVertex2i(600,500); glVertex2i(800,500); glColor3f(1.0 ,1.0 ,0.0);

11

glPointSize(50); glBegin (GL_POINTS); glVertex2i(200,600); glVertex2i(400,600); glVertex2i(600,600); glVertex2i(800,600); glColor3f(0.0 ,0.0 ,0.0); glPointSize(50); glBegin (GL_POINTS); glVertex2i(100,600); glVertex2i(300,600); glVertex2i(500,600); glVertex2i(700,600); glColor3f(1.0 ,1.0 ,0.0); glPointSize(50); glBegin (GL_POINTS); glVertex2i(100,700); glVertex2i(300,700); glVertex2i(500,700); glVertex2i(700,700); glColor3f(0.0 ,0.0 ,0.0); glPointSize(50); glBegin (GL_POINTS); glVertex2i(200,700); glVertex2i(400,700); glVertex2i(600,700); glVertex2i(800,700); glColor3f(0.0 ,0.0 ,0.0); glPointSize(50); glBegin (GL_POINTS); glVertex2i(100,800); glVertex2i(300,800); glVertex2i(500,800); glVertex2i(700,800); glColor3f(1.0 ,1.0 ,0.0); glPointSize(50);

12

glBegin (GL_POINTS); glVertex2i(200,800); glVertex2i(400,800); glVertex2i(600,800); glVertex2i(800,800); glEnd();glFlush(); //forza dibujo}

Salida:

13

Practica No.2: Estrella

Descripción: En esta práctica bebemos de realizar una estrella de cinco picos con la función de líneas.


14

Código:void dibuja(void) //funcion dibuja{glClear(GL_COLOR_BUFFER_BIT); //borra pantallaglColor3f(0.0,0.0,0.0);glLineWidth(5);glBegin(GL_LINES);glVertex2i(100,100);glVertex2i(300,550);glVertex2i(300,550);glVertex2i(500,100);glVertex2i(500,100);glVertex2i(100,350);glVertex2i(100,350);glVertex2i(500,350);glVertex2i(500,350);glVertex2i(100,100);glEnd();glFlush(); //forza dibujo}

Salida:

15

Practica No.3: Cubo con líneas

Descripción: En esa práctica debemos de utilizar la función de línea y debemos de realizar un cubó el tamaño que deseemos.


16

Código: void dibuja(void) //funcion dibuja{glClear(GL_COLOR_BUFFER_BIT); //borra pantalla glLineWidth(5); glColor3f(1.0 , 0.0 , 0.0);glBegin(GL_LINES);glVertex2i(200,200);glVertex2i(200,400);glVertex2i(200,400);glVertex2i(400,400);glVertex2i(400,400);glVertex2i(400,200);

17

glVertex2i(400,200);glVertex2i(200,200);glVertex2i(300,300);glVertex2i(300,500);glVertex2i(300,500);glVertex2i(500,500);glVertex2i(500,500);glVertex2i(500,300);glVertex2i(500,300);glVertex2i(300,300);glVertex2i(200,200);glVertex2i(300,300);glVertex2i(400,200);glVertex2i(500,300);glVertex2i(200,400);glVertex2i(300,500);glVertex2i(400,400);glVertex2i(500,500);glEnd();glFlush(); //forza dibujo}

Salida:

18

19

Practica No.4: Cubo delineado

Descripción: En esta actividad debemos de realizar un cubo pero ahora debe de ir relleno de color y delineado negro. Para eso debemos de utilizar la función de cuadros para el relleno y la de líneas para el delineado.


Código: void dibuja(void) //funcion dibuja{glClear(GL_COLOR_BUFFER_BIT); //borra pantalla

20

glBegin(GL_QUADS);// parte de frenteglColor3f(1.0,0.0,0.0);glVertex2i(200,200);glColor3f(0.0,1.0,0.0);glVertex2i(400,200);glColor3f(0.0,0.0,1.0);glVertex2i(400,400);glColor3f(1.0,0.0,1.0);glVertex2i(200,400);// parte de ladoglColor3f(0.0,1.0,0.0);glVertex2i(400,200);glColor3f(1.0,0.0,0.0);glVertex2i(500,300);glColor3f(0.0,0.0,1.0);glVertex2i(500,500);glColor3f(1.0,1.0,0.0);glVertex2i(400,400);// parte de arribaglColor3f(1.0,0.0,1.0);glVertex2i(200,400);glColor3f(1.0,1.0,0.0);glVertex2i(400,400);glColor3f(1.0,1.0,1.0);glVertex2i(500,500);glColor3f(0.0,0.0,0.0);glVertex2i(300,500);glEnd(); glLineWidth(5); glBegin(GL_LINES);glColor3f(0.0,0.0,0.0);glVertex2i(200,200);glVertex2i(400,200);glVertex2i(400,200);

21

glVertex2i(400,400);glVertex2i(400,400);glVertex2i(200,400);glVertex2i(200,400);glVertex2i(200,200);

glVertex2i(400,200);glVertex2i(500,300);glVertex2i(500,300);glVertex2i(500,500);glVertex2i(500,500);glVertex2i(400,400);glVertex2i(400,400);glVertex2i(400,200);

glVertex2i(200,400);glVertex2i(400,400);glVertex2i(400,400);glVertex2i(500,500);glVertex2i(500,500);glVertex2i(300,500);glVertex2i(300,500);glVertex2i(200,400);glEnd();glFlush(); //forza dibujo}

Salida:

22

23

Practica No.5: Muñeco con triángulos

Descripción: En esta práctica vamos a utilizar la función de triángulos, cuadrados y polígonos y vamos a realizar un muñeco con triángulos, la mayoría de las partes son puros triángulos y deberemos de utilizar diferentes colores.


Código:

24

void dibuja(void) //funcion dibuja{glClear(GL_COLOR_BUFFER_BIT); //borra pantallaglColor3f(1.0 , 0.0 , 0.0);// triangulo de la cabezaglBegin(GL_TRIANGLES);glColor3f(1.0,1.0,0.0);glVertex2i(250,750);glColor3f(0.0,1.0,0.0);glVertex2i(550,750);glColor3f(0.0,1.0,1.0);glVertex2i(400,850);//triangulo de la cabeza 2glColor3f(0.0,1.0,0.0);glVertex2i(300,750);glColor3f(1.0,0.0,0.0);glVertex2i(500,750);glColor3f(0.0,0.0,1.0);glVertex2i(400,600);//triangulo pequeño del cuerpoglColor3f(0.0,0.0,0.0);glVertex2i(400,550);glColor3f(0.0,0.0,0.0);glVertex2i(425,600);glColor3f(0.0,0.0,0.0);glVertex2i(374,600);// triangulos de la mano izquierdaglColor3f(1.0,0.0,0.0);glVertex2i(300,600);glColor3f(1.0,0.0,1.0);glVertex2i(100,300);glColor3f(1.0,1.0,0.0);glVertex2i(50,400);

glColor3f(0.0,1.0,0.0);

25

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 derechaglColor3f(1.0,1.0,0.0);glVertex2i(500,600);glColor3f(0.0,1.0,1.0);glVertex2i(650,300);glColor3f(1.0,1.0,1.0);glVertex2i(700,350);

glColor3f(1.0,0.0,1.0);glVertex2i(700,350);glColor3f(1.0,1.0,0.0);glVertex2i(750,300);glColor3f(0.0,1.0,1.0);glVertex2i(750,400);// triangulos de la pierna y pie izquierdoglColor3f(1.0,0.0,1.0);glVertex2i(350,100);glColor3f(1.0,0.0,0.0);glVertex2i(350,350);glColor3f(0.0,1.0,1.0);glVertex2i(300,300);

glColor3f(1.0,1.0,0.0);glVertex2i(350,100);glColor3f(1.0,0.0,1.0);glVertex2i(250,150);glColor3f(1.0,1.0,1.0);glVertex2i(200,100);// triangulos de la pierna y pie derechoglColor3f(1.0,1.0,0.0);

26

glVertex2i(450,250);glColor3f(1.0,0.0,1.0);glVertex2i(600,250);glColor3f(0.0,1.0,1.0);glVertex2i(450,350);

glColor3f(0.0,0.0,1.0);glVertex2i(600,150);glColor3f(0.0,1.0,0.0);glVertex2i(750,150);glColor3f(0.0,0.0,0.0);glVertex2i(675,200);

glColor3f(1.0,1.0,0.0);glVertex2i(600,150);glColor3f(1.0,0.0,1.0);glVertex2i(600,250);glColor3f(0.0,1.0,1.0);glVertex2i(550,200);glEnd();// cuerpo del muñecoglBegin(GL_QUADS);glColor3f(1.0,1.0,0.0);glVertex2i(300,350);glColor3f(1.0,0.0,1.0);glVertex2i(500,350);glColor3f(0.0,1.0,1.0);glVertex2i(500,600);glColor3f(0.0,1.0,1.0);glVertex2i(300,600);// balonglBegin(GL_QUADS);glColor3f(1.0,1.0,0.0);glVertex2i(600,100);glColor3f(1.0,0.0,1.0);

27

glVertex2i(650,150);glColor3f(0.0,1.0,1.0);glVertex2i(700,150);glColor3f(0.0,1.0,1.0);glVertex2i(750,100);// balon 2glBegin(GL_QUADS);glColor3f(1.0,1.0,0.0);glVertex2i(600,100);glColor3f(1.0,0.0,1.0);glVertex2i(650,50);glColor3f(0.0,1.0,1.0);glVertex2i(700,50);glColor3f(0.0,1.0,1.0);glVertex2i(750,100);glEnd();glFlush(); //forza dibujo}

Salida:

28

Practica No.6: Casita

Descripción: En esta práctica utilizaremos todas las funciones ya aprendidas anterior mente ya que realizaremos una casa con ventanas, puertas, barandales, arboles entre otras cosas y utilizaremos diferentes combinaciones de colores para cada accesorio.


Código: void dibuja(void) //funcion dibuja{glClear(GL_COLOR_BUFFER_BIT); //borra pantallaglBegin(GL_QUADS);// calleglColor3f(0.0,0.0,0.0);glVertex2i(0,0);glVertex2i(1000,0);glVertex2i(1000,100);

29

glVertex2i(0,100);//guarnicionglColor3f(1.0,1.0,0.0);glVertex2i(0,100);glVertex2i(1000,100);glVertex2i(1000,150);glVertex2i(0,150);// grisglColor3f(1.0,0.0,1.0);glVertex2i(0,150);glVertex2i(1000,150);glVertex2i(1000,200);glVertex2i(0,200);// pastoglColor3f(0.0,1.0,0.0);glVertex2i(0,200);glVertex2i(1000,200);glVertex2i(1000,450);glVertex2i(0,450);// parte de la casa (anaranjado)glColor3f(1.0,0.0,0.0);glVertex2i(150,300);glVertex2i(200,300);glColor3f(1.0,1.0,0.0);glVertex2i(200,600);glVertex2i(150,600);// parte de la casa (gris)glColor3f(1.0,1.0,1.0);glVertex2i(200,300);glVertex2i(450,300);glColor3f(1.0,1.0,1.0);glVertex2i(450,600);glVertex2i(200,600);// parte de la casa (roja)glColor3f(1.0,0.0,0.0);

30

glVertex2i(50,600);glVertex2i(450,600);glVertex2i(450,700);glVertex2i(100,700);// parte de la casa (anaranjada)glColor3f(1.0,0.0,0.0);glVertex2i(450,300);glVertex2i(850,300);glColor3f(1.0,1.0,0.0);glVertex2i(850,800);glVertex2i(450,800);// parte de la casa1 (rosa)glColor3f(1.0,0.0,1.0);glVertex2i(550,300);glVertex2i(600,300);glVertex2i(600,800);glVertex2i(550,800);// parte de la casa2 (rosa)glColor3f(1.0,0.0,1.0);glVertex2i(700,300);glVertex2i(750,300);glVertex2i(750,800);glVertex2i(700,800);// parte de la casa3 (rosa)glColor3f(1.0,0.0,1.0);glVertex2i(450,600);glVertex2i(850,600);glVertex2i(850,650);glVertex2i(450,650);// parte de la casa (roja)glColor3f(1.0,0.0,0.0);glVertex2i(300,800);glVertex2i(1000,800);glVertex2i(900,900);glVertex2i(400,900);

31

// parte de la casa (rosa)glColor3f(1.0,0.0,1.0);glVertex2i(550,150);glVertex2i(750,150);glVertex2i(750,300);glVertex2i(550,300);// puerta (blanca)glColor3f(1.0,1.0,1.0);glVertex2i(600,300);glVertex2i(700,300);glVertex2i(700,550);glVertex2i(600,550);// puesta pequeña (azul)glColor3f(0.0,0.0,1.0);glVertex2i(625,325);glVertex2i(675,325);glVertex2i(675,500);glVertex2i(625,500);// chapaglColor3f(0.0,0.0,0.0);glVertex2i(600,380);glVertex2i(620,380);glVertex2i(620,400);glVertex2i(600,400);// ventasnas 1 y 2 glColor3f(0.0,0.0,0.0);glVertex2i(450,350);glVertex2i(550,350);glVertex2i(550,450);glVertex2i(450,450);

glColor3f(0.0,0.0,0.0);glVertex2i(450,450);glVertex2i(550,450);glVertex2i(550,550);

32

glVertex2i(450,550);//ventanas 3 y 4glColor3f(0.0,0.0,0.0);glVertex2i(750,350);glVertex2i(850,350);glVertex2i(850,450);glVertex2i(750,450);

glColor3f(0.0,0.0,0.0);glVertex2i(750,450);glVertex2i(850,450);glVertex2i(850,550);glVertex2i(750,550);// ventanas 5 y 6glColor3f(0.0,0.0,0.0);glVertex2i(450,660);glVertex2i(525,660);glVertex2i(525,775);glVertex2i(450,775);// ventana 7 y 8glColor3f(0.0,0.0,0.0);glVertex2i(775,660);glVertex2i(850,660);glVertex2i(850,775);glVertex2i(775,775);// ventanas 9 y 10 glColor3f(0.0,0.0,0.0);glVertex2i(600,750);glVertex2i(700,750);glVertex2i(700,800);glVertex2i(600,800);// linea de las ventanas 9 y 10glColor3f(1.0,1.0,1.0);glVertex2i(600,725);glVertex2i(700,725);

33

glVertex2i(700,750);glVertex2i(600,750);glEnd();glLineWidth(5); glBegin(GL_LINES);glColor3f(1.0,1.0,1.0);// lineas de la calleglColor3f(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(850,50);glVertex2i(950,50);// lineas de la ventana 1

34

glLineWidth(7);glColor3f(1.0,1.0,1.0);glVertex2i(450,350);glVertex2i(550,350);glVertex2i(550,350);glVertex2i(550,450);glVertex2i(550,450);glVertex2i(450,450);glVertex2i(450,450);glVertex2i(450,350);// lineas de la ventana 2glLineWidth(7);glColor3f(1.0,1.0,1.0);glVertex2i(450,450);glVertex2i(550,450);glVertex2i(550,450);glVertex2i(550,550);glVertex2i(550,550);glVertex2i(450,550);glVertex2i(450,550);glVertex2i(450,450);// lineas de la ventana 3 glLineWidth(7);glColor3f(1.0,1.0,1.0);glVertex2i(750,350);glVertex2i(850,350);glVertex2i(850,350);glVertex2i(850,450);glVertex2i(850,450);glVertex2i(750,450);glVertex2i(750,450);glVertex2i(750,350);// lineas de la ventana 4glLineWidth(7);glColor3f(1.0,1.0,1.0);

35

glVertex2i(750,450);glVertex2i(850,450);glVertex2i(850,450);glVertex2i(850,550);glVertex2i(850,550);glVertex2i(750,550);glVertex2i(750,550);glVertex2i(750,450);// lineas de la ventana 5 y 6glLineWidth(7);glColor3f(1.0,1.0,1.0);glVertex2i(450,660);glVertex2i(525,660);glVertex2i(525,660);glVertex2i(525,775);glVertex2i(525,775);glVertex2i(450,775);glVertex2i(450,775);glVertex2i(450,660);

glVertex2i(450,725);glVertex2i(525,725);// lineas de la ventana 7 y 8glVertex2i(775,660);glVertex2i(850,660);glVertex2i(850,660);glVertex2i(850,775);glVertex2i(850,775);glVertex2i(775,775);glVertex2i(775,775);glVertex2i(775,660);

glVertex2i(775,725);glVertex2i(850,725);glEnd();

36

// tronco del arbolglBegin(GL_QUADS);glColor3f(0.6,0.5,0.4);glVertex2i(900,350);glVertex2i(950,350);glVertex2i(950,500);glVertex2i(900,500);glEnd();// hojas de los arbolesglLineWidth(3);glBegin(GL_LINES);glColor3f(0.0,0.5,0.1);glVertex2i(850,500);glVertex2i(1000,500);

glVertex2i(860,510);glVertex2i(990,510);







37

glEnd();glBegin(GL_QUADS);glColor3f(0.7,0.1,0.5);glVertex2i(100,50);glVertex2i(300,50);glVertex2i(300,100);glVertex2i(100,100); glVertex2i(150,100);glVertex2i(250,100);glVertex2i(250,150);glVertex2i(150,150);

glColor3f(0.0,0.0,0.0);glVertex2i(200,100);glVertex2i(250,100);glVertex2i(250,150);glVertex2i(200,150); glEnd();glBegin(GL_QUADS);glColor3f(0.0,0.2,0.4);glVertex2i(700,50);glVertex2i(700,150);glVertex2i(1000,150);glVertex2i(1000,50);

glVertex2i(850,150);glVertex2i(850,200);glVertex2i(950,200);glVertex2i(950,150);

glColor3f(0.0,0.0,0.0);glVertex2i(900,150);glVertex2i(950,150);glVertex2i(950,200);

38

glVertex2i(900,200);glEnd();// tronco del arbolglBegin(GL_QUADS);glColor3f(0.6,0.5,0.4);glVertex2i(50,350);glVertex2i(100,350);glVertex2i(100,500);glVertex2i(50,500);glEnd();// hojas de los arbolesglLineWidth(3);glBegin(GL_LINES);glColor3f(0.0,0.5,0.1);glVertex2i(0,500);glVertex2i(150,500);







39

glVertex2i(70,570);glVertex2i(80,570);glEnd(); glBegin(GL_LINES);glLineWidth(3);// barandal de la ventanaglColor3f(0.0,0.0,0.0);glVertex2i(600,700);glVertex2i(700,700);glColor3f(0.0,0.0,0.0);glVertex2i(600,600);glVertex2i(600,700);






glEnd();glFlush(); //forza dibujo}

Salida:

40

41

Practica No.7: Oso

Descripción: En esta actividad deberás de realizar un oso con la función de círculo.


42

Código: 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);

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

glEnd();}

void dibuja(void) //funcion dibuja{glClear(GL_COLOR_BUFFER_BIT); //panzaglColor3f(0.2,0.1,0.1); //borra pantallacirculo(280,200,100);glColor3f(0.9,0.7,0.8);circulo(280,200,60);//pie izq

43

glColor3f(0.2,0.1,0.1); circulo(190,100,40);glColor3f(0.9,0.7,0.8); circulo(190,100,20);//pie derglColor3f(0.2,0.1,0.1); circulo(370,100,40);glColor3f(0.9,0.7,0.8); circulo(370,100,20);//mano derechaglColor3f(0.2,0.1,0.1); circulo(390,280,40);glColor3f(0.9,0.7,0.8); circulo(390,280,20);//mano izq

glColor3f(0.2,0.1,0.1); circulo(170,280,40);glColor3f(0.9,0.7,0.8); circulo(170,280,20);//cabezaglColor3f(0.2,0.1,0.1); circulo(280,350,60);

//oreja izqglColor3f(0.2,0.1,0.1); circulo(220,400,20);glColor3f(0.9,0.7,0.8); circulo(220,400,10);//oreja dereglColor3f(0.2,0.1,0.1); circulo(340,400,20);glColor3f(0.9,0.7,0.8); circulo(340,400,10);//ojo izq

44

glColor3f(0.0,0.0,0.0); circulo(260,370,20);glColor3f(0.9,0.7,0.4); circulo(260,370,5);//ojo der

glColor3f(0.0,0.0,0.0); circulo(300,370,20);glColor3f(0.9,0.7,0.4); circulo(300,370,5);//nariz

glColor3f(1.0,1.0,1.0); circulo(280,340,10);glEnd();glBegin(GL_LINES);glColor3f(1.0,1.0,1.0);glVertex2i(280,330);glVertex2i(280,310);



Salida:

45

46

Practica No.8: Cubo con cubitos

Descripción: Debes de realizar un cubo con cubitos en el cual sea 8 X 8 y que no tenga rellenos solamente estén los cubitos.


Código: void cubo (int x, int y,int t,int l){ double a=.8,b=.6;glColor3f(0.2 , 0.7 , 0.7); glBegin(GL_QUADS);glVertex2f(x,y);glVertex2f(x+t,y);glVertex2f(x+t,y+t);glVertex2f(x,y+t);glColor3f(0.0 , 0.5 , 0.8);glVertex2f(x,y+t);glVertex2f(x+t,y+t);glVertex2f(x+t+(t*a),y+t+(t*b));glVertex2f(x+(t*a),y+t+(t*b));glColor3f(0.8 , 0.0 , 0.4);glVertex2f(x+t,y+t);

47

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

glColor3f(0.0 , 0.0 , 0.0);glLineWidth(3);glBegin(GL_LINES);glVertex2f(x,y);glVertex2f(x+t,y);glVertex2f(x+t,y);glVertex2f(x+t,y+t);glVertex2f(x+t,y+t);glVertex2f(x,y+t);glVertex2f(x,y);

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

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

48

} void dibuja(void) //funcion dibuja{glClear(GL_COLOR_BUFFER_BIT); //borra pantallaglColor3f(1.0 , 0.0 , 0.0);//columna izquierda atrasfor(int i=0;i<=10;i++){cubo(260,220+20*i,20,5);}//abajo atrasfor(int j=0;j<=9;j++){cubo(280+20*j,220,20,5);}//arriba de atrasfor(int j=0;j<=10;j++){cubo(260+20*j,420,20,5);}//columna derecha atrasfor(int i=0;i<=10;i++){cubo(480,220+20*i,20,5);}

//los de enfrente//diagonales izquiercafor(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 frentefor(int i=0;i<=10;i++){cubo(100,100+20*i,20,5);}//abajo frente

49

for(int j=0;j<=10;j++){cubo(120+20*j,100,20,5);//arriba frentecubo(120+20*j,300,20,5);}//diagonales derechafor(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 frentefor(int i=0;i<=10;i++){cubo(320,100+20*i,20,5);}

glFlush(); //forza dibujo}

Salida:

50

Practica No.9: Muñeco con formas

Descripción: En esta práctica debes de realizar un muñeco con triángulos, cuadros, polígonos y que vayan rellenos de colores que el dibujó te vaya indicando.


Código:

51

void dibuja(void) //funcion dibuja{glClear(GL_COLOR_BUFFER_BIT); //borra pantalla// pie izquierdoglBegin(GL_QUADS);glColor3f(0.0,0.0,0.0);glVertex2i(200,100);glVertex2i(300,100);glVertex2i(300,150);glVertex2i(250,150);// pie derechoglColor3f(0.0,0.0,0.0);glVertex2i(450,100);glVertex2i(450,150);glVertex2i(500,150);glVertex2i(550,100);// pantalonglColor3f(0.2,0.2,0.7);glVertex2i(275,250);glVertex2i(300,325);glVertex2i(450,325);glVertex2i(475,250);

glColor3f(0.2,0.2,0.7);glVertex2i(250,150);glVertex2i(275,250);glVertex2i(375,250);glVertex2i(300,150);

glColor3f(0.2,0.2,0.7);glVertex2i(375,250);glVertex2i(475,250);glVertex2i(500,150);glVertex2i(450,150);// cinturon

52

glColor3f(1.0,1.0,1.0);glVertex2i(300,325);glVertex2i(300,350);glVertex2i(450,350);glVertex2i(450,325);

glColor3f(0.0,0.0,0.0);glVertex2i(350,325);glVertex2i(350,350);glVertex2i(400,350);glVertex2i(400,325);// camisaglColor3f(0.9,0.3,0.3);glVertex2i(300,350);glVertex2i(300,600);glVertex2i(450,600);glVertex2i(450,350);// camisa toraxglVertex2i(225,550);glVertex2i(250,600);glVertex2i(500,600);glVertex2i(525,550);// manga izquierdaglVertex2i(200,450);glVertex2i(225,550);glVertex2i(300,550);glVertex2i(250,450);// manga derechaglVertex2i(500,450);glVertex2i(450,550);glVertex2i(525,550);glVertex2i(550,450);// mano izquierdaglColor3f(0.9,0.8,0.7);glVertex2i(200,375);

53

glVertex2i(210,450);glVertex2i(230,450);glVertex2i(220,375);// mano derechaglVertex2i(510,375);glVertex2i(510,450);glVertex2i(530,450);glVertex2i(530,375);// botones de la camisaglColor3f(0.3,0.8,0.8);glVertex2i(350,525);glVertex2i(350,550);glVertex2i(400,550);glVertex2i(400,525);



glVertex2i(350,375);glVertex2i(350,400);glVertex2i(400,400);glVertex2i(400,375);// cuelloglColor3f(0.9,0.8,0.7);glVertex2i(350,600);glVertex2i(350,650);glVertex2i(400,650);glVertex2i(400,600);

54

glEnd();

glBegin(GL_TRIANGLES);glColor3f(0.9,0.8,0.7);glVertex2i(350,600);glVertex2i(400,600);glVertex2i(375,550);// cabeza circuloglColor3f(0.9,0.8,0.7);circulo(375,750,150);

circulo(225,750,15);

circulo(525,750,15);

glEnd();

glBegin(GL_QUADS);glColor3f(0.0,0.0,0.0);glVertex2i(300,750);glVertex2i(350,750);glVertex2i(350,800);glVertex2i(300,800);glColor3f(0.0,0.0,0.0);glVertex2i(400,750);glVertex2i(450,750);glVertex2i(450,800);glVertex2i(400,800);glEnd();

glBegin(GL_POLYGON);glColor3f(1.0,1.0,1.0);glVertex2i(350,725);glVertex2i(375,700);glVertex2i(400,725);

55

glEnd();

glLineWidth(5);glBegin(GL_LINES);glColor3f(0.0,0.0,0.0);glVertex2i(300,650);glVertex2i(450,650);glEnd();

glBegin(GL_TRIANGLES);glColor3f(0.4,0.2,0.1);glVertex2i(300,880);glVertex2i(375,950);glVertex2i(450,880);

glVertex2i(435,890);glVertex2i(490,890);glVertex2i(510,815);

glVertex2i(310,880);glVertex2i(245,905);glVertex2i(245,830);

glEnd();glBegin(GL_POLYGON);glColor3f(0.9,0.8,0.7);glVertex2i(510,375);glVertex2i(490,350);glVertex2i(520,370);glVertex2i(510,320);glVertex2i(525,380);glVertex2i(520,390);glVertex2i(545,350);glEnd();glBegin(GL_POLYGON);

56

glColor3f(0.9,0.8,0.7);glVertex2i(200,375);glVertex2i(180,350);glVertex2i(210,370);glVertex2i(205,320);glVertex2i(215,380);glVertex2i(210,390);glVertex2i(235,350);


Salida:

57

Practica No.10: Animación de circulo rotando

Descripción: En esta actividad debes de realizar que el círculo vaya dando vueltas por toda la ventana de OpenGl.


Código: void dibuja(void){glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);if(x>=1 && x<500){circulo(2+1*x,500,50);glFlush();x++;}if(y>=1 && y<500 && x==500){circulo(500,500+y,50);

58

glFlush();y++;}if(k>=1 && k<500 && x==500 && y==500){circulo(500-k,1000,50);glFlush();k++;}

if(z>=1 && z<500 && x==500 && y==500 && k==500){circulo(5,1000-z,50);glFlush();z++;if(z==500){x=1; y=1; k=1; z=1;}}glutSwapBuffers();}

Salida:

59

60

Practica No.11: Animación del Sistema Solar

Descripción: En esta práctica realizaremos una animación en el cual nosotros vamos a hacer la simulación del sistema solar y que los planetas vayan girando sobre su eje de rotación.


Código: void dibuja(void){

61

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//estoglColor3f(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 circuloglColor3f(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;

62

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 lentofor(int j=1;j<=10000000;j++){}//pausaif(ang==360){ang=0;}// se repite idefinidamenteglFlush(); //forzar dibujadoglutSwapBuffers(); //y esto}

Salida:

Practica No.12: Movimiento en ocho

63

Descripción: En esta práctica debemos de realizar que una pelotita se mueva en una dirección de ocho.


Código: void dibuja(void){glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//esto

64

glColor3f (1.0, 0.5, 0.4);//primer circulocirculo(400,400,150); glColor3f (0.4, 0.7, 0.2);circulo(400,400,100);

glColor3f (1.0, 0.5, 0.4);// segundo circulocirculo(400,650,150); glColor3f (0.4, 0.7, 0.2);circulo(400,650,100);//bolitas glColor3f (0.0, 0.0, 0.0); if(a>=6.15 && a<12.40){circulo(400 -sin(a) * 125,400 +cos(a) * 125,10);a=a+0.1;}else{circulo(400 -sin(b)* 125,650 +cos(b)* -125,10);b=b+0.1;if(b>12.40) (a=6.15, b=6.15);}glFlush(); //forzar dibujadoglutSwapBuffers(); //y esto

Salida:

65

66

Practica No.13: Semáforo

Descripción: En esta práctica vamos a realizar un semáforo en el cual el semáforo vaya cambiando los colores como lo es un semáforo de realidad.


Código:

67

void dibuja(void) //funcion dibuja{glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //borra pantallaglColor3f(0.1 , 0.0 , 0.4);// semaforo parte grandeglColor3f(0.0,0.0,0.0);glBegin(GL_QUADS);glVertex2i(200,350);glVertex2i(350,350);glVertex2i(350,650);glVertex2i(200,650);// parte delgadaglVertex2i(250,100);glVertex2i(300,100);glVertex2i(300,350);glVertex2i(250,350);glEnd(); // lineas del semaforoglLineWidth(5);glColor3f(1.0,1.0,1.0);glBegin(GL_LINES);glVertex2i(200,450);glVertex2i(350,450);glVertex2i(200,550);glVertex2i(350,550);// lineas de contornoglVertex2i(200,350);glVertex2i(200,650);glVertex2i(200,650);glVertex2i(350,650);glVertex2i(350,650);glVertex2i(350,350);glVertex2i(350,350);glVertex2i(200,350);

68

// lineas del contorno del troncoglVertex2i(250,100);glVertex2i(250,350);glVertex2i(250,350);glVertex2i(300,350);glVertex2i(300,350);glVertex2i(300,100);glVertex2i(300,100);glVertex2i(250,100);glEnd();glColor3f(0.0,0.0,0.0);circulo(275,600,40);glColor3f(0.0,0.0,0.0);circulo(275,500,40);glColor3f(0.0,0.0,0.0);circulo(275,400,40);

a=a+1;for(int j=1 ;j<=10000000; j++){}if(a>1 && a<40){glColor3f(1.0,0.0,0.0);circulo(275,600,40);} if(a>40 && a<70){glColor3f(0.8,0.1,0.1);circulo(275,600,40);} if(a>100 && a<130){glColor3f(1.0,0.9,0.0);circulo(275,500,40);

}

69

if(a>70 && a<100){glColor3f(0.2,0.6,0.3);circulo(275,400,40);

} if(a>130 && a<1){glColor3f(1.0,0.0,0.0);circulo(275,600,40);

}

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

glEnd();glFlush(); //forza dibujoglutSwapBuffers(); }

Salida:

70

71

Practica No.14: Cubo 3D

Descripción: En esta actividad realizaremos con funciones en 3D el un cubo el cual tenga movimiento con el mouse y se vea en tercera dimensión.


Código: 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

72

//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 luzglLightfv(GL_LIGHT0,GL_DIFFUSE,(GLfloat []){1.0f,1.0f,1.0f,0.0f}); // Color de la luzglLightfv(GL_LIGHT0,GL_AMBIENT,(GLfloat []){1.0, 1.0, 1.0, 4.0}); // Luz ambienteglLightfv(GL_LIGHT0,GL_POSITION,(GLfloat []){0.0f,12.0f,5.0f,0.0f}); // PosiciÃ³n de la luzglLightfv(GL_LIGHT0,GL_EMISSION,(GLfloat []){0.5,0.5,0.5,1.0});//glShadeModel (GL_SMOOTH);// esferaglPushMatrix();mover();if(malla) creaMalla();if(ejes) creaEjes();//glRotatef(anguloEsfera, 1.0f, 1.0f,0.0f);glColor3f(1.0,1.0,0.0);//RglTranslatef(-8.0,0.0, 0.0);glutSolidCube(2);

73

glTranslatef(3.0,0.0, 0.0);glutSolidCube(2);


glTranslatef(-6.0,3.0, 0.0);glutSolidCube(2);


glTranslatef(3.0,-3.0, 0.0);glutSolidCube(2);



glTranslatef(-3.0,0.0, 0.0);glutSolidCube(2);// AQUI PONES TU NOMBRE

//AQUI//AQUI//AQUI//AQUI//AQUI//AQUI//AQUI//AQUIglPopMatrix ();glFlush();glutSwapBuffers ();//anguloEsfera+=2.0f;

74

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

Salida:

Practica No.15: Nombre 3D

75

Descripción: En esta actividad realizaremos con funciones en 3D el nombre de nosotros en cual tenga movimiento con el mouse y se vea en tercera dimensión.


Código: void dibuja( void ){glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

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

76

glEnable(GL_LIGHTING); // Activamos la iluminaciÃ³nglEnable(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 luzglLightfv(GL_LIGHT0,GL_DIFFUSE,(GLfloat []){1.0f,1.0f,1.0f,0.0f}); // Color de la luzglLightfv(GL_LIGHT0,GL_AMBIENT,(GLfloat []){1.0, 1.0, 1.0, 4.0}); // Luz ambienteglLightfv(GL_LIGHT0,GL_POSITION,(GLfloat []){0.0f,12.0f,5.0f,0.0f}); // PosiciÃ³n de la luzglLightfv(GL_LIGHT0,GL_EMISSION,(GLfloat []){0.5,0.5,0.5,1.0});//glShadeModel (GL_SMOOTH);// esferaglPushMatrix();mover();if(malla) creaMalla();if(ejes) creaEjes();//glRotatef(anguloEsfera, 1.0f, 1.0f,0.0f);glColor3f(1.0,1.0,0.0);//R

77

glTranslatef(-8.0,0.0, 0.0);glutSolidCube(1);glTranslatef(0.0,1.0, 0.0);glutSolidCube(1);glTranslatef(0.0,1.0, 0.0);glutSolidCube(1);glTranslatef(0.0,1.0, 0.0);glutSolidCube(1);glTranslatef(0.0,1.0, 0.0);glutSolidCube(1);glTranslatef(0.0,1.0, 0.0);glutSolidCube(1);glTranslatef(0.0,1.0, 0.0);glutSolidCube(1);

glTranslatef(1.0,0.0, 0.0);glutSolidCube(1);glTranslatef(1.0,0.0, 0.0);glutSolidCube(1);glTranslatef(1.0,0.0, 0.0);glutSolidCube(1);glTranslatef(1.0,0.0, 0.0);glutSolidCube(1);

glTranslatef(-3.0,-3.0, 0.0);glutSolidCube(1);

glTranslatef(5.0,3.0, 0.0);glutSolidCube(1);glTranslatef(0.0,-1.0, 0.0);glutSolidCube(1);glTranslatef(0.0,-1.0, 0.0);glutSolidCube(1);glTranslatef(0.0,-1.0, 0.0);glutSolidCube(1);

78

glTranslatef(0.0,-1.0, 0.0);glutSolidCube(1);glTranslatef(0.0,-1.0, 0.0);glutSolidCube(1);glTranslatef(0.0,-1.0, 0.0);glutSolidCube(1);

glTranslatef(1.0,0.0, 0.0);glutSolidCube(1);glTranslatef(1.0,0.0, 0.0);glutSolidCube(1);glTranslatef(1.0,0.0, 0.0);glutSolidCube(1);

glTranslatef(-2.0,3.0, 0.0);glutSolidCube(1);


glTranslatef(2.0,0.0, 0.0);glutSolidCube(1);glTranslatef(0.0,-1.0, 0.0);glutSolidCube(1);glTranslatef(0.0,-1.0, 0.0);glutSolidCube(1);glTranslatef(0.0,-1.0, 0.0);glutSolidCube(1);glTranslatef(0.0,-1.0, 0.0);glutSolidCube(1);glTranslatef(0.0,-1.0, 0.0);

79

glutSolidCube(1);glTranslatef(0.0,-1.0, 0.0);glutSolidCube(1);


glTranslatef(0.0,-1.0, 0.0);glutSolidCube(1);glTranslatef(0.0,-1.0, 0.0);glutSolidCube(1);

glTranslatef(-1.0,0.0, 0.0);glutSolidCube(1);glTranslatef(-1.0,0.0, 0.0);glutSolidCube(1);




glTranslatef(1.0,-1.0, 0.0);glutSolidCube(1);// AQUI PONES TU NOMBRE

//AQUI

80

//AQUI//AQUI//AQUI//AQUI//AQUI//AQUI//AQUIglPopMatrix ();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);}

Salida:

81

82

Practica Extra: La pirámide

Descripción: En esta práctica debemos de realizar una pirámide con 10 cuadros y que vayan disminuyendo, con una función en especial y ponerle líneas de esquina a esquina.


Código: void dibuja(void) //funcion dibuja{ int i,a=20;glClear(GL_COLOR_BUFFER_BIT); //borra pantallaglColor3f(1.0 , 1.0 , 0.0);glBegin(GL_LINES);

83

//valor inicial --- valor final o condicion --- incrementofor(i=1;i<=10;i++){//abajoglVertex2i(300-a*i,300-a*i);glVertex2i(320+a*i,300-a*i);//derechaglVertex2i(320+a*i,300-a*i);glVertex2i(320+a*i,320+a*i);//izquierdaglVertex2i(300-a*i,300-a*i);glVertex2i(300-a*i,320+a*i);//arribaglVertex2i(300-a*i,320+a*i);glVertex2i(320+a*i,320+a*i);}glEnd();glBegin(GL_LINES);glColor3f(1.0,1.0,0.0);glVertex2i(120,120);glVertex2i(100,100);






84












glVertex2i(420,200);

85

glVertex2i(440,180);




Salida:

Manual de practicas segundo parcial

Education