Capítulo 3: Viewing

Analogía de la Cámara

• El proceso de transformación para producir la visión de una escena es análogo al proceso de tomar un fotografía con la cámara:
– Colocar el trípode y la cámara apuntando a la escena (transformación de la vista).
– Colocar en la posición deseada los objetos que van a ser fotografiados en la escena (transformación del modelado).
– Elegir un lente para la cámara o ajustar el zoom (transformación de la proyección).
– Determinar que tan grande va a ser la fotografía final (transformación del viewport).

Ejemplo Cube.c
void display(void){
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 1.0, 1.0);
glLoadIdentity ();

/* viewing transformation */
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glScalef (1.0, 2.0, 1.0); /* modeling transformation */
glutWireCube (1.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);
}

Transformaciones Generales

• glMatrixMode( modo ):
– Selecciona la matriz actual.
– Modo: GL_MODELVIEW, GL_PROJECTION, GL_TEXTURE.

• glLoadIndentity():
– Asigna a la matriz actual la matriz identidad (m4x4).

• glLoadMatrix{fd}( const TYPE *m ) :
– Asigna 16 valores de m a la matriz actual.

• glMultMatrix{fd}( const TYPE *m ) :
– Multiplica la matriz actual por m y el resultado queda en la matriz actual.

Transformaciones del Modelview
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMultMatrixf(N); /* apply transformation N */
glMultMatrixf(M); /* apply transformation M */
glMultMatrixf(L); /* apply transformation L */
glBegin(GL_POINTS);
glVertex3f(v); /* draw transformed vertexv */
glEnd();
v’ = NMLv

Sistema de Coordenadas Fijo
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMultMatrixf(T); /* translation */
glMultMatrixf(R); /* rotation */
draw_the_object();

Transformaciones del Modelado

• voidglTranslate{fd}(TYPE x, TYPE y, TYPE z);
– Multiplica la matriz actual por una matriz de traslación dada por (x,y, z).

• voidglRotate{fd}(TYPE angle, TYPE x, TYPE y, TYPE z);
– Multiplica la matriz actual por una matriz de rotación en el sentido inverso al movimiento de las manecillas del reloj, alrededor del rayo que forma el origen con el punto (x,y,z).
– Angle especifica el ángulo en grados.

• voidglScale{fd}(TYPE x, TYPE y, TYPE z);
– Multiplica la matriz actual por una matriz de escalamiento.
– Cada coordenada (x,y,z) se multiplica por el correspondiente parámetro x, y o z.

Transformaciones de la Vista
• Se pueden realizar de diferentes formas:
– Usando glTranslate y glRotate.
– Usando gluLookAt()
– Creando funciones propias que encapsulen rotaciones y traslaciones.

void gluLookAt( GLdouble eyex, eyey, eyez, GLdouble centerx, centery, centerz, GLdouble upx, upy, upz );
– Define una matriz de vista y la multiplica por la derecha con la matriz actual.
– La posición del punto del ojo se especifica por eyex, eyey y eyez.
– El centro de la escena se especifica por centerx, centery y centerz.
– La dirección hacia arriba se indica por upx, upy y upz.

Transformación de la Proyección
• Proyección en Perspectiva.
• Proyección Ortográfica.

Proyección en Perspectiva
• voidglFrustum(left, right, bottom,top, near, far);
– Crea una matrix de un frustum en perspectiva y lo multiplica por la actual matrix. El volumen de visión se define por los parámetros:
(left, bottom, -near) and (right, top, -near)
– Los valores near y far deben ser positivos.

• voidgluPerspective( fovy, aspect, near, far);
– Crea a matriz de un frustum en perspectiva simétrica y lo multiplica por la matriz actual.
– Fovy: ángulo en el plano x-z [0.0,180.0].
– Aspect: razón entre ancho y el alto (w/h).

Proyección Ortográfica
• voidglOrtho( left, right, bottom, top, near, far);
– Crea una matriz de un volumen ortográfico paralelo y lo multiplica por la matriz actual.
– (left, bottom, -near) y (right, top, -near) son puntos en el plano cercano.
– (left,bottom, -far) y (right, top, -far) son punto en el plano lejano.

Manipulación del Stack de Matrices
• OpenGL dispone de un stack de matrices.
• Esto facilita la construcción de modelos jerárquicos.
• Dispone de un stack de matrices para cada modo de matriz.
• En modo GL_MODELVIEW, profundidad es de por lo menos 32.
• En modo GL_PROJECTION y GL_TEXTURE, profundidad es por lo menos 2.
• La matriz actual en cualquier modo está en el tope.

• voidglPushMatrix(void);

– Empuja hacia abajo el stack de matrices y agrega en el tope la matriz actual duplicada.

– Inicialmente, cada stack de matrices tiene la identidad.

• voidglPopMatrix(void);

– Saca fuera la matriz del tope del stack, reemplazando la matriz actual por la que estaba más abajo.