iniciando no OpenGL

Estou estudando a API OpenGL, então vou fazer uma síntese do que consegui absorver.

fonte

Introdução

OpenGL é definida como “um programa de interface para hardware gráfico”. Na verdade, OpenGL é uma biblioteca de rotinas gráficas e de modelagem, bi (2D) e tridimensional (3D), extremamente portável e rápida. Usando OpenGL é possível criar gráficos 3D com uma qualidade visual próxima de um ray tracer. Entretanto, a maior vantagem na sua utilização é a rapidez, uma vez que usa algoritmos cuidadosamente desenvolvidos e otimizados pela Silicon Graphics, Inc., líder mundial em Computação Gráfica e Animação.

Tipos de dados

Para tornar o OpenGL portável, foram criados tipos de variáves própias para o OpenGL, que vem a substituir, em alguns casos, as variáveis tradicionais do C/C++. Dentre elas podemos citar GLbyte, GLshort, GLfloat, GLint, GLdouble, GLboolean, GLenum, GLushort, etc…

Convenção para o nome das funções do OpenGL

<prefixo biblioteca><comando><contador (opcional)><tipo (opcional)>

Ex: glColor3f ( float, float, float ) , glVertex2d( double, double) , glVertex3f ( float , float , float )

Um primeiro programa

# include <gl/glut.h>

void Desenha(void)
{
     glMatrixMode(GL_MODELVIEW);
     glLoadIdentity();

     // Limpa a janela de visualização com a cor de fundo especificada
     glClear(GL_COLOR_BUFFER_BIT);

     // Especifica que a cor corrente é vermelha
     //         R     G     B
     glColor3f(1.0f, 0.0f, 0.0f);

     glBegin(GL_LINES);
                       glVertex2i(100,100);
                       glVertex2i(200,100);

                       glColor3f( 0.0f , 1.0f , 0.0f ); //agora é verde ..

                       glVertex2i(200,100);
                       glVertex2i(150,200);

                       glColor3f( 0.0f, 0.0f , 1.0f ); //agora é azul

                       glVertex2i(150,200);
                       glVertex2i(100,100);
     glEnd();

     glFlush(); // Executa os comandos OpenGL
}

void Inicializa (void)
{
    // Define a cor de fundo da janela de visualização como preta
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
}

void AlteraTamanhoJanela(GLsizei w, GLsizei h)
{
                   // Evita a divisao por zero
                   if(h == 0) h = 1;

                   // Especifica as dimensões da Viewport
                   glViewport(0, 0, w, h);

                   // Inicializa o sistema de coordenadas
                   glMatrixMode(GL_PROJECTION);
                   glLoadIdentity();

                   // Estabelece a janela de seleção (left, right, bottom, top)
                   if (w <= h)
                           gluOrtho2D (0.0f, 250.0f, 0.0f, 250.0f*h/w);
                   else
                           gluOrtho2D (0.0f, 250.0f*w/h, 0.0f, 250.0f);
}

int main(void)
{
     glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); // Cria a tela em modo single (uma camada) e sistema RGB
     glutInitWindowSize(500,500);
     glutCreateWindow("Triângulo");

     // callbacks
     glutDisplayFunc(Desenha);
     glutReshapeFunc(AlteraTamanhoJanela);

     Inicializa();
     glutMainLoop();
}

Esse código resultara nisto:

Diferenças entre glMatrixMode(GL_PROJECTION) e glMatrixMode(GL_MODELVIEW)

glMatrixMode(GL_PROJECTION) serve para avisar ao OpenGL que todas as futuras alterações, tais como operações de escala, rotação e translação, irão afetar a “câmera” (ou observador).

Já glMatrixMode(GL_MODELVIEW) avisa ao OpenGL que todas as futuras alterações, tais como operações de escala, rotação e translação, irão afetar os modelos da cena, ou em outras palavras, o que é desenhado.

Linhas pontos e polígonos

Argumentos para a função glBegin():

GL_LINES: exibe uma linha a cada dois comandos glVertex;
GL_LINE_STRIP: exibe uma seqüência de linhas conectando os pontos definidos por glVertex;
GL_LINE_LOOP: exibe uma seqüência de linhas conectando os pontos definidos por glVertex e ao final liga o primeiro como último ponto
GL_POLYGON: exibe um polígono convexo preenchido, definido por uma seqüência de chamadas a glVertex;
GL_TRIANGLES: exibe um triângulo preenchido a cada três pontos definidos por glVertex;
GL_TRIANGLE_STRIP: exibe uma seqüência de triângulos baseados no trio de vértices v0, v1, v2, depois, v2, v1, v3, depois, v2, v3, v4 e assim por diante;
GL_TRIANGLE_FAN: exibe uma seqüência de triângulos conectados baseados no trio de vértices v0, v1, v2, depois, v0, v2, v3, depois, v0, v3, v4 e assim por diante;
GL_QUADS: exibe um quadrado preenchido conectando cada quatro pontos definidos por glVertex;
GL_QUAD_STRIP: exibe uma seqüência de quadriláteros conectados a cada quatro vértices; primeiro v0, v1, v3, v2, depois, v2, v3, v5, v4, depois, v4, v5, v7, v6, e assim por diante