[Tutorial] III.3 Dibujado de lineas: GL_LINES

III.3 Dibujado de lineas: GL_LINES
Novedades:

• Uso de GL_LINES en glBegin()

Este programa es el primero en el que vamos a mostrar cómo hacer líneas, funciona como los puntos, pero dando vértices de dos en dos, uniéndolos, salen líneas. En este programa, se genera una serie de líneas que comparten un punto común en el centro, y de ahí salen en todas direcciones. Además puedes aumentar o disminuir su tamaño con las flechas arriba y abajo. Si lo aumentas te sale una figura, que si miras mucho rato parece que se mueve, lo que se llama un efecto visual de los de toda la vida.

Código:

#include <GL/glut.h>
#include <math.h>

#define PI 3.14159f

float ang, x, y;
int up, down;
float zoom = 2.5f;

void IniciarGLUT() {
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
  glutInitWindowSize(600,600);
  glutInitWindowPosition(100,100);
  glutCreateWindow("Practica III,3 de OpenGL");
}

void PintarEscena() {
   glMatrixMode(GL_MODELVIEW);
   glClear(GL_COLOR_BUFFER_BIT);
   glLoadIdentity();

   glBegin(GL_LINES);
           for (ang=0.0f; ang<PI*2.0f; ang = ang + 0.1f ) {
              x = zoom*cosf(ang);
              y = zoom*sinf(ang);
              glVertex3f(0.0f,0.0f,0.0f);
              glVertex3f(x,y,0.0f);
           }
   glEnd();

   glutSwapBuffers();
}

void ReProyectar(int w, int h) {
   GLfloat formato;

   if(h == 0) h = 1;

    glViewport(0, 0, w, h);

   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();

   formato = (GLfloat)w / (GLfloat)h;

    if (w <= h) glOrtho (-10.0f, 10.0f, -10.0f / formato, 10.0f / formato, 1.0f, -1.0f);
    else glOrtho (-10.0f * formato, 10.0f * formato, -10.0f, 10.0f, 1.0f, -1.0f);
}

void Flechas(int key, int x, int y) {
   if (key==GLUT_KEY_UP) up = 1;
   if (key==GLUT_KEY_DOWN) down = 1;
}

void FlechasUp(int key, int x, int y) {
   if (key==GLUT_KEY_UP) up = 0;
   if (key==GLUT_KEY_DOWN) down = 0;
}

void Zoomizar(int value) {
   if (up) zoom = zoom * 1.01f;
   if (down) zoom = zoom / 1.01f;

   glutTimerFunc(33,Zoomizar,1);
}

int main(int argc, char **argv) {
   glutInit(&argc,argv); //Solo necesario en Linux
  IniciarGLUT();

  glutReshapeFunc(ReProyectar);
  glutDisplayFunc(PintarEscena);
  glutSpecialFunc(Flechas);
  glutSpecialUpFunc(FlechasUp);
  glutTimerFunc(33,Zoomizar,1);
  glutIdleFunc(PintarEscena);

  glutMainLoop();
    return 0;
}

Si miras fíjamente el centro (a tamaño real, como aquí) en 5 segundos verás débiles colores que ondean a cada parpadeo, en 10 segundos empezarás ver como se curvan algunas rectas al ir al centro, y a los 15 segundos o más te parecerá que tiemblan al mover un poco la cabeza (viéndolo de cerca, como a medio metro).

Aparte de lo de las flechas arriba y abajo, y que aumenta la variable zoom, en lo que no voy a entrar porque no es el tema. Lo que hay que explicar está en PintarEscena():

Código:

   glBegin(GL_LINES);
           for (ang=0.0f; ang<PI*2.0f; ang = ang + 0.1f ) {
              x = zoom*cosf(ang);
              y = zoom*sinf(ang);
              glVertex3f(0.0f,0.0f,0.0f);
              glVertex3f(x,y,0.0f);
           }
   glEnd()

Una vez iniciado el modo líneas, debemos dar vértices a pares. Aparte hacemos dentro un bucle, que aumenta poco a poco un ángulo que parte de 0, hasta completar la vuelta entera (en radianes es 2*PI), creando líneas que parten del centro, a donde indique el seno y coseno de float de ese momento. La variable zoom que aumenta o dismuye la longitud de las líneas, que no el tamaño, aquí pasa como con los puntos, las líneas tiene un pixel de grosor, y eso no va a cambiar por mucho que se aleje o acerque la línea. También podemos cambiar su grosor, en el próximo tutorial.