Criando nosso primeiro programa em C++ e OpenGL

Aprenda como criar uma janela e desenhar primitivas na mesma.

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)

Artigos relacionados