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.

Previo 3.

1. ¿Qué es una composición de transformaciones?

Una matriz de transformación describe todas las transformaciones (traslación, escalado, rotación, deformación) que modifican la matriz de un determinado objeto. Para poder animar o mover un objeto dentro del ambiente en que esta descrito es necesario realizar transformaciones succesivas que modifiquen la matriz que describe dicho objeto, a esto se le conoce como composicion de transformaciones.

• La composición de transformaciones se realiza mediante el producto de matrices

• Se pueden obtener los valores de la transformación a partir de la matriz: desplazamiento, escala y giro.

2. ¿Afecta el orden en el cual se aplican las transformaciones sobre un vector o conjunto de vectores?, ¿por qué?

El orden de las transformaciones es importante. En general, un orden de rotación, ajuste de escala y traslación no es lo mismo que un orden de ajuste de escala, rotación y traslación. Análogamente, el orden de multiplicación de matrices es importante. En general, ABC no es lo mismo que BAC.

3. Es lo mismo:

glRotatef(30.0,1.0,0.0,0.0);

gltranslate(1,1,1);

glScalef(2.0,2.0,2.0);

cubo();

qué:

cubo();

glRotatef(30.0,1.0,0.0,0.0);
gltranslate(1,1,1);
glScalef(2.0,2.0,2.0);

o qué:

glScalef(2.0,2.0,2.0);

glRotatef(30.0,1.0,0.0,0.0);
gltranslate(1,1,1);
glScalef(2.0,2.0,2.0);

cubo();

No es el mismo resultado, ya que en algunos se llama primero a la figura y después se transforma, y en otra sección se aplican transformaciones y luego se llama a la figura, además como se mencionó antes, si importa el orden de las transformaciones.

4. ¿Qué es un modelado jerárquico?

Es la aplicación de límites de conectividad (o colocación relativa) entre objetos organizados en una estructura de árbol.

Un tipo de modelo jerárquico común usado en gráficas tiene objetos que estan conectados en sus extremos por cadenas de extremidades.

5. ¿Cómo se modela jerarquicamente el humanoide?

Primero se modela el cuadro central, es decir el cuerpo, de ahi se van modelando los brazos, las manos. También de ahi se modelan las extremidades inferiores, y la cabeza.

Previo 2. OPENGL y modelado geométrico.

1. Investigue el uso, parámetros y variantes de los comandos OPENGL.

glVertex. Especifica un vértice para el uso en la descripción de un objeto geométrico. El número de coordenadas puedeser de 2 (x,y), 3 (x,y,z) y 4 (x,y,z,w).

glBegin() . Marca el inicio de una lista de vértices que describen una primitiva geométrica.El tipo de primitiva está indica por el cual puede tener uno de los siguientes valores.

glEnd(). Marca el final de una lista de vértices.

glPushMatrix(). Empuja todas las matrices un nivel hacia abajo e introduce la matriz actual. Si hay demasiadas matrices entonces se generará un error.

glPopMatrix(). Saca la primera matriz de la pila, por lo tanto la segunda pasa a ser la primera. Los contenidos de la primera matriz son eliminados. Si la pila contiene una sola matriz, entonces se generará un error.

glTranslate. Variables: TYPE x, TYPE y, TYPE z. Multiplica la matriz actual por una matriz de traslación que mueve.

glRotate. Parámetros: TYPE angle,TYPE x, TYPE y, TYPE z. Multiplica la matriz actual por una matriz de rotación que rota el objeto en ladirección de las agujas del reloj sobre el radio de origen en el punto x,y,z.

glScale. Variables: TYPE x, TYPE y, TYPE z .Multiplica la matriz actual por una matriz que cambia el tamaño del objeto a lo largo de los ejes. Las coordenadasx, y, z de cada objeto es multiplicada por los parámetros x, y, z.

glClear(). Limpia los buffers especificados asignándoles los valores actuales.

glClearColor(). Parámetros: GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha. Establece el color actual que va a aparecer en el fondo de la ventana en modo RGBA. Los valores red, green, blue y alpha están restringidos entre los valores [0,1]. El valor por defecto es (0,0,0,0) negro.

2. Escriba un programa que diuje un tetraedro (puede basarse en el código del cube.c que se encuentra en la distriución del GLUT).

#include
/* La siguiente función limpia el buffer y coloca el tetraedro*/
void tetra() {
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_TRIANGLE_STRIP);
glColor3f(0.5,0.6, 0);
glVertex3f(1, 0, 0);
glColor3f(1, 1, 1); glVertex3f(-1, 0, 1);
glColor3f(0, 0.8, 1);
glVertex3f(1, 0, 1);
glColor3f(0, 0, 0.5);
glVertex3f(0, 0, -1.4);
glColor3f(1, 1, 0);
glVertex3f(0, 0, 0);
glColor3f(1, 1, 0);
glVertex3f(-1, 0, 1);
glEnd();
glFlush();
}

void ini() {
glClearColor(0, 0, 1, 1);
glColor3f(0, 0.6, 1.0);
glEnable(GL_CULL_FACE);/*deshabilita que se dibujencaras posteriores*/
glCullFace(GL_BACK);
glMatrixMode(GL_PROJECTION);/*Se configura la proyección*/
glLoadIdentity();
glFrustum(-2, 2, -1.5,0, 1, 40);/*Se configuran los planos*/
glMatrixMode(GL_MODELVIEW);/*Se configura la vista de la figura*/
glLoadIdentity();
glTranslatef(0, 0, -1);
glRotatef(60, 1, 0, 0);
glRotatef(50, 0, 1,90);
}

int main(int argc, char** argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE GLUT_RGB);/*Se inicial el GLUT*/
glutInitWindowPosition(80, 80); /*aqui se indica la posicion de la ventana*/
glutInitWindowSize(300,250); /*aqui el tamaño de la ventana*/
glutCreateWindow("tria"); /*nombre de la ventana donde se muestra la figura*/
glutDisplayFunc(tetra); /*se manda a llamar la funcion tetra*/
ini();
glutMainLoop();
}

3. Cree un archivo de cabecera, llamelo objetos.h y ahi deposite el código del tetraedro. Siempre tenga a la mano este archivo.

objetos.h

#include
/* La siguiente función limpia el buffer y coloca el tetraedro*/
void tetra() {
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_TRIANGLE_STRIP);
glColor3f(0.5,0.6, 0);
glVertex3f(1, 0, 0);
glColor3f(1, 1, 1);
glVertex3f(-1, 0, 1);
glColor3f(0, 0.8, 1);
glVertex3f(1, 0, 1);
glColor3f(0, 0, 0.5);
glVertex3f(0, 0, -1.4);
glColor3f(1, 1, 0);
glVertex3f(0, 0, 0);
glColor3f(1, 1, 0);
glVertex3f(-1, 0, 1);
glEnd(); glFlush(); }
void ini() {
glClearColor(0, 0, 1, 1);
glColor3f(0, 0.6, 1.0);
glEnable(GL_CULL_FACE);/*deshabilita que se dibujencaras posteriores*/
glCullFace(GL_BACK);
glMatrixMode(GL_PROJECTION);/*Se configura la proyección*/
glLoadIdentity();
glFrustum(-2, 2, -1.5,0, 1, 40);/*Se configuran los planos*/
glMatrixMode(GL_MODELVIEW);/*Se configura la vista de la figura*/
glLoadIdentity();
glTranslatef(0, 0, -1);
glRotatef(60, 1, 0, 0);
glRotatef(50, 0, 1,90); }
int main(int argc, char** argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE GLUT_RGB);/*Se inicial el GLUT*/ glutInitWindowPosition(80, 80); /*aqui se indica la posicion de la ventana*/
glutInitWindowSize(300,250); /*aqui el tamaño de la ventana*/
glutCreateWindow("tria"); /*nombre de la ventana donde se muestra la figura*/ glutDisplayFunc(tetra); /*se manda a llamar la funcion tetra*/
ini();
glutMainLoop();
}

Práctica 1. "Ambiente de trabajo y configuración de proyectos".

1. Describe paso a paso la forma en que se crea un proyecto en VS 2005.

Al entrar a Windows vista debemos asegurarnos de ser administradores, ya que asi evitaremos muchos contratiempos. Posteriormente abrimos VS 2005, nos dirigimos al menú File, eligiendo la opción New, y ahi Project. Dentro de Project se elige C++, se debe expandir esta opción y elegir en Win32, la opción Win32 console aplication.Se debe poner un nombre a la solución que es donde estarán todos nuestros proyectos afines y al proyecto actual, para después elegir Empty Project y luego Finish.

2. ¿Qué pasos hay que seguir para configurar los proyectos que pueden utilizar la librería GLUT?

Se deben descargar los siguientes archivos de www.opengl.com/codingresources/libraries : GLUT 3.7 Source Code Download for Win32 y Pre-compiled Win32 for Intel GLUT 3.7 DLLs for Windows 95 & NT y descargarlos en Mis Documentos. Luego se debe crear una carpeta que contenga otras carpetas: incude, dll, lib. Después de descomprimir los archivos de Glut, de la carpeta glutdll37 copio los .dll en la carpeta dll, y los .lib en la carpeta lib. Dentro de la carpeta include, creamos una carpeta llamada GL, en la cual colocamos el archivo glut.h. En las propiedades del archivos se debe elegir Linker en General se tiene la opción Aditional Library Directories, en donde se coloca la ruta de la carpeta lib. También en propiedades, se elige en C/C++ la opción aditional include directories y se especifica la ruta de la carpeta include.

3.¿Cuál es la diferencia de crear un proyecto C++ console aplication y un proyecto C++ en Win32 proyect?

La diferencia básica es que una aplicación de console es para utilizarse en una consola, como MS-DOS, y las de Win32 se ejecutan en Windows.

4.¿Cuál es la diferencia entre ejecutar la aplicación recién creada en modo debug y sin debug?

Al ejecutar en modo debug, se tiene información de errores en el tiempo de la ejecución. Sin debug, no se tiene esta información.

5.¿Qué es una variable de entorno?¿Cómo se puede crear y/o modificar en Windows Vista?

El entorno es una área de memoria, la cual tiene variables que contienen información que usa el sistema para poder funcionar, un ejemplo es PATH que tiene la dirección de archivos importantes para el sistema. Se modifican en el panel de control, en Sistema, entrando en opciones avanzadas.