Previo Práctica 2 Laboratorio

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

Una transformación geométrica, o simplemente una transformación, es una aplicación que hace corresponder a cada punto del plano otro punto del plano. Como consecuencia, las figuras se transforman en otras figuras. Las transformaciones más usuales son las traslaciones, rotaciones, simetrías y las homotecias. Todas ellas mantienen la forma de las figuras, pero pueden disminuir el tamaño y cambiar la figura de posición. OpenGL proporciona funciones para controlar la traslación, rotación y escalado. Estas transformaciones se representan como matrices 4x4 ordenadas como vectores columna.

Las matrices de traslación y escalado se pueden apreciar en el siguiente vínculo: Matrices

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

Las funciones utilizadas para transformar son las siguientes,

glTranslatef(1.0f, 1.0f, 1.0f);
glRotatef(45.0f, 1.0f, 0.0f, 0.0f); los parámetros utilizados son ángulo, coordenada en X, en Y, y en Z.
glScalef(2.0f, 2.0f, 2.0f); Aquí solamente se utilizan las tres coordenadas.

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

Ambas son matrices consideradas como variables de estado.

GL_PROJECTION Es la matriz de proyección, afecta a las vistas o las perspectivas. La matriz con las transformaciones que realizan la proyección de la escena de 3 a 2 dimensiones.

GL_MODELVIEW Es la matriz de modelo, la matriz que contiene las transformaciones originadas por los cambios de modelado y posición de la cámara. El valor inicial es GL_MODELVIEW.

glLoadIdentity() sustituye a la matriz que se está utilizando por la matriz identidad.

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

Existe una pila de matrices para cada uno de los modos de matrices. En GL_MODELVIEW el tamaño de la pila es de 32. Para GL_PROJECTION y GL_TEXTURE el tamaño es de al menos 2.

glPushMatrix() realiza la operación de Push en esa pila de matrices, duplicando la matriz que se encuentra actualmente en el tope.

glPopMatrix() Hace la operación de pop en la pila reemplazando la matriz actual con la siguiente.

Un ejemplo de código con estas instrucciones es el siguiente:

glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glGetDoublev (GL_MODELVIEW_MATRIX, mModel);
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.

Estas funciones se emplean para delimitar los vértices de un primitivo o de un grupo de primitivos parecidos. Con la instrucción glBegin se debe elegir el tipo de objeto que se va a crear. En este caso vamos a crear cuadrados, así que se ejemplifica con $GL_QUADS.

glBegin $GL_QUADS
glVertex3 0,0,0
glVertex3 1,0,0
glVertex3 1,1,0
glVertex3 0,1,0
;Ahora finalizamos el cuadrado con el comando glEnd.
glEnd

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

El modelado geométrico describe la forma de un objeto físico o matemático utilizando conceptos geométricos. Estos modelos pueden ser construidos de objetos de cualquier dimensión en cualquier espacio geométrico.

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.

A continuación incluyo el código basado en lo visto en teoría con ayuda de unos tutoriales encontrados en internet. Se toma el pregrama base cube.c y se modifica. Se incluye sólo el código de la función que crea al humanoide.

void cubo(void)
{
glBegin(GL_POLYGON);
glVertex3f(0.5,0.5,0.5);//v1
glVertex3f(-0.5,0.5,0.5);//v2
glVertex3f(-0.5,-0.5,0.5);//v3
glVertex3f(0.5,-0.5,0.5);//v4
glEnd();
glBegin(GL_POLYGON);
glVertex3f(-0.5,0.5,-0.5);//v5
glVertex3f( 0.5,0.5,-0.5);//v6
glVertex3f(0.5,-0.5,-0.5);//v7
glVertex3f(-0.5,-0.5,-0.5);//v8
glEnd();
glBegin(GL_POLYGON);
glVertex3f(-0.5,0.5,0.5);//v2
glVertex3f(-0.5,0.5,-0.5);//v5
glVertex3f(-0.5,-0.5,-0.5);//v8
glVertex3f(-0.5,-0.5,0.5);//v3
glEnd();
glBegin(GL_POLYGON);
glVertex3f(0.5,0.5,0.5);//v1
glVertex3f(0.5,-0.5,0.5);//v4
glVertex3f( 0.5,-0.5,-0.5);//v7
glVertex3f(0.5,0.5,-0.5);//v6
glEnd();
glBegin(GL_POLYGON);
glVertex3f(-0.5,0.5,-0.5);//v5
glVertex3f(-0.5,0.5,0.5);//v2
glVertex3f(0.5,0.5,0.5);//v1
glVertex3f( 0.5,0.5,-0.5);//v6
glEnd();
glBegin(GL_POLYGON);
glVertex3f(0.5,-0.5,-0.5);//v7
glVertex3f(-0.5,-0.5,-0.5);//v8
glVertex3f(-0.5,-0.5,0.5);//v3
glVertex3f(0.5,-0.5,0.5);//v4
glEnd();
}
void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0.0, 0.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity (); /* clear the matrix */
gluLookAt ( 0.0, 0.0, 20.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glPushMatrix();//torzo
glScalef(0.80,2.0,0.5);
cubo();
glPushMatrix(); //head
glTranslatef(0.0,0.5,0.0);
glScalef(0.6,0.6,0.5);
cubo();
glPopMatrix();
glPushMatrix(); //antebrazo derecho
glTranslatef(0.8,0.4,0.0);
glScalef(0.7,0.2,0.5);
cubo();
glPushMatrix(); //brazo derecho
glTranslatef(1.0,0.0,0.0);
glScalef(1.0,1.5 ,0.5);
cubo();
glPushMatrix();
glTranslatef(0.8,0.0,0.0);
glScalef(0.8,0.6,0.5);
cubo();
glPopMatrix();
glPopMatrix();
glPopMatrix();//fin brazo derecho
glPushMatrix();
glTranslatef(-0.8,0.4,0.0);
glScalef(0.7,0.2,0.5);
cubo();
glPushMatrix();//brazo izquierdo
glTranslatef(-1.0,0.0,0.0);
glScalef(1.0,1.5,0.5);
cubo();
glPushMatrix();
glTranslatef(-0.8,0.0,0.0);
glScalef( 0.8,0.6,0.5);
cubo();
glPopMatrix();
glPopMatrix();
glPopMatrix();//fin brazo Izquierdo
glPushMatrix();//pie derecho
glTranslatef(0.35,-0.7,0.0);
glScalef(0.3,0.4,0.5);
cubo();
glPushMatrix();
glTranslatef(0.0,-1.0,0.0);
glScalef(1.5,1.0,0.5);
cubo();
glPushMatrix();
glTranslatef(0.5,-0.6,0.0);
glScalef(2.0,0.4,0.5);
cubo();
glPopMatrix();
glPopMatrix();
glPopMatrix();//fin del pie derecho
glPushMatrix();//pie izquierdo
glTranslatef(-0.35,-0.7,0.0);
glScalef(0.3,0.4,0.5);
cubo();
glPushMatrix();
glTranslatef(0.0,-1.0,0.0);
glScalef(1.5,1.0,0.5);
cubo();
glPushMatrix();
glTranslatef(- 0.5,-0.6,0.0);
glScalef(2.0,0.4,0.5);
cubo();
glPopMatrix();
glPopMatrix();
glPopMatrix();//fin del pie izquierdo
glPopMatrix();
glFlush ();
}

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.

glClearColor() especifica los valores alpha rojo, verde y azul utilizados por glClear() para limpiar el búffer de colores. Los valores especificados por glClearColor() se limitan al rango [0, 1]. Utiliza la siguiente connotación: glClearColor(rojo, verde, azul, alpha)

glClear() fija el área de mapa de bits de la ventana a valores preestablecidos por glClearColor, glClearIndex, glClearDepth, glClearStencil, y glClearAccum.

Sus argumentos son: GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_ACCUM_BUFFER_BIT, GL_STENCIL_BUFFER_BIT.

9. Describa los comandos glutInit(), glutInit(), glutInitDisplayMode (), glutInitWindowSize (), glutInitWindowPosition (), glutCreateWindow (), glutDisplayFunc(), glutReshapeFunc(), glutKeyboardFunc() y glutMainLoop(). Describa su funcionamiento, uso y parámetros.

glutInit() Se utiliza para inicializar la librería de GLUT. Se utiliza de la siguiente manera: void glutInit(int *argcp, char **argv); donde argcp es un apuntador a la variable sin modificar argc desde main. Argv es el valor de la variable sin modificar desde main, esta información será actualizada ya que esta función extrae cualquier opción de comando entendida por la librería de GLUT.

glutInitDisplayMode () Fija el modo de display inicial.Se utiliza de la siguiente manera: void glutInitDisplayMode(unsigned int mode); el valor entero que se utiliza de argumento funciona como un selector de las máscaras del modo de despliegue.

glutInitWindowSize () Sirve para fijar el tamaño inicial de la ventana. Se utiliza de la siguiente manera: void glutInitWindowSize(int width, int height); donde se indica la altura y el ancho de la ventana.

glutInitWindowPosition ()La ventana creada por glutCreateWindow, al utilizar esta función, le será indicado que sea creada en la posición especificada. Los parámetros son: void glutInitWindowPosition(int x, int y); es decir, int x – coordenada en x e int y – coordenada en y.

glutCreateWindow () Crea una ventana. Su parámetro es int glutCreateWindow(char *name); donde name es el nombre que se le va a asignar a la ventana con el cual el sistema de ventanas va a reconocerla.

glutDisplayFunc() Obtiene el callback de display para la ventana actual. Cuando GLUT determina que el plano normal para la ventana necesita ser vuelto a ser mostrado, el callback de display para la función es llamado. Antes de ello, la ventana actual cambia su valor a la ventana que necesita ser mostrada de nuevo y la capa en uso cambia al plano normal. No tiene parámetros. Esta función callback especifica cuál función será llamada cada vez que la ventana actual se afecte void glutDisplayFunc(void (*func)(void));

glutReshapeFunc() Esta función callback especifica cuál función será llamada cada vez que la ventana sea redimensionada o movida, pero también es utilizada para definir inicialmente el área de proyección de la figura en la ventana. Su uso es: void glutReshapeFunc(void (*func)(int width, int height)); Donde func es la nueva función que será llamada cada vez que la ventana sea redimensionada.

glutKeyboardFunc() Especifica la rutina de servicio a ejecutar cada vez que se pulsa una de las teclas correspondiente a un código ASCII. Su uso es: void glutKeyboardFunc(void (*function)(unsigned char key, int x, int y)); El argumento function es un puntero a la función que actúa como rutina de servicio. Esta función espera tres parámetros, el carácter de la tecla pulsada y la posición del ratón sobre la ventana en coordenadas del mundo real.

glutMainLoop() entra al evento de procesamiento del GLUT en un loop infinito, este comando debe ser utilizado por lo menos una vez cada vez que se quiera utilizar GLUT, una vez llamada nunca se saldrá del proceso, pero llamara todas las rutinas necesarias para el uso de GLUT, se usa de la siguiente manera: void glutMainLoop(void);

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

Es la respuesta que tiene el programa a cualquier estímulo por parte del hardware, se puede hacer la analogía con las interrupciones de un programa ocasionadas por eventos como la acción de una tecla o del mouse. Una Function Callback es una que no se invoca explícitamente por el programador; en vez de ello, la responsabilidad de su invocación se delega a otra función que recibe la dirección del la función Callback.

Fuentes de Consulta

http://graficos.uji.es/grafica/NuevasPracticas/Practica3/Transformaciones.html
http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/rotate.html
http://en.wikipedia.org/wiki/Geometric_modeling
http://www.tecnun.es/asignaturas/grafcomp/OpenGL/practica/capitulo3.pdf
y otras que por espacio no se incluyen.