Previo 1

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

Las transformaciones geométricas es hacer mediante una ecuación o pasos una traslado o correspondencia de cada punto de un plano a otro plano, esto lleva a la deformación o transformación de las figuras dentro del plano. Las transformaciones básicas y sus matrices se encuentran en la siguiente dirección, en las páginas 3,4 y 5:

http://wwwdi.ujaen.es/asignaturas/igaplicada/pdf/tema3.pdf

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

Para la traslación utilizamos el comando void glTranslate(TYPE x, TYPE y, TYPE z), este comando multiplica la matriz actual por una de traslación haciendo que se mueva el objeto, existen las variantes: void glTranslated( GLdouble x, GLdouble y,GLdouble z) void glTranslatef ( GLfloat x, GLfloat y, GLfloat z) Los parámetros x, y, z especifican las coordenadas del vector de traslación

Para la rotación utilizamos void glRotate(TYPE angle, TYPE x, TYPE y, TYPE z), este commando multiplica la matriz actual por una matriz de rotación, logrando así una rotación en el objeto en sentido de las manecillas del reloj. Existen las variantes:
void glRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )void glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )

El parámetro angle especifica el ángulo de rotación en grados, mientras que los parámetros x, y, z son las coordenadas del vector

Para lograr el escalado de usa el comando void glScale(TYPE x, TYPE y, TYPE z), este multiplica la matriz actual por una matriz que cambia el tamaño del objeto a lo largo de los ejes, las coordinas del objeto se multiplican por lo parámetros x,y,z. Existen las variantes:
void glScaled( GLdouble x, GLdouble y, GLdouble z )void glScalef( GLfloat x, GLfloat y, GLfloat z) x, y, z, especifican el factor de escala para cada eje de 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()?

GL_MODELVIEW es la matriz que contiene las transformaciones originadas por los cambios de modelado y posición de la cámara, mientras que GL_PROJECTION es la matriz con las transformaciones que realizan las proyecciones de 3 a 2 dimensiones. La matriz activa por defecto es la GL_MODELVIEW, para intercambiarse de una a la otra se hace uso del comando glMatrixMode(Glenum mode) que tiene como argumento una de las tres constantes (la tercer constante es la GL_TEXTURE), este comando se comporta como un estado, por tanto, hasta que se especifique un nuevo estado todas las transformaciones se realizan sobre la última matriz especificada. El comando glLoadIdentity() remplaza la matriz actual por una matriz identidad.

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

Existen para cada modo mencionado anteriormente una pila de matrices, para el modo GL_MODELVIEW la pila es de 32 mientras que para GL_PROJECTION y GL_TEXTURE el tamaño es de al menos 2, las funciones glPushMatrix() y glPopMatrix() hacen uso de estas pilas, glPushMatrix() realiza la operación de Push en esa pila de matrices, este duplica la matriz que se encuentra en el tope de la pila, el comando glPopMatrix() hace la operación de pop en la pila reemplazando la matriz actual con la siguiente. Ejemplo:

glPushMatrix();
apply_sphere_transformation();

glPushMatrix();
apply_cube_transformation();
draw_cube();
glPopMatrix()M

draw_sphere();

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.

La definición de primitivas inicia siempre con la función glBegin y finaliza con glEnd. Entre estas dos funciones debemos definir los vértices que forman la primitiva.

void glBegin(GLenum primitiva).- Esta función marca el inicio de un conjunto de vértice que definen una o varias primitivas, primitiva puede valer: GL_POINTS (puntos), GL_LINES (líneas), GL_TRIANGLES (triángulos), GL_LINE_LOOP (poli líneas cerradas), GL_TRIANGLE_FAN (triángulos alrededor de un punto), GL_QUADS (cuadriláteros), GL_QUAD_STRIP (cuadriláteros encadenados), GL_POLYGON (polígono convexo con cualquier número de vértices).

void glEnd(void).- Marca el final de la última primitiva que se haya iniciado con glBegin.

Ejemplo:

// dibuja una linea en las coordenadas especificadas en glVertex3f
glBegin(GL_LINES);
glVertex3f(100.0f, 100.0f, 0.0f); // origin of the line
glVertex3f(200.0f, 140.0f, 5.0f); // ending point of the line
glEnd( );

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

El modelado geométrico es la construcción o el uso de modelos geométricos, estos describen la forma de un objeto físico o matemático en términos de conceptos geométricos, es usado en graficas por computadoras, diseño asistido por computadoras y manufactura entre otros.

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.

/** mono.c
Este programa despliega un humanoide formado unicamente por cubos de diferetes tamaños, todos creados a apartir
de un cubo base y aplicando transformadas de traslacion y escalamiento*/
#include
#include
void init(void)
{
glClearColor (0.0, 0.0, 0.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 */
gluLookAt (0.0, 0.0, 9.5, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
/*torso*/
glPushMatrix();
glScalef (2.0, 3.0, 1.0);
glTranslatef(0.0,0.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*cara*/
glPushMatrix();
glTranslatef(0.0,3.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*brazo derecho*/
glPushMatrix();
glScalef (2.0, 0.5, 1.0);
glTranslatef(1.0,5.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*antebrazo derecho*/
glPushMatrix();
glScalef (2.0, 1.0, 1.0);
glTranslatef(2.0,2.75,0.0);
glutWireCube(1.0);
glPopMatrix();
/*mano derecha*/
glPushMatrix();
glScalef (0.5, 0.5, 1.0);
glTranslatef(10.5,5.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*brazo izquierdo*/
glPushMatrix();
glScalef (2.0, 0.5, 1.0);
glTranslatef(-1.0,5.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*antebrazo izquierdo*/
glPushMatrix();
glScalef (-2.0, 1.0, 1.0);
glTranslatef(2.0,2.75,0.0);
glutWireCube(1.0);
glPopMatrix();
/*mano izquierda*/
glPushMatrix();
glScalef (0.5, 0.5, 1.0);
glTranslatef(-10.5,5.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*muslo derecho*/
glPushMatrix();
glScalef (0.5, 2.5, 1.0);
glTranslatef(1.5,-0.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*pantorrila derecha*/
glPushMatrix();
glScalef (1.0, 2.5, 1.0);
glTranslatef(0.75,-1.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*pie derecho*/
glPushMatrix();
glScalef (1.75, 0.5, 1.0);
glTranslatef(0.635,-10.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*muslo izquierda*/
glPushMatrix();
glScalef (0.5, 2.5, 1.0);
glTranslatef(-1.5,-0.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*pantorrila izquierda*/
glPushMatrix();
glScalef (1.0, 2.5, 1.0);
glTranslatef(-0.75,-1.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*pie izquierdo*/
glPushMatrix();
glScalef (1.75, 0.5, 1.0);
glTranslatef(-0.635,-10.5,0.0);
glutWireCube(1.0);
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);
}
/* 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 (700, 700);
glutInitWindowPosition (100, 100);
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

glClearColor() especifica los valores 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].
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

Para el jemplo vea el codigo del humanoide en la pregunta anterior

9. Describa los comandos 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(): la ventana creada por glutCreateWindow, al utilizar esta función, le será indicado que sea creada bajo el tamaño inicial de ventana especificado. Los parámetros son: void glutInitWindowSize(int width, int height); es decir, int width – ancho e int height – largo.

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. Se emplea del modo siguiente:

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 función 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 laposició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?

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:

http://wwwdi.ujaen.es/asignaturas/igaplicada/pdf/tema3.pdf
http://usuarios.lycos.es/andromeda_studios/paginas/tutoriales/aptutgl01.htm#Modelado
http://www.opengl.org/documentation/specs/man_pages
http://www.tecnun.es/asignaturas/grafcomp/OpenGL/practica/capitulo2.pdf
http://www.tecnun.es/asignaturas/grafcomp/OpenGL/practica/capitulo3.pdf
http://www.cs.buap.mx/~asanchez/Curso_programacion_opengl_2.pdf
http://www.opengl.org/documentation/specs/glut/
http://serdis.dis.ulpgc.es/~atrujill/iga/Intro_GLUT_archivos/frame.htm
https://www.linux-magazine.es/issue/09/Python.pdf