Criando nosso primeiro programa em C++ e OpenGL

1. Criando uma simples janela

O que posso dizer é que a experiência de estar estudando OpenGL não está sendo umas das mais agradáveis.

Até que estou gostando da biblioteca, mas para quem já programou em XNA é difícil de se acostumar com as coisas que temos que fazer na mão em OpenGL. Em XNA nós nos preocupamos apenas com a “regra” do jogo em si.

Um exemplo disto é a criação de uma simples janela. Em XNA não precisamos codificar nada para mostrar uma janela para o usuário. Já em OpenGL temos que codificar algumas linhas.

Neste post iremos analisar o código que é necessário para criar e exibir uma simples janela para o usuário.

   1: #include <GL/glut.h>

   2: 

   3: void drawWindow()

   4: {

   5:     glClearColor(1.0f, 0.5f, 0.0f, 1.0f);

   6:     glClear(GL_COLOR_BUFFER_BIT);

   7:     glFlush();

   8: }

   9: 

  10: int main(int argc, char *argv[])

  11: {

  12:     glutCreateWindow("Olá Mundo OpenGL");

  13:     glutDisplayFunc(drawWindow);

  14:     glutMainLoop();

  15:     return 1;

  16: }

1. glutCreateWindow: Criar a janela com de nome “Olá Mundo OpenGL”
   
   
2. glutDisplayFunc: Informa que função será chamada sempre que a janela necessitar ser redesenhada. Neste exemplo, a função chamada é a “drawWindow”
   
   
3. glClear: Limpa a janela e repinta com a cor que é passada para a função glClearColor
   
   
4. glFlush: Força a execução dos comandos da biblioteca GL(Caso tire esta linha, a sua janela pode ficar com o fundo transparente).
   
   
5. glutMainLoop: Dá início ao processamento do ciclo de eventos do glut que serão executados em loop.

2. Desenhando nossa primeira primitiva

Para desenharmos primitivas em nossa janela é bastante simples. Temos uma função no OpenGL chamada “glVertex3f” que é responsável por definir pontos em nosso plano cartesiano.

As coordenadas de nossa janela estão definidos desta maneira:

Para desenharmos uma série de pontos e interligá-los, temos que definir um escopo onde iremos informar os pontos. Este escopo é informado com as funções glBegin(x) e glEnd().

A função glBegin recebe um parâmetro que informa como irá ocorrer a ligação entre os pontos. Os possíveis parâmetros são:

1. GL_POINTS – Desenhamos apenas pontos em nosso plano.
2. GL_LINES – São desenhadas linhas independentes entre dois pontos.
3. GL_LINE_STRIP – Liga todos os pontos (não fecha o circuito)
4. GL_LINE_LOOP – Liga todos os pontos (fecha o circuito)
5. GL_TRIANGLES – A cada três vértices forma um triângulo
6. GL_TRIANGLE_STRIP - Liga uma série de triângulos, formando uma tira com os mesmos.
7. GL_TRIANGLE_FAN – A palavra "fan" significa “leque” em portugues. Ou seja, criamos um leque em nosso plano.
8. GL_QUADS – A cada quatro vértices definidos, é desenhado um quadrado em nossa tela.
9. GL_QUAD_STRIP – Forma uma malha com os quadrados.
10. GL_POLYGON – Polígono convexo simples.

Como exemplo, iremos desenhar um triângulo em nossa tela. O código fica da seguinte maneira:

   1: #include <GL/glut.h>

   2: 

   3: void drawWindow()

   4: {

   5:     glClearColor(1.0f, 0.5f, 0.0f, 1.0f);

   6:     glClear(GL_COLOR_BUFFER_BIT);

   7: 

   8:     glBegin(GL_TRIANGLES);

   9:     glVertex3f(0.0f, 0.5f, 0.0f);

  10:     glVertex3f(-0.5f, -0.5f, 0.0f);

  11:     glVertex3f(0.5f, -0.5f, 0.0f);

  12:     glEnd();

  13: 

  14:     glFlush();

  15: }

  16: 

  17: int main(int argc, char *argv[])

  18: {

  19:     glutCreateWindow("Olá Mundo OpenGL");

  20:     glutDisplayFunc(drawWindow);

  21:     glutMainLoop();

  22:     return 1;

  23: }

Abraços!!!

Obs: Este post foi publicado, também, em meu blog (http://fpimentel88.wordpress.com)