Aquí estamos de nuevo tras una pausa de no haber publicado nada del tutorial de openGL. El tiempo es limitado y las cosas que uno tiene que hacer a veces supera ese tiempo.

En este capítulo lo que haremos es rotar una figura bidimensional en alguno de sus ejes. Concretamente el triángulo en el eje de las x y el cuadrilátero en el eje de las y. Las modificaciones al código anterior son pocas. Recordemos que los métodos de inicialización y manejo de la ventana son idénticos que en el resto de publicaciones.

Recordemos el código del método DrawGLScene del capítulo anterior:

def DrawGLScene(self):
       glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
       glLoadIdentity()

       glTranslatef(-1.5,0.0,-6.0)

       glBegin(GL_POLYGON)
       glColor3f(1.0,0.0,0.0)
       glVertex3f(0.0,1.0,0.0)
       glColor3f(0.0,1.0,0.0)
       glVertex3f(1.0,-1.0,0.0)
       glColor3f(0.0,0.0,1.0)
       glVertex3f(-1.0,-1.0,0.0)
       glEnd()

       glTranslatef(3.0,0.0,0.0)

       glColor3f(0.3,0.5,1.0)

       glBegin(GL_QUADS)
       glVertex3f(-1.0,1.0,0.0)
       glVertex3f(1.0,1.0,0.0)
       glVertex3f(1.0,-1.0,0.0)
       glVertex3f(-1.0,-1.0,0.0)
       glEnd()

       glutSwapBuffers()

Si hacemos memoria este código lo que hacía era dibujar en nuestra ventana OpenGL dos figuras geométricas básicas distanciadas en el eje de las x: un triángulo con un degradado de color (debido a la imposición de diferentes colores en sus vértices) y un cuadrilátero con un único color (debido a la imposición de color a nivel de figura).
En esta publicación introduciremos el concepto de rotación. La rotación en OpenGL se hace mediante la función glRotatef. La definición de la función es la siguiente:

void glRotatef(GLDouble angle, GLDouble x, GLDouble y, GLDouble z)

donde angle especifica el ángulo de rotación en grados y x,y y z definen las coordenadas x,y,z de un vector.
glRotate produce una rotación en un ángulo determinado alrededor de un vector (x,y,z). La matriz actual (dada por glMatrizMode) es multiplicada por la matriz de rotación reemplazando la actual matriz por el resultado del producto. Si la matriz actual es GL_MODELVIEW o GL_PROJECTION todos los objetos dibujados después de la llamada a glRotate serán rotados. Si queremos salvar nuestro sistema de coordenadas sin rotar podemos guardar la matriz previa a la modificación en una pila con la función glPushMatrix y recuperarla posteriormente con glPopMatrix.
Por tanto, nuestro código anterior donde únicamente se veía dos figuras estáticas coloreadas puede cambiar a ser dinámicas con una simple modificación:

def DrawGLScene(self):
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
     glLoadIdentity()

     glTranslatef(-1.5,0.0,-6.0)

     glRotatef(self.rtri,0.0,1.0,0.0)

     glBegin(GL_POLYGON)
     glColor3f(1.0,0.0,0.0)
     glVertex3f(0.0,1.0,0.0)
     glColor3f(0.0,1.0,0.0)
     glVertex3f(1.0,-1.0,0.0)
     glColor3f(0.0,0.0,1.0)
     glVertex3f(-1.0,-1.0,0.0)
     glEnd()

     glLoadIdentity()

     glTranslatef(1.5,0.0,-6.0)
     glRotatef(self.rquad,1.0,0.0,0.0)

     glColor3f(0.3,0.5,1.0)
     glBegin(GL_QUADS)
     glVertex3f(-1.0,1.0,0.0)
     glVertex3f(1.0,1.0,0.0)
     glVertex3f(1.0,-1.0,0.0)
     glVertex3f(-1.0,-1.0,0.0)
     glEnd()

     self.rtri=self.rtri+1.0
     self.rquad=self.rquad-1.0

     glutSwapBuffers()

Como podemos observar, al triángulo lo rotamos rtri sobre el vector (0,1,0) o lo que viene a ser lo mismo que decir que modificamos en rtri el eje de las y. Al cuadrilátero le modificamos en rquad el vector (1,0,0) o lo que viene a ser que modificamos en rquad el eje de las x. Cada vez que GLU llama a GLScene (cada vez que necesita redibujar la escena) rtri se incremente en 1 grado y rquad se decrementa en un grado y da esa sensación de movimiento.

¿Cansados ya de figuras en el plano bidimensional? En la próxima entrega ya entraremos en el plano tridimensional y crearemos a partir del cuadrilátero, un cubo; y del triángulo, un cono y las haremos rotar en el espacio tridimensional.

¡hasta entonces!