Top links de computação gráfica

Neste post iremos citar uma lista de links que possuam como assunto principal a computação gráfica.

Se vocês souberem de algum link a mais, por favor, respondam ao post.

Vamos ao que interessa:

  1. http://opengl.luciopaiva.com/
  2. http://orion.lcg.ufrj.br/compgraf1/downloads/glut-3.spec.pdf
  3. http://orion.lcg.ufrj.br/compgraf1/downloads/OpenGL%20Programming%20Guide%20-%20RedBook.pdf
  4. http://www.inf.pucrs.br/~manssour/OpenGL/Tutorial.html
  5. http://www.inf.ufsc.br/~awangenh/CG/apostilas/openGL/
  6. http://nehe.gamedev.net/default.asp

Abraços.

Nosso primeiro programa em OpenGL e C++

1. Mostrando 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:

Untitled

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”. 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!!!

OpenGL no Visual Studio 2008

Início de período letivo bem corrido. Uma das coisas que está consumindo meu tempo é a cadeira de Computação Gráfica da faculdade, onde estamos aprendendo a mexer com OpenGL. E a partir de hoje, compartilho com vocês através deste blog o conhecimento que eu for adquirindo nessa matéria.

Neste Post iremos aprender como configurar nosso ambiente de desenvolvimento. Ou seja, instalar e configurar o OpenGl, Glut e Glui no Visual Studio 2008

1. Baixando os arquivos

Adquira os arquivos no seguinte link:

http://cid-2d6d3503299ba131.skydrive.live.com/self.aspx/Artigos/Configuration%20Files.rar

Descompacte os arquivos em seu local de preferência.

2. Colocando os arquivos em seus devidos locais
  1. Copie os arquivos com extensão .h (glui.h e glut.h) para a pasta
    C:Program FilesMicrosoft SDKsWindowsv6.0AIncludegl

    Obs: A pasta “gl” deve estar deste modo agora:
    ScreenShot003

  2. Copie os arquivos com extensão .Lib (glut32.lib e glui32.lib) para a pasta
    C:Program FilesMicrosoft SDKsWindowsv6.0ALib
  3. Agora copie a dll glut32.dll e copie para o system32
    C:WindowsSystem32

Agora nosso ambiente está pronto.

3. Configurando o Visual Studio 2008
  1. Crie um novo projeto c++ no visual studio.
    ScreenShot004

    ScreenShot005

    ScreenShot006

  2. Agora vamos configurar o nosso projeto.
  3. Click com o botão direito no projeto e selecione “properties”ScreenShot007
  4. Expanda a opção “Configuration Properties”ScreenShot008
  5. Altere a opção “configuration” para “all configurations”ScreenShot009
  6. Expanda “Linker” e selecione “Input”ScreenShot010
  7. Selecione “Addtion Dependencies”ScreenShot011
  8. Adicione as referências aos “Libs” (OpenGL32.Lib, glut32.Lib e glui32.Lib)ScreenShot012

Nosso ambiente já está pronto. Agora você já pode começar a brincar com as bibliotecas vistas no post.