Previo 7.

1.¿Que es "shading" (sombreado) en términos de computación gráfica?
OpenGL nos permite elegir entre dos métodos de sombreado, de caras planas y suaves. Para elegir el método de sombreado, usaremos la función glShadeModel con parámetro GL_FLAT para caras planas, y GL_SMOOTH para el suave.
OpenGL, excepto cuando renderiza NURBS y otras funciones gráficas de alto nivel, no genera automáticamente normales, así que tenemos que especificárselas nosotros mismos.
Para especificar la normal actual, basta con hacer una llamada a la función glNormal3f(nx, ny, nz). A partir de ese momento, cualquier vértice que se renderice se supondrá que tiene como normal (nx, ny, nz)
Esta normal es deseable que esté normalizada.
Con el modo de sombreado suave activo, dependiendo de si definimos la misma normal para toda la carao para cada vértice, podemos obtener un sombreado de caras planas o de tipo gouraud. Para obtener un sombreado de tipo gouraud, bastan con definir a cada vértice la normal media de las caras a las que pertenece. Esto es especialmente interesante cuando queremos renderizar superficies curvas, mientras que para renderizar poliedros es más aconsejable asignar una única normal para todos los vértices de una misma cara.

2¿Qué es y cómo se declara y usa en OpenGL/GLUT
-Una fuente de luz?
-Un material?
-Una textura?

TEXTURAS
Cargando texturas en memoria
El proceso de cargar la textura en memoria, no es propio de OpenGL. Se tiene que realizar una función externa. Existen algunas limitaciones que la librería impone. Las dimensiones de todas las texturas que carguen tienen que ser potencias de 2, como por ejemplo 64x64, 128x64, etc.
Se tiene que tener en cuenta que si se debe estar dibujando en RGB, sin color indexado, o bien cargando texturas en formato RGB. Si se carga una imagen GIF, que tiene color indexado, se tiene que programar una función extra para convertirla a RGB.. Sea cuál sea el método, al final se tendrá un puntero a un segmento de memoria que contiene la imagen:
unsigned char *textura;
Es importante también guardar las propiedades de la textura, en concreto sus dimensiones de ancho y alto, así como su profundidad en bits. Si estamos trabajando en RGB, la profundidad será 24bits.
Los pasos a seguir son:
• Determinamos el tamaño
• Calculamos la memoria que será necesaria
• Reservamos memoria
• Generación de archivo TGA el cual viene en formato RGB. Si no está en este formato se deberá realizar la conversión.
Una vez tenemos la imagen cargada en memoria, los pasos a seguir son:
• Generar la referencia para la textura. [glGenTextures (1, &textura);] Con el GLuint textura referenciaremos a "esa textura". Si se quiere tener más, se debe crear un array de GLuint. El 1 significa que sólo generamos una textura.
• Referenciamos esa textura: [glBindTexture (GL_TEXTURE_2D, textura);]. Esta función dice que ahora en adelante, todas las operaciones que afecten al manejo de texturas se aplicarán sobre esa textura. En este caso es una etextura 2D
• Especificamos los filtros para esa textura:
o glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
• OpenGL puede aplicar filtros a las texturas para mejorar su visualización. La primer línea especifica el filtro a utilizar en caso de que las textura se vea más grande de lo que en realidad es (Aumento). La segunda, especifica el filtro para el caso de que la textura se vea más pequeña de lo que en realidad es. Aquí utilizamos un filtro LINEAR para el 1er caso y del segundo hablaremos más adelante. Otro valor que podríamos haber utilizado es el GL_NEAREST, que es un filtro peor pero más rápido
• Creamos la textura por medio de MIPMAPS para mejor rendimiento, en vez de filtrar las textura dinámicamente, al crear un mipmap, creamos varias texturas de diferentes tamaños (del original hacia más pequeño). OpenGL, decidirá en función de lo lejano que esté el objeto con esa textura, de qué mipmap utilizar.
• Por ultimo, sólo hace falta habilitar el empleo de texturas con:glEnable(GL_TEXTURE_2D);En la función init_gl.

TEXTURAS EN UNA SUPERFICIE
•Al mapear la imagen de textura sobre una superficie, los texels no se van a corresponder exactamente con los pixels
Magnificación : Si la superficie es mayor que la textura, cada pixel se corresponderá con un trozo pequeño de texel

Minificación : Si la superficie es menor que la textura, cada pixel se corresponderá con una conjunto de texels contiguos•
Texels

Pixeles

Modos de mapeo
•Para establecer el modo de mapeo:
• glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GLint valor)
• donde valor puede tomar 3 valores:
–GL_DECAL: el valor del texel se copia directamente al pixel
–GL_MODULATE: el valor del texel se escala por el color del objeto
–GL_BLEND: el valor del texel se usa para interpolar entre el color del objeto y un color constante definido para la textura, mediante la función
• glTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_COLOR,GLfloat color[4])


MODOS DE APLICACIÓN DE TEXTURAS

GL TEXTURE WRAP S
Establece el parámetro wrap para la coordenada de textura s a GL_CLAMP, GL_CLAMP_TO_EDGE, o GL_REPEAT. GL_CLAMP causa que las coordenadas s estén limitadas al rango [0,1] y es útil para prevenir artefactos de envoltura (compresión?) cuando se mapea una única imagen en un objeto. GL_CLAMP_TO_EDGE causa que las coordenadas s se limiten al rango [1/2n, 1-(1/2n)i], donde n es el tamaño de la textura en la dirección del límite. GL_REPEAT causa que la parte entera de s se ignore; el GL utiliza solo la parte fraccionaria, creando por lo tanto un patrón repetitivo. Los elementos de textura de borde son accesados solo si la envoltura se establece a GL_CLAMP. Inicialmente, GL_TEXTURE¬_WRAP_S se establece a GL_REPEAT.

GL TEXTURE WRAP T
Establece el parámetro wrap para la coordenada de textura t a GL_CLAMP, GL_CLAMP_TO_EDGE, o GL_REPEAT (véase arriba). Inicialmente, GL_TEXTURE_WRAP_T se establece a GL_REPEAT.


3¿Cuales son los atributos/características que se pueden declarar en OpenGL/GLUT para manejo de:
-Luces
-Materiales
-Texturas
y con que funciones se hace esto?

En OpenGL se pueden definir tres formas de luz distintas, estas son: AMBIENTE, DIFUSA y ESPECULAR

AMBIENTE.- la luz llega de todas las direcciones de forma distribuida y es reflejada de igual forma por los polígonos de la escena.

DIFUSA.- la luz llega de una fuente puntual en particular y toca la superficie con una intensidad que depende de la cara hacia la cual llega la luz, este tipo de iluminación es la que mejor define el contorno en los objetos 3D

ESPECULAR.- es la luz emitida desde el objeto de forma distribuida en todas direcciones.


La luz tiene las propiedades de color, posición y dirección. El color que las luces tendrán esta determinado por las tres componentes de color que maneja OpenGL, rojo, verde y azul. El comando utilizado para especificar todas las propiedades de la luz es glLiht(), este comando tiene tres argumentos para identificar la luz que se está utilizando, la propiedad y el valor deseado para la propiedad.

Después de definir las características de las luces se encienden con el comando glEnable(nombre de la fuente de luz a activar). También existe una función para desactivar la iluminación, que es glDisable y desactiva la luz especificada.
Las características de la luz por default para glLight son:
GL_DIFFUSE Y GL_SPECULAR sólo se usan con la primera fuente de luz.
GL_AMBIENT: Define los valores de la luz ambiental. Valor RGBA, su valor por defecto es 0.0,0.0,0.0,1.0)
GL_DIFFUSE: Define los valores de la luz difusa. Valor RGBA. su valor por defecto es (1.0,1.0,1.0,1.0)
GL_SPECULAR: Define los valores de la luz especular. Valor RGBA. Su valor por defecto es (1.0,1.0,1.0,1.0)
GL_POSITION: Posición de la luz, en coordenadas { x, y, z, w }, su valor por defecto es (0.0,0.0,1.0,0.0)
GL_SPOT_DIRECTION: Vector de dirección de la luz, en coordenadas { x, y, z }, su valor por defecto es (0.0,0.0,-1.0)
GL_SPOT_EXPONENT: Representa la concentración de la intensidad de la luz. Valor escalar, por defecto 0.
GL_SPOT_CUTOFF: Ángulo del cono de luz. Valor escalar, por defecto 180.
GL_CONSTANT_ATTENUATION: Atenuación constante a aplicar a la luz según la distancia. Valor escalar, por defecto 1
GL_LINEAR_ATTENUATION: Atenuación lineal a aplicar a la luz según la distancia. Valor escalar, por defecto 0
GL_QUADRATIC_ATTENUATION: Atenuación cuadrática a aplicar a la luz según la distancia. Valor escalar, por defecto 0

La luz es un punto focal el cual ilumina los objetos en un cierto rango, es un punto muy definido y fácil de encontrar, en cambio la iluminación da una intensidad de luz en un rango más amplio dando la sensación de que no hay un punto focal donde la luz es emitida, la iluminación es un tipo de luz la cual no incide directamente en los objetos.

Para habilitar y deshabilitar a uno de los puntos de iluminación se utilizan los comandos glEnable(nombre_iluminación) y glDisable(nombre_iluminación). La fuente de luz es creada con glLightfv (GL_LIGHT0, GL_AMBIENT, luz ambiental);

Dependiendo de las propiedades de los materiales la luz tiene un efecto distinto sobre ellos.
Estas propiedades se definen con glMaterial:
void glMaterial(GLenum cara, GLenum nombre, TYPOparam);
El argumento cara, determina la cara del objeto en la que aplicamos las propiedades, tiene los siguientes valores:
GL_FRONT,GL_BACK,GL_FRONT_AND_BACK.
El siguiente indica la propiedad que va utilizarse para dicha cara, puede ser:
GL_AMBIENT, GL_DIFFUSE, GL_AMBIENT_AND_DIFFUSE, GL_SPECULAR, GL_SHININESS, GL_EMISSION, GL_COLOR_INDEXES.
El ultimo parámetro especifica un puntero al valor o valores que el parámetro nombre tomara.
• GL_AMBIENT .- color ambiente del material, sus valores por defecto son (0.2, 0.2, 0.2, 1.0).
• GL_DIFFUSE .- color difuso del material, sus valores por defecto son (0.8, 0.8, 0.8, 1.0).
• GL_AMBIENT_AND_DIFFUSE .- color ambiente y difuso del material
• GL_SHININESS.- exponente especular, su valor por defecto es 0.
• GL_EMISSION.- el color de emisión del material, sus valores por defecto son (0.0, 0.0, 0.0, 1.0).
• GL_COLOR_INDEXES.- índice de color ambiente, difuso y especular, sus valores por defecto son (0, 1, 1).

Previo 6

¿Cómo se dibuja texto con GLUT? ¿Cambia el dibujo de texto con freeGLUT y OpenGLUT? ¿Porque?

El manejo de fuentes de texto es una de las partes débiles de OpenGL. Su implementación es complicada ya que la biblioteca GL sólo proporciona funciones muy primitivas para trazado de bitmaps que obligan a disponer de una librería propia de bitmaps para los caracteres. GLUT va un poco más allá y dispone de unas pocas funciones que permiten renderizar texto en pantalla.
GLUT resuelve un poco el dilema de usar texto en OpenGL. Proporciona glutBitmapCharacter, que traza un único carácter en la posiciçón especificada por glRasterPos. He añadido unas pocas funciones, drawString(), y drawStringBig() que hacen la vida un poco mejor al trazar cadenas de caracteres.

¿Cómo funcionan y cúales son los parámetros de los comandos ?

glutBitmapCharacter(*font vacío, carácter interno); Traza un único caracter en la posición especificada. Los parámetros son la fuente a usar, y el caracter que va a escribir.

glutStrokeCharacter(*font vacío, carácter interno); Rinde un carácter del movimiento que usa OpenG. Tiene los mismos parámetros que el anterior caso.

Escriba un programa que dibuje su nombre y numero de cuenta en la pantalla

void escribe(char * s)
{
int i;
for(i=0;
glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18,s[i]);
}

void disp(void){
glClear(GL_COLOR_BUFFER_BIT);glFlush();
}
int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA GLUT_SINGLE);
glutInitWindowSize(500,500);
glutInitWindowPosition(100,100);
glutCreateWindow("TEXTO");
glClearColor(0.0,0.0,0.0,0.0);
glutDisplayFunc(disp);
glutMainLoop();
}

Reporte práctica 5

¿Qué es diseño orientado a eventos?

Es un diseño que se basa en la ocurrencia de eventos, es decir, esperar que el usuario realice una acción en la ventana (un click, oprimir una tecla, o el simple movimiento del raton), para que el programa interactue como respuesta a ese evento realizando una acción.



¿Qué utilidad tiene el manejo de eventos en el desarrollo de aplicaciones gráficas?



Los lenguajes visuales orientada al evento y con manejo de componentes dan al usuario que no cuenta con mucha experiencia en desarrollo, la posibilidad de construir sus propias aplicaciones utilizando interfaces gráficas sobre la base de ocurrencia de eventos.Para soportar este tipo de desarrollo interactuan dos tipos de herramientas, una que permite realizar diseños gráficos y , un lenguaje de alto nivel que permite codificar los eventos. Con dichas herramientas es posible desarrollar cualquier tipo de aplicaciones basadas en el entorno.



Escriba un programa en el cual se tomen las coordenadas y se dibuje un punto,
- Cada 2 puntos acumulados dibuje una línea

#include
#include
#include
using namespace std;
int point1[]={10,10};
int point2[]={50,50};
int click=0;

void onMouse(int button, int state, int x, int y)
{
if ( (button == GLUT_LEFT_BUTTON) && (state == GLUT_DOWN) ) {
click++;
if (click==1){
point1[0]=x;
point1[1]=y;
}
if (click==2){
point2[0]=x;
point2[1]=y;
glutPostRedisplay();
}
if (click==3){
point1[0]=x;
point1[1]=y;
click=1; }

if ( (button == GLUT_RIGHT_BUTTON) && (state == GLUT_DOWN) ) {
glClear(GL_COLOR_BUFFER_BIT);
}

}
}

void disp(void){
glutMouseFunc(onMouse);
glClear(GL_COLOR_BUFFER_BIT); // se limpia pantalla
glColor3f(110.0/255.0,191.0/255.0,116.0/255.0);
glBegin(GL_LINES); //para crear líneas
//dibujo de linea entre puntos
glVertex2f(-1.0+((float)point1[0]/250.0),1.0-((float)point1[1]/250.0));
glVertex2f(-1.0+((float)point2[0]/250.0),1.0-((float)point2[1]/250.0));
glEnd();
glFlush();
}

int main(int argc, char **argv){

glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA GLUT_SINGLE);
glutInitWindowSize(500,500);

glutInitWindowPosition(100,100);

glutCreateWindow("LINEAS");

glClearColor(0.0,0.0,0.0,0.0);
glutDisplayFunc(disp);

glutMainLoop();
}

- Cada tres puntos acumulados dibuje un triangulo

#include
#include
#include
using namespace std;
int point1[]={10,10};
int point2[]={50,50};
int point3[]={10,50}
int click=0;

void onMouse(int button, int state, int x, int y)
{
if ( (button == GLUT_LEFT_BUTTON) && (state == GLUT_DOWN) ) {
click++;
if (click==1){
point1[0]=x;
point1[1]=y;
}
if (click==2){
point2[0]=x;
point2[1]=y;
glutPostRedisplay();
}
if(click==3){
point3[0]=x;
point3[1]=1;
glutPostRedisplay();
}

if (click==4){
point1[0]=x;
point1[1]=y;
click=1;
}
if ( (button == GLUT_RIGHT_BUTTON) && (state == GLUT_DOWN) ) {
glClear(GL_COLOR_BUFFER_BIT);
}
}
}

void disp(void){
glutMouseFunc(onMouse);
glClear(GL_COLOR_BUFFER_BIT); // se limpia pantalla
glColor3f(110.0/255.0,191.0/255.0,116.0/255.0);
glBegin(GL_LINES); //para crear líneas
//dibujo de linea entre puntos
glVertex2f(-1.0+((float)point1[0]/250.0),1.0-((float)point1[1]/250.0));
glVertex2f(-1.0+((float)point2[0]/250.0),1.0-((float)point2[1]/250.0));
glvertex2f(-1.0+((float)point3[0]/250.0),1.0-((float)point3[1]/250.0));
glEnd();
glFlush();
}

int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA GLUT_SINGLE);
glutInitWindowSize(500,500);

glutInitWindowPosition(100,100);

glutCreateWindow("LINEAS");

glClearColor(0.0,0.0,0.0,0.0);
glutDisplayFunc(disp);

glutMainLoop();
}

Previo 5.

Escriba una aplicación que usando la libreria GLUT detecte que se ha realizadoun click con el botón derecho del mouse sobre la ventana principal e imprima la coordenadas del mouse en la sálida estándar. Cuando se haga click en el botón izquierdo, cierre la aplicación. Nota: Usar glutMouseFunc().

void Mouse(int button, int state, int x, int y) {
if ( (button == GLUT_RIGHT_BUTTON && state == GLUT_DOWN) ) {
printf("Botón derecho\n");
printf("X=%f\n", (GLfloat)GLsizei x);
printf("Y=%f\n", (GLfloat)GLsizei y);
cout << "\nPOSICION X:" <<>
cout << "\nPOSICION Y:" << y;
}

if ( (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) )
{
exit(0);
}

}

void disp(void){
glClear(GL_COLOR_BUFFER_BIT);
glutMouseFunc(Mouse);
glFlush();
}

int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA GLUT_SINGLE);
glutInitWindowSize(500,500);
glutInitWindowPosition(100,100);
glutCreateWindow("RATON");
glClearColor(0.0,0.0,0.0,0.0);
glutDisplayFunc(disp);
glutMainLoop();
}

¿Qué comandos para manejo de eventos nos proporciona GLUT?
Un evento es algo que el usuario puede hacer, dentro de una ventana.
Las funciones más comunes que GLUT llama automáticamente al detectar un evento son:

glutMouseFunc(función de control de eventos con el ratón);

glutMotionFunc(función de control de eventos de movimiento del ratón);

glutReshapeFunc(función de control del cambio de tamaño de la ventana de visualización);

glutKeyboardFunc(función de control de eventos con el teclado);

glutDisplayFunc(función de control del render);

glutIdleFunc(función que se activa cuando no se hace nada);

Previo 5.

Previo

Reporte Práctica 4.

1. Describa la ventajas y desventaja de construir de manera jerárquica escenas


Dentro de las ventahas esta de que los efectos sobre objetos relacionados se propaguen automáticamente a través de ciertos grupos. Esté método (jerárquico) es muy útil cuando se asocia a transformaciones geométricas ya que sería demasiado complicado rotar, trasladar y escalar una y otra vez algunos objetos que están relacionados, en vez de esto es más fácil encontrar la relación que existe entre dichos objetos y solo tener que hacer pocas transformaciones para lograr los resultados deseados.

2. Escriba un programa que construya de manera jerárquica una escena en la que haya 3 humanoides.

void init(void){

glClearColor (0.0, 0.0, 0.0, 0.0);

glShadeModel (GL_FLAT);

}

void cubohum(void){

glBegin(GL_LINE_LOOP);

glVertex3f(0.5,0.5,0.5);

glVertex3f(-0.5,0.5,0.5);

glVertex3f(-0.5,-0.5,0.5);

glVertex3f(0.5,-0.5,0.5);

glEnd();

glBegin(GL_LINE_LOOP);

glVertex3f(-0.5,0.5,-0.5);

glVertex3f( 0.5,0.5,-0.5);

glVertex3f(0.5,-0.5,-0.5);

glVertex3f(-0.5,-0.5,-0.5);

glEnd();

glBegin(GL_LINE_LOOP);

glVertex3f(-0.5,0.5,0.5);

glVertex3f(-0.5,0.5,-0.5);

glVertex3f(-0.5,-0.5,-0.5);

glVertex3f(-0.5,-0.5,0.5);

glEnd();

glBegin(GL_LINE_LOOP);

glVertex3f(0.5,0.5,0.5);

glVertex3f(0.5,-0.5,0.5);

glVertex3f( 0.5,-0.5,-0.5);

glVertex3f(0.5,0.5,-0.5);

glEnd();

glBegin(GL_LINE_LOOP);

glVertex3f(-0.5,0.5,-0.5);

glVertex3f(-0.5,0.5,0.5);

glVertex3f(0.5,0.5,0.5);

glVertex3f( 0.5,0.5,-0.5);

glEnd();

glBegin(GL_LINE_LOOP);

glVertex3f(0.5,-0.5,-0.5);

glVertex3f(-0.5,-0.5,-0.5);

glVertex3f(-0.5,-0.5,0.5);

glVertex3f(0.5,-0.5,0.5);

glEnd();

}

void torso (int posx,int posy,int posz){

glTranslatef(0.0,1.5,0.0);

glScalef (0.5, 0.5, 0.5);

glRotatef(posx,1.0,0.0,0.0);

glRotatef(posy,0.0,1.0,0.0);

glRotatef(posz,0.0,0.0,1.0);

glTranslatef(0.0,0.0,0.0);

glPushMatrix();

glScalef (2.0, 3.0, 1.0);

cubohum();

glPopMatrix();

}

void rostro (int cuey){

glPushMatrix();

glRotatef(cuey,0.0,1.0,0.0);

glTranslatef(0.0,2.0,0.0);

cubohum();

glPopMatrix();

}

void brazoder (int hombrodx,int hombrody,int hombrodz,int cododz){

glPushMatrix();

glTranslatef(1.0,1.0,0.0);

glRotatef(hombrodx,1.0,0.0,0.0);

glRotatef(hombrody,0.0,1.0,0.0);

glRotatef(hombrodz,0.0,0.0,1.0);

glTranslatef(1.0,0.25,0.0);

glPushMatrix();

glScalef(2.0,0.5,1.0);

cubohum();

glPopMatrix();

glTranslatef(1.0,0.0,0.0);

glRotatef(cododz,0.0,0.0,1.0);

glTranslatef(1.0,0.0,0.0);

glPushMatrix();

glScalef(2.0,1.0,1.0);

cubohum();

glPopMatrix();

glTranslatef(1.25,0.0,0.0);

glPushMatrix();

glScalef(0.5,0.5,1.0);

cubohum();

glPopMatrix();

glPopMatrix();

}

void brazoizq (int hombroix,int hombroiy,int hombroiz,int codoiz){

glPushMatrix();

glTranslatef(-1.0,1.0,0.0);

glRotatef(hombroix,1.0,0.0,0.0);

glRotatef(hombroiy,0.0,1.0,0.0);

glRotatef(hombroiz,0.0,0.0,1.0);

glTranslatef(-1.0,0.25,0.0);

glPushMatrix();

glScalef(2.0,0.5,1.0);

cubohum();

glPopMatrix();

glTranslatef(-1.0,0.0,0.0);

glRotatef(codoiz,0.0,0.0,1.0);

glTranslatef(-1.0,0.0,0.0);

glPushMatrix();

glScalef(2.0,1.0,1.0);

cubohum();

glPopMatrix();

glTranslatef(-1.25,0.0,0.0);

glPushMatrix();

glScalef(0.5,0.5,1.0);

cubohum();

glPopMatrix();

glPopMatrix();

}

void piernader(int muslodx,int muslody,int muslodz,int rodilladx,int piedy){

glPushMatrix();

glTranslatef(0.665,-1.5,0.0);

glRotatef(muslodx,1.0,0.0,0.0);

glRotatef(muslody,0.0,1.0,0.0);

glRotatef(muslodz,0.0,0.0,1.0);

glTranslatef(0.0,-1.2,0.0);

glPushMatrix();

glScalef(0.68,2.4,1.0);

cubohum();

glPopMatrix();

glTranslatef(0.0,-1.2,0.0);

glRotatef(rodilladx,1.0,0.0,0.0);

glTranslatef(0.0,-1.2,0.0);

glPushMatrix();

glScalef(1.0,2.4,1.0);

cubohum();

glPopMatrix();

glTranslatef(0.0,0.-1.25,0.0);

glRotatef(piedy,0.0,1.0,0.0);

glTranslatef(0.25,-0.35,0.0);

glPushMatrix();

glScalef(1.5,0.75,1.0);

cubohum();

glPopMatrix();

glPopMatrix();

}

void piernaizq(int musloix,int musloiy,int musloiz,int rodillaix,int pieiy){

glPushMatrix();

glTranslatef(-0.665,-1.5,0.0);

glRotatef(musloix,1.0,0.0,0.0);

glRotatef(musloiy,0.0,1.0,0.0);

glRotatef(musloiz,0.0,0.0,1.0);

glTranslatef(0.0,-1.2,0.0);

glPushMatrix();

glScalef(0.68,2.4,1.0);

cubohum();

glPopMatrix();

glTranslatef(0.0,-1.2,0.0);

glRotatef(rodillaix,1.0,0.0,0.0);

glTranslatef(0.0,-1.2,0.0);

glPushMatrix();

glScalef(1.0,2.4,1.0);

cubohum();

glPopMatrix();

glTranslatef(0.0,0.-1.25,0.0);

glRotatef(pieiy,0.0,1.0,0.0);

glTranslatef(-0.25,-0.35,0.0);

glPushMatrix();

glScalef(1.5,0.75,1.0);

cubohum();

glPopMatrix();

glPopMatrix();

}

void humanoides (int px,int py,int pz,int cy,int hdx,int hdy,int hdz,int cdz,int hix,

int hiy,int hiz,int ciz,int mdx,int mdy,int mdz,int rdx,

int pdy,int mix,int miy,int miz,int rix,int piy)

{

torso(px,py,pz);

rostro(cy);

brazoder(hdx,hdy,hdz,cdz);

brazoizq(hix,hiy,hiz,ciz);

piernader(mdx,mdy,mdz,rdx,pdy);

piernaizq(mix,miy,miz,rix,piy);

}

/*Aqui se colocan los tres humanoides*/

void display(void){

glClear (GL_COLOR_BUFFER_BIT);

glColor3f (1.0, 1.0, 1.0);

glLoadIdentity ();

gluLookAt (0.0,0.0,10.0,0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

glPushMatrix();

glScalef(0.5,0.5,0.5);

glRotatef(-45,0.0,1.0,0.0);

glTranslatef(5.0,0.0,2.0);

humanoides(posicionx,posiciony,posicionz,cuelloy,hombroderx,hombrodery,hombroderz,cododerz,

hombroizqx,hombroizqy,hombroizqz,codoizqz,musloderx,muslodery,musloderz,rodilladerx,

piedery,musloizqx,musloizqy,musloizqz,rodillaizqx,pieizqy);

glPopMatrix();

glPushMatrix();

glTranslatef(1.0,1.0,1.0);

glRotatef(15,1.0,0.0,0.0);

glScalef(0.5,-1.5,0.8);

humanoides(posicionx,posiciony,posicionz,cuelloy,hombroderx,hombrodery,hombroderz,cododerz,

hombroizqx,hombroizqy,hombroizqz,codoizqz,musloderx,muslodery,musloderz,rodilladerx,

piedery,musloizqx,musloizqy,musloizqz,rodillaizqx,pieizqy);

glPopMatrix();

glPushMatrix();

glRotatef(20,0.0,1.0,0.0);

glTranslatef(-2.0,-1.0,-3.0);

humanoides(posicionx,posiciony,posicionz,cuelloy,hombroderx,hombrodery,hombroderz,cododerz,

hombroizqx,hombroizqy,hombroizqz,codoizqz,musloderx,muslodery,musloderz,rodilladerx,

piedery,musloizqx,musloizqy,musloizqz,rodillaizqx,pieizqy);

glPopMatrix();

glFlush ();

}

void reshape (int w, int h){

glViewport (0, 0, (GLsizei) w, (GLsizei) h);

glMatrixMode (GL_PROJECTION);

glLoadIdentity ();

glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);

glMatrixMode (GL_MODELVIEW);

}

int main(int argc, char** argv){

glutInit(&argc, argv);

glutInitDisplayMode (GLUT_SINGLE GLUT_RGB);

glutInitWindowSize (800, 800);

glutInitWindowPosition (90, 90);

glutCreateWindow (argv[0]);

init ();

glutDisplayFunc(display);

glutReshapeFunc(reshape);

glutKeyboardFunc(keyboard);

glutMainLoop();

return 0;

Reporte Práctica2.

1. Escriba u programa en el cual:
- Se dibuja un cuadrado.

void cuad() {
glBegin(GL_POLYGON);
glVertex3f(0.6,0.6,0.6);
glVertex3f(-0.6,0.,0.6);
glVertex3f(-0.6,-0.6,0.6);
glVertex3f(0.6,-0.6,0.6);

- Utilizando las llamadas al cuadrado y aplicando rotaciones y transformaciones, dibuje un cubo.

cuad();
glRotatef(30.0,1.0,0.0,0.0);
glTranslatef(0.5,0.5,-0.5);
glScalef(2.0,0.5,1.0);

Se aplican más transformaciones para obtener el cubo.