martes, 20 de marzo de 2007

PRACTICA 3

Humaniode con manos


#include
#include
#include
#include
#include

void mano(float ang,float rpy,float rpz,float rpyf123,float rpyf23,float rpyf3,float rixf123,float rixf23,float rixf3,float rmxf123,float rmxf23,float rmxf3,float raxf123,float raxf23,float raxf3,float rmexf123,float rmexf23,float rmexf3,float rmaz,float rmax,float rmay);

void mueveExtremidades(float abd, float abi, float apd,float api,float x1,float y1,float z1);

void init(void)
{
glClearColor (0.0, 0.0, 1.0, 0.0);
glShadeModel (GL_FLAT);
}

void display(void)
{

glClear (GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 1.0, 1.0);
glLoadIdentity (); /* clear the matrix */
/* viewing transformation */
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glScalef (1.0, 1.0, 1.0); /* modeling transformation */


glPushMatrix();
glScalef(0.1,.6,1.0);
glTranslatef(-21,2.75f,0.0f);
glRotatef(90,0,0,1);
mano(0,1,45,0,0, 45,0,0, 45,0,0, 45,0,0, -20,0,0, -15, 0,1,0 );
glPopMatrix();

glPushMatrix();
glScalef(0.1,.6,1.0);
glTranslatef(21,2.75f,0.0f);
glRotatef(-90,0,0,1);
mano(0,1,45,0,0, 45,0,0, 45,0,0, 45,0,0, -20,0,0, -15, 0,1,0 ,);
glPopMatrix();

mueveExtremidades(8,-8,8,-8,0,0,0);

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

/* ARGSUSED1 */
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
exit(0);
break;
}
}

nt main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (300,230);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();

return 0;
}



void mueveExtremidades(float abd, float abi, float apd,float api,float x1,float y1,float z1)
{
float x,y,z,brazod, brazoi, pied, piei;
x=x1;
y=y1;
z=z1;
brazod=abd;
brazoi=abi;
pied=apd;
piei=api;

glPushMatrix();
//cabeza
glTranslatef(0.0f,2.5f,0.0f);
glutWireCube (0.5);

//tronco
glScalef(2.5,2.5,2.0);
glTranslatef(0.0f,-0.45f,0.0f);
glutWireCube (0.5);
//piernas

glPushMatrix();
glPushMatrix();
//pierna izquierda
glRotatef(piei,x,y,z);
glTranslatef(-0.1f,-0.55f,0.0f);
glScalef(-.3,1.2,1.0);
glutWireCube (0.5);
glPushMatrix();

glTranslatef(0.0f,-0.7f,0.0f);
glutWireCube (0.5);

glPushMatrix();
glTranslatef(0.0f,.35f,0.0f);
glScalef(1.1,.4,1.0);
glutWireCube (0.5);
glPopMatrix();
glPopMatrix();
//pies
glPushMatrix();
glTranslatef(.3f,-1.0f,0.0f);
glScalef(1.6,.2,1.0);
glutWireCube (0.5);
glPopMatrix();
glPopMatrix();

//pierna derecha
glRotatef(pied,x,y,z);
glTranslatef(0.1f,-0.55f,0.0f);
glScalef(-.3,1.2,1.0);
glutWireCube (0.5);
glPushMatrix();

glTranslatef(0.0f,-0.7f,0.0f);
glutWireCube (0.5);

glPushMatrix();
glTranslatef(0.0f,.35f,0.0f);
glScalef(1.1,.4,1.0);
glutWireCube (0.5);
glPopMatrix();
glPopMatrix();

//pies
glTranslatef(-.3f,-1.0f,0.0f);
glScalef(1.6,.2,1.0);
glutWireCube (0.5);


glPopMatrix();
//brazo derecho
glPushMatrix();
glRotatef(brazod,x,y,z);
glTranslatef(0.35f,0.1f,0.0f);
glScalef(0.5,0.4,.5);
glutWireCube (0.5);

glPushMatrix();

glTranslatef(0.4f,0.0f,0.0f);
glScalef(0.5,1.2,1.0);
glutWireCube (0.5);

glPopMatrix();
glTranslatef(0.7f,0.0f,0.0f);
glScalef(.7,1,1.0);
glutWireCube (0.5);
//brazo izquierdo
glPopMatrix();
glRotatef(brazoi,x,y,z);
glTranslatef(-0.35f,0.1f,0.0f);
glScalef(0.5,0.4,.5);
glutWireCube (0.5);

glPushMatrix();
glTranslatef(-0.4f,0.0f,0.0f);
glScalef(0.5,1.2,1.0);
glutWireCube (0.5);

glPopMatrix();
glTranslatef(-0.7f,0.0f,0.0f);
glScalef(.7,1,1.0);
glutWireCube (0.5);
glPopMatrix();


}

void mano(float ang,float rpy,float rpz,float rpyf123,float rpyf23,float rpyf3,float rixf123,float rixf23,float rixf3,float rmxf123,float rmxf23,float rmxf3,float raxf123,float raxf23,float raxf3,float rmexf123,float rmexf23,float rmexf3,float rmaz,float rmax,float rmay)
{


glRotatef(ang,rmax,rmay,rmaz);
glPushMatrix();
//palma

glScalef(4,3,2);
glutWireCube (0.5);
glPopMatrix();

glPushMatrix();
//pulgar
//falange1
glRotatef(rpyf123,0,1,0);
glTranslatef(1.25f,-0.55f,0.0f);
glScalef(1.25,1,1);
glutWireCube (0.5);

//falange2
glRotatef(rpyf23,0,1,0);
glTranslatef(.5f,0.0f,0.0f);
glScalef(1,1,1);
glutWireCube (0.5);

//falange3
glRotatef(rpyf3,0,1,0);
glTranslatef(0.39f,0.0f,0.0f);
glScalef(.5,1,1);
glutWireCube (0.5);

glPopMatrix();

glPushMatrix();
//indice
//falange1
glRotatef(rixf123,1,0,0);
glScalef(1,1.5,1);
glTranslatef(0.75f,0.75f,0.0f);
glutWireCube (0.5);

//falange2
glRotatef(rixf23,1,0,0);
glScalef(1,1.25,1);
glTranslatef(0.0f,0.45f,0.0f);
glutWireCube (0.5);

//falange3
glRotatef(rixf3,1,0,0);
glScalef(1,.5,1);
glTranslatef(0.0f,.75f,0.0f);
glutWireCube (0.5);

glPopMatrix();

glPushMatrix();
//medio
//falange1
glRotatef(rmxf123,1,0,0);
glScalef(1,1.5,1);
glTranslatef(0.25f,0.75f,0.0f);
glutWireCube (0.5);

//falange2
glRotatef(rmxf23,1,0,0);
glScalef(1,1.25,1);
glTranslatef(0.0f,0.45f,0.0f);
glutWireCube (0.5);

//falange3
glRotatef(rmxf3,1,0,0);
glScalef(1,.75,1);
glTranslatef(0.0f,.60f,0.0f);
glutWireCube (0.5);

glPopMatrix();

glPushMatrix();
//Angular
//falange1
glRotatef(raxf123,1,0,0);
glScalef(1,1.25,1);
glTranslatef(-0.25f,0.860f,0.0f);
glutWireCube (0.5);

//falange2
glScalef(1,1.25,1);
glRotatef(raxf23,1,0,0);
glTranslatef(0.0f,.45f,0.0f);
glutWireCube (0.5);

//falange3
glRotatef(raxf3,1,0,0);
glScalef(1,1,1);
glTranslatef(0.0f,.5f,0.0f);
glutWireCube (0.5);

glPopMatrix();

glPushMatrix();
//meñique
//falange1
glRotatef(rmexf123,1,0,0);
glScalef(1,1.2,1);
glTranslatef(-0.75f,0.86f,0.0f);
glutWireCube (0.5);

//falange2
glRotatef(rmexf23,1,0,0);
glScalef(1,1,1);
glTranslatef(0.0f,0.5f,0.0f);
glutWireCube (0.5);

//falange3
glRotatef(rmexf3,1,0,0);
glScalef(1,1,1);
glTranslatef(0.0f,.5f,0.0f);
glutWireCube (0.5);

glPopMatrix();

}

viernes, 16 de marzo de 2007

Matriz de Transformación
El orden es primero rotación (z a x) y luego traslación por -d, dado que mover la cámara es como mover el mundo en la dirección opuesta.
Otro método para generar la matriz de transformación y rotación consiste en calcular los vectores unitarios uvn y formar la matriz de rotación compuesta de manera directa. Dados los vectores N y V, se calculan estos vectores unitarios como
n = N / çN ç= ( n1, n2, n3 )
u= VxN / ç VxN ç= ( u1, u2, u3 )
v = nxu = ( v1, v2, v3 )
Este método también ajusta en forma automática la dirección de V de modo que v sea perpendicular a n.
La matriz de rotación compuesta para la transformación de vista es



que transforma u en el eje mundial de xw, v en el eje de yw y n en el eje de zw. Esta matriz lleva a cabo de manera automática la reflexión necesaria para transformar un sistema de vista de lado izquierdo en un sistema mundial de lado derecho.
La transformación completa de coordenadas mundiales a coordenadas de vista se obtiene como el producto de matriz

MVC ¬WC = R · T-1


glViewport(0, 0, width, height);

Esta función define la porción de ventana donde puede dibujar ogl. Los parámetros son x e y, esquina superior izquierda del "cuadro" donde puede dibujar (con
referencia la ventana), y ancho y alto. En este caso coje el width y height, que son los parámetros de reshape(), es decir, los datos que acaba de recibir por culpa
del reescalado de la ventana.

martes, 13 de marzo de 2007

Espacio vectorial

Un espacio vectorial (o espacio lineal) es el objeto básico de estudio en la rama de la matemática llamada álgebra lineal. Las operaciones que podemos realizar entre ellos son: la suma de vectores y la multiplicación por un escalar,el producto punto, el producto vectorial y el triple preduco escalar con algunas restricciones naturales como el cierre de estas operaciones, la asociatividad de estas y la combinación de estas operaciones, siguiendo, llegamos a la descripción de una estructura matemática llamada espacio vectorial.

Definición formal
Dado un
cuerpo conmutativo de escalares K (como el cuerpo de los números reales o el cuerpo de los números complejos), en el que llamaremos por:
0 (cero) al elemento nulo.
1 (uno) al elemento unidad.
Un conjunto V dotado de una ley de composición interna (+), (suma de vectores), y una ley de composición externa (·), (producto por un escalar), respecto al cuerpo K, es un espacio vectorial si y solo si:
V tiene estructura de
grupo conmutativo, respecto a la ley de composición interna (+), (suma de vectores).
Respecto a su ley de composición externa (·), (producto por un escalar), se cumple:

Campo vectorial

En matemática un campo vectorial es una construcción del cálculo vectorial que asocia un vector a cada punto en el espacio euclídeo.
Los campos vectoriales se utilizan a menudo en la
física para, por ejemplo, modelar la velocidad y la dirección de un líquido móvil a través del espacio, o la intensidad y la dirección de una cierta fuerza, tal como la fuerza electromagnética o la gravitatoria, pues cambian punto a punto.
En el tratamiento matemático riguroso, los campos vectoriales se definen en
variedades diferenciables como secciones del fibrado tangente de la variedad.







Anillo

Dados, un conjunto no vacío A y dos leyes de composición interna y , la terna ordenada (A , , ) tiene estructura de Anillo si y solo si

a) es asociativa. Es decir , , : a, b, c A

b) posee elemento neutro en A. Es decir / , si

c) Todo elemento de A es invertible en A respecto de .
Es decir , /

d) es conmutativa. Es decir , : a, b A

Estas 4 propiedades muestran que ( A , ) es un grupo abeliano.

e) es asociativa. Es decir , , : a, b, c A (a b) c = a ( b c)

Esta propiedad muestra que ( A , ) es un semigrupo.

f) distribuye doblemente sobre . Es decir, , , : a, b, c A
a (b c ) = ( a b ) (a c ) y (b c ) a = (b a ) ( c a )

Resumiendo podemos decir que:

(A , , ) es un Anillo sii (A , ) es un grupo abeliano ; ( A , ) es un semigrupo y la segunda operación distribuye sobre la primera.




DEMOSTRACION MATRIZ DE ROTACIO EJE Y







lunes, 12 de marzo de 2007

Previo Practica No.2
Este es el archivo del humanoide que se mueve segun los parametro es en la función muevete.
#include
#include
#include
#include
#include

void pinta(float ejex, float ejey, float ejez,float r,char c);
void muevete(float abd, float abi, float apd,float api);

void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0.1, 0.1, 0.1);
glLoadIdentity ();
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glScalef (1.0, 1.0, 1.0);

glEnable(GL_DEPTH_TEST);
glPushMatrix();
glLoadIdentity();
muevete(8,-8,8,-8);
glPopMatrix();
Sleep(1000);
pinta(0,0,1,-15,'r');
glutPostRedisplay();
Sleep(1000);
glDisable(GL_DEPTH_TEST);
glPushMatrix();
Sleep(1000);
muevete(8,-8,8,-8);
glPopMatrix();
glLoadIdentity();
pinta(0,0,1,-15,'r');
glutSwapBuffers();
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);
}

/* ARGSUSED1 */
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
exit(0);
break;
}
}

int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE GLUT_RGB);
glutInitWindowSize (500, 300);
glutInitWindowPosition (300,230);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();

return 0;
}


void pinta(float ejex, float ejey, float ejez,float r,char c)
{
float x1,y1,z1,r1;
char c1;
x1=ejex;
y1=ejey;
z1=ejez;
r1=r;
c1=c;
glPushMatrix();
if(c1=='r')
glRotatef(r1, x1,y1,z1);
else if(c1=='t')
glTranslatef(x1,y1,z1);

//cabeza
glTranslatef(0.0f,2.5f,0.0f);
glutWireCube (0.5);
glScalef(2.5,2.5,2.0);
glTranslatef(0.0f,-0.45f,0.0f);
glutWireCube (0.5);
//tronco
glPushMatrix();
glTranslatef(-0.1f,-0.55f,0.0f);
glScalef(-.3,1.2,1.0);
glutWireCube (0.5);
glPopMatrix();
//piernas
glPushMatrix();
glTranslatef(0.1f,-0.55f,0.0f);
glScalef(-.3,1.2,1.0);
glutWireCube (0.5);

glPushMatrix();
glTranslatef(0.0f,-0.7f,0.0f);
glutWireCube (0.5);
glPopMatrix();


glTranslatef(0.7f,-0.7f,0.0f);
glutWireCube (0.5);

glPushMatrix();
glTranslatef(0.0f,.35f,0.0f);
glScalef(1.1,.4,1.0);
glutWireCube (0.5);
glPopMatrix();

glPushMatrix();
glTranslatef(-0.7f,.35f,0.0f);
glScalef(1.1,.4,1.0);
glutWireCube (0.5);
glPopMatrix();
//pies
glPushMatrix();
glTranslatef(.3f,-.3f,0.0f);
glScalef(1.6,.2,1.0);
glutWireCube (0.5);
glPopMatrix();

glTranslatef(-.8f,-.3f,0.0f);
glScalef(1.6,.2,1.0);
glutWireCube (0.5);


glPopMatrix();
//brazo derecho
glPushMatrix();
glTranslatef(0.35f,0.1f,0.0f);
glScalef(0.5,0.4,.5);
glutWireCube (0.5);

glPushMatrix();
glTranslatef(0.4f,0.0f,0.0f);
glScalef(0.5,1.2,1.0);
glutWireCube (0.5);

glPopMatrix();
glTranslatef(0.8f,0.0f,0.0f);
glutWireCube (0.5);
//brazo izquierdo
glPopMatrix();
glTranslatef(-0.35f,0.1f,0.0f);
glScalef(0.5,0.4,.5);
glutWireCube (0.5);

glPushMatrix();
glTranslatef(-0.4f,0.0f,0.0f);
glScalef(0.5,1.2,1.0);
glutWireCube (0.5);

glPopMatrix();
glTranslatef(-0.8f,0.0f,0.0f);
glutWireCube (0.5);
glPopMatrix();

}

void muevete(float brader, float braizq, float pieder,float pieizq)
{
float brazod, brazoi, pied, piei;

brazod=brader;
brazoi=braizq;
pied=pieder;
piei=pieizq;

glPushMatrix();
//cabeza
glTranslatef(0.0f,2.5f,0.0f);
glutWireCube (0.5);

//tronco
glScalef(2.5,3.0,2.0);
glTranslatef(0.0f,-0.45f,0.0f);
glutWireCube (0.5);
//piernas

glPushMatrix();
glPushMatrix();
//pierna izquierda
glRotatef(piei,0,0,1);
glTranslatef(-0.1f,-0.55f,0.0f);
glScalef(-.3,1.2,1.0);
glutWireCube (0.5);
glPushMatrix();

glTranslatef(0.0f,-0.7f,0.0f);
glutWireCube (0.5);

glPushMatrix();
glTranslatef(0.0f,.35f,0.0f);
glScalef(1.1,.4,1.0);
glutWireCube (0.5);
glPopMatrix();
glPopMatrix();
//pies
glPushMatrix();
glTranslatef(.3f,-1.0f,0.0f);
glScalef(1.6,.2,1.0);
glutWireCube (0.5);
glPopMatrix();
glPopMatrix();

//pierna derecha
glRotatef(pied,0,0,1);
glTranslatef(0.1f,-0.55f,0.0f);
glScalef(-.3,1.2,1.0);
glutWireCube (0.5);
glPushMatrix();

glTranslatef(0.0f,-0.7f,0.0f);
glutWireCube (0.5);

glPushMatrix();
glTranslatef(0.0f,.35f,0.0f);
glScalef(1.1,.4,1.0);
glutWireCube (0.5);
glPopMatrix();
glPopMatrix();

//pies
glTranslatef(-.3f,-1.0f,0.0f);
glScalef(1.6,.2,1.0);
glutWireCube (0.5);


glPopMatrix();
//brazo derecho
glPushMatrix();
glRotatef(brazod,0,0,1);
glTranslatef(0.35f,0.1f,0.0f);
glScalef(0.5,0.4,.5);
glutWireCube (0.5);

glPushMatrix();

glTranslatef(0.4f,0.0f,0.0f);
glScalef(0.5,1.2,1.0);
glutWireCube (0.5);

glPopMatrix();
glTranslatef(0.8f,0.0f,0.0f);
glutWireCube (0.5);
//brazo izquierdo
glPopMatrix();
glRotatef(brazoi,0,0,1);
glTranslatef(-0.35f,0.1f,0.0f);
glScalef(0.5,0.4,.5);
glutWireCube (0.5);

glPushMatrix();
glTranslatef(-0.4f,0.0f,0.0f);
glScalef(0.5,1.2,1.0);
glutWireCube (0.5);

glPopMatrix();
glTranslatef(-0.8f,0.0f,0.0f);
glutWireCube (0.5);
glPopMatrix();


}

martes, 6 de marzo de 2007

Previo Practica 2

Laboratorio de Computación Gráfica

Cuestionario previo #2
- Modelado Geométrico -

1. ¿Qué es una transformación geométrica? ¿Cuáles son las transformaciones básicas y sus matrices?

Transformaciones: una transformación T es una función que nos cambia un punto Q o un vector v en otro punto P o en otro vector u: P = T (Q); u = T (v), una transformación cualquiera debería ser aplicada punto a punto a todos los puntos de una escena.
Las transformaciones nos ayudan a:
Manipular objetos en el espacio 3D
Ayuda para visualizar y examinar objetos

Tipos de transformaciones afines:
– Traslación
– Rotación
– Escalado
– Cizallado
– Reflexión

Traslación: Desplazamos el origen y los ejes de forma paralela. En dos y tres dimensiones, siendo dx, dy, dz las distancias de traslación:





Rotación: En dos dimensiones: si giramos los ejes un ángulo (positivo si gira en sentido anti-horario)

En tres dimensiones: ahora tenemos tres rotaciones diferentes respecto cada uno de los ejes coordenados (igualmente, consideramos sentido positivo si gira en sentido anti-horario) La rotación sobre Z es prácticamente igual que antes, aunque ahora tenemos que usar una matriz (3x3):

Para la rotación sobre X, también es prácticamente igual que antes, solamente que el eje que antes era X será ahora Y, y el que antesera Y, Z (igualmente, consideramos sentido positivo si gira en sentido anti-horario)

Si rotamos respecto de Y, lo que en Rz era X ahora será Z, y donde teníamos Y, ahora habrá que poner Z. Por tanto hay queintercambiar también filas y columnas en la matriz de rotación...

Las matrices de rotación son ortonormales. Podemos invertirlas por transposición.
La rotación sobre un eje cualquiera va a necesitar, en general, ser realizada como una composición de varias transformaciones:
1. Traslación del eje de rotación (y los objetos a rotar) de forma que el eje pase por el origen
2. Descomposición de la rotación en rotaciones simples respecto a los tres ejes de coordenadas X, Y y Z
3. Deshacer la traslación, efectuando la inversa que se hizo en (1)
Escalado uniforme y no uniforme: Variamos la escala en los ejes coordenados con el mismo factor de escala o diferente para cada eje (factores de escala si iguales o diferentes)

Cizallado:
• No mantiene los ángulos, aunque sí las rectas y el paralelismo
• Menos utilizada en gráficos
• En tres dimensiones es análoga, si bien nos aparecen nuevos coeficientes adicionales

2. Escriba los comandos que en OpenGL permiten aplicar transformaciones geométricas, las variantes de dichos comandos y describa sus parámetros.

Translación: void glTranslate(x,y,z); nos va a permitir trasladar un objeto en el espacio
Rotación: void glRotate(angulo,x,y,z); nos va a permitir rotar un objeto
Escalado: void glScale(x,y,z); nos va a permitir escalar un objeto

Donde: x,y,z son las coordenadas de un punto.

3. Describa en OpenGL qué son las matrices GL_MODELVIEW y GL_PROJECTION. ¿Para qué sirven? ¿Cómo se puede intercambiar entre una y otra? ¿Cuál es la matriz activa por defecto? ¿Para que sirve el comando glLoadIdentity()?

GL_MODELVIEW: la matriz que contiene las transformaciones originadas por los
cambios de modelado y posición de la cámara.
GL_PROJECTION: la matriz con las transformaciones que realizan la proyección de la
escena de 3 a 2 dimensiones.

Estas dos matrices sirven para hacer una operación de transformación. Se especifica con la función glMatrixMode(Glenum mode) que tiene como argumento una de las tres constantes enumeradas. Se comporta como un estado, por tanto, hasta que se especifique un nuevo estado todas las transformaciones se realizan sobre la última matriz especificada.
En el código de la función resaphe() del capítulo anterior:
void reshape(int width, int height) {
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, (GLfloat)height / (GLfloat)width, 1.0, 128.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0.0, 1.0, 3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
}
Se observa que se utiliza la función glMatrixMode() dos veces, la primera con
GL_PROJECTION y la segunda con GL_MODELVIEW .
Despues de la primera llamada a glMatrixMode(), la matriz sobre la que se realizarán
las transformaciones es GL_PROJECTION, la primera operación es inicializar la matriz con la función glLoadIdentity() que carga la matriz identidad y se define una proyección perspectiva con la función gluPerspective(). Esta función se explica en el siguiente capítulo.
Despues de la segunda llamada a glMatrixMode(), la matriz sobre la que se realizarán
las transformaciones es GL_MODELVIEW, igualmente, la primera operación es inicializar la matriz con la función glLoadIdentity() y a continuación se establece la posición de la cámara con gluLookAtAl comportarse OpenGL como una máquina de estados, las siguientes operaciones de transformación que se realicen en el código, que estarán fuera de la función resaphe(), se realizarán sobre la última matriz especificada, es decir sobre GL_MODELVIEW.

4. ¿Para qué son los comandos glPushMatrix() y glPopMatrix()? Describa su uso a través de un ejemplo en código.

glPushMatrix(); // La función glPushMatrix() realiza una copia de la matriz superior y la pone encima de la pila, de tal forma que las dos matrices superiores son iguales, al llamar a la función glPushMatrix() se duplica la matriz superior. Las siguientes transformaciones que se realizan se aplican sólo a la matriz superior de la pila, quedando la anterior con los valores que tenía en el momento de llamar a la función glPushMatrix().
glPopMatrix(); La función glPopMatrix() elimina la matriz superior, quedando en la parte superior de la pila la matriz que estaba en el momento de llamar a la función glPushMatrix().

glColor4f(1.0,0.0,0.0,1.0);
dibujarCuadro(1.0);
glPushMatrix();
glTranslatef(0.0, 2.0, 0.0);
dibujarCuadro(0.5);
glPopMatrix();
glPushMatrix();
glTranslatef(0.0, -2.0, 0.0);
dibujarCuadro(0.5);
glPopMatrix();

5. ¿Para qué sirven los comandos glBegin() y glEnd()? Describa su uso, sus parámetros y ejemplifique a través de una pieza de código.

Para crear cualquier figura geométrica en OpenGL hay que definir los vértices entre un par de llamadas a las funciones glBegin() y glEnd(). A la función glBegin se le puede pasar un argumento que determina qué tipo de figura geométrica se va construir. Después se definen los vértices mediante llamadas a la función glVertex. A continuación vemos un ejemplo en el que se define el polígono.
glBegin (GL_POLYGON);
glVertex2f (0.0, 0.0);
glVertex2f (0.0, 3.0);
glVertex2f (3.0, 3.0);
glVertex2f (4.0, 1.5);
glVertex2f (3.0, 0.0);
glEnd ();
void glBegin (GLenum mode); Marca el principio de una lista de vértices que describen una primitiva geométrica. El parámetro mode índica el tipo de primitiva(GL_POINTS Puntos individuales. GL_LINES Cada Par de vértices forman un segmento individual.
GL_POLYGON Vértices de polígono simple y conexo. GL_TRIANGLES Cada terna determina un triángulo. GL_QUADS Cada cuátrupla determina un cuadrado. GL_LINE_STRIP Series de segmentos conectados. GL_LINE_LOOP Series de segmentos conectados y cerrados. GL_TRIANGLE_STRIP Cadenas de triángulos conectados. GL_TRIANGLE_FAN Cadenas de polystrip (el centro es el primer
vértice). GL_QUAD_STRIP Cuadriláteros encadenados.)
void glEnd (void); Marca el final de una lista de vértices.

6. ¿Qué es modelado geométrico? Describa los tipos de modelado geométrico que existen.

Modelado Geométrico: es una técnica que puede generar distintos tipos de objetos.
Los modelos pueden clasificarse en: alambritos, de superficies (planas o curvas) y sólidos. Los modelos de superficies curvas se dividen en: paramétricas(analíticas y sintéticas) y no paramétricas(explícitas e implícitas). Los modelos sólidos más importantes son: semi-espacios,frontera,CSG, barrido, enumeración espacial,etc.
Entre los modelos no convencionales se encuentran: los fractales, los de gramáticas, los sistemas de partículas, los blobs, y los basados en propiedades físicas.

7. Construya código para dibujar un cubo (revisar en la clase de teoría), y a partir de éste modele jerárquicamente el humanoide de la ilustración y escriba el programa que lo dibuja. Las medidas corren por su cuenta.


#include
#include

void init(void)
{
glClearColor (0.0, 0.0, 1.0, 0.0);
glShadeModel (GL_FLAT);
}

void cube(void){
GLfloat vertices[][]={{0.55,0.5,0.5},
{-0.5,-0.5,0.5},
{0.5,-0.5,0.5},
{-0.5,0.5,0.5},
{-0.5,-0,5,-0.5},
{-0.5,0.5,-0.5},
{0.5,0.5,-0.5}};
glBegin(GL_QUADS);
glVertex3fv(vertices[0]);
glVertex3fv(vertices[1]);
glVertex3fv(vertices[2]);
glVertex3fv(vertices[3]);
glEnd();
glBegin(GL_QUADS);
glVertex3fv(vertices[4]);
glVertex3fv(vertices[5]);
glVertex3fv(vertices[6]);
glVertex3fv(vertices[7]);
glEnd();
glBegin(GL_QUADS);
glVertex3fv(vertices[1]);
glVertex3fv(vertices[6]);
glVertex3fv(vertices[5]);
glVertex3fv(vertices[2]);
glEnd();
glBegin(GL_QUADS);
glVertex3fv(vertices[0]);
glVertex3fv(vertices[3]);
glVertex3fv(vertices[4]);
glVertex3fv(vertices[7]);
glEnd();
glBegin(GL_QUADS);
glVertex3fv(vertices[0]);
glVertex3fv(vertices[7]);
glVertex3fv(vertices[6]);
glVertex3fv(vertices[1]);
glEnd();
glBegin(GL_QUADS);
glVertex3fv(vertices[2]);
glVertex3fv(vertices[5]);
glVertex3fv(vertices[4]);
glVertex3fv(vertices[3]);
glEnd();
}
void display(void)
{

glPushMatrix();
glTranslatef(0.0,1.25,0.0);
glPushMatrix();
glTranslatef(0.25,1.5,0.0);
glScalef(1.5,0.5,0.5);
cube();
glPopMatrix();

glPushMatrix();
glTranslatef(0.25,2.0,0.0);
glScalef(1.0,2.0,0.5);
cube();
glPopMatrix();

glPushMatrix();
glTranslatef(-4.75,1.75,0.0);
glScalef(0.5,2.0,0.5);
cube();
glPopMatrix();
glPushMatrix();
glTranslatef(1.5,0.0,0.0);
glScalef(2.0,1.5,0.5);
cube();
glPopMatrix();

glPushMatrix();
glTranslatef(2.0,0.0,0.0);
glScalef(2.0,0.5,0.5);
cube();
glPopMatrix();
glPushMatrix();
glTranslatef(-1.5,0.0,0.0);
cube();
glPopMatrix();

glPushMatrix();
glTranslatef(-2.0,0.0,0.0);
glScalef(2.0,1.5,0.5);
cube();
glPopMatrix();
glPushMatrix();
glTranslatef(-2.0,0.75,0.0);
glScalef(2.0,0.5,0.5);
cube();
glPopMatrix();
glPushMatrix();
glTranslatef(0.0,-2.0,0.0);
cube();
glPopMatrix();

glPushMatrix();
glTranslatef(0.75,-2.5,0.0);
glScalef(2.0,3.0,0.5);
cube();
glPopMatrix();
glPushMatrix();
glScalef(0.5,2.0,0.5);
cube();
glPopMatrix();
glPushMatrix();
glTranslatef(0.25,-2.0,0.0);
glScalef(1.0,2.0,1.0);
cube();
glPopMatrix();
glPushMatrix();
glTranslatef(0.5,-1.5,0.0);
glScalef(1.5,0.5,0.5);
cube();
glPopMatrix();
glPopMatrix();

}
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);
}
/* ARGSUSED1 */
/*void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
exit(0);
break;
}
}*/
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE GLUT_RGB);
glutInitWindowSize (500, 300);
glutInitWindowPosition (300,230);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}

8. ¿Para qué sirven los comandos glClearColor() y glClear()? Descríbalos su funcionamiento, sus parámetros y ejemplifique a través de una pieza de código.

void glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
Activa el color de fondo actual, siguiendo el modelo de representación RGB. Cada argumento representa la cantidad del color indicado que tiene el color de fondo, y toma valores en el intervalo [0, 1. El valor por defecto es el color NEGRO que se representa por el valor: (0, 0, 0, 0).
void display(void)
{
glClearColor(0.0,0.0,0.0,0.0);
// Color de fondo: negro
glClear(GL_COLOR_BUFFER_BIT);
// Boramos la pantalla
glMatrixMode(GL_PROJECTION);
// Modo proyección
glLoadIdentity();
// Cargamos la matriz identidad
glOrtho(-1.0,1.0,-1.0,1.0,-1.0,1.0);
// Proyección ortográfica, dentro del cubo señalado
glMatrixMode(GL_MODELVIEW);
// Modo de modelado
glBegin(GL_TRIANGLES);
// Dibujamos un triángulo
glColor3f(1.0,0.0,0.0);
// Color del primer vértice: rojo
glVertex3f(0.0,0.8,0.0);
// Coordenadas del primer vértice
glColor3f(0.0,1.0,0.0);
// Color del segundo vértice: verde
glVertex3f(-0.6,-0.2,0.0);
// Coordenadas del segundo vértice
glColor3f(0.0,0.0,1.0);
// Color del tercer vértice: azúl
glVertex3f(0.6,-0.2,0.0);
// Coordenadas del tercer vértice
glEnd();
// Terminamos de dibujar
glFlush();
// Forzamos el dibujado
sleep(10);
// Esperamos 10 segundos
exit(0);
// Salimos del programa
}

void glClear (GLbitfield mask);
Limpia el buffer especificado por el parámetro, inicializándolo al valor que tenía asignada la variable de estado anteriormente. Los posibles valores del argumento, es decir los posibles buffers que tenemos son los siguientes:
Color Buffer GL_COLOR_BUFFER_BIT
Depth Buffer GL_DEPTH_BUFFER_BIT
Accumulate Buffer GL_ACCUM_BUFFER_BIT
Stencil Buffer GL_STENCIL_BUFFER_BIT

void display(void) {
glClear(GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glMultMatrixd(mModel);
glColor3f(1.0,1.0,0.0) ;
drawTurtle();
glPopMatrix();
displayTrace();
glutSwapBuffers();
}
9. Describa los comandos glutInit(), glutInitDisplayMode (), glutInitWindowSize (), glutInitWindowPosition (), glutCreateWindow (), glutDisplayFunc(), glutReshapeFunc(), glutKeyboardFunc() y glutMainLoop(). Describa su funcionamiento, uso y parámetros.

Void glutInit(&argc, argv); que inicializa la GLUT, y negocia con el sistema de ventanas para abrir una. Los parámetros deben ser los mismos argc y argv sin modificar de la main(). Glut entiende una serie de parámetros que pueden ser pasados por línea de comandos.

void glutDisplayFunc( void (*func) (void)) La función func() se llamará cada vez que haya que redibujar la ventana. Inicializa el buffer de la pantalla inicial, esn este caso es el modo y tipo de colores en la pantalla(RGB/RGBA)


void glutReshapeFunc(void (*func) (int width, int height)) La función func(width, height) se llamará cada vez
que la ventana cambie de tamaño, y recibirá como parámetros la nueva anchura y altura.

glutInitDisplayMode. Inicializar el modo de visualización. En este caso, estamos activando el buffer de profundidad (GLUT_DEPTH), el doble buffering (GLUT_DOUBLE) y la renderización en RGB (GLUT_RGB).

glutInitWindowSize (anchura, altura). Inicializar el tamaño de la ventana.

glutInitWindowPosition(x, y). Inicializar la posición de la ventana en el escritorio.

glutCreateWindow(char* titulo). Crear la ventana. Esta función muestra una ventana del tamaño y posición definidas y con el título que le hayamos puesto.

Void glutKeyboardFun(void (*func)(unsigned char key, int x,int y)): Se encarga de la interacción de eventos en el teclado. maneja el control del teclado, haciendo un transición ente ASCII y GLUT

Void glutMainLoop(); es el bucle principal de la visualización, se encarga de interaccionar con eventos. esta función inicializa el framework running de GLUT, y procesa los mensajes de sistema operativo

10. ¿Qué es un Function Callback en GLUT?

La ejecución de esta función espera a que se produzcan eventos. Cada vez que se produce un evento lo atiende y ejecuta la función registrada, encargada de responder al evento (función de callback).