Tutoriais‎ > ‎Computação Gráfica‎ > ‎

Introdução ao OpenGL

postado em 16 de fev de 2015 05:28 por Prof. Rodrigo Costa   [ 16 de fev de 2015 05:33 atualizado‎(s)‎ ]
O OpenGL é uma ferramenta gráfica utilizada para geração de gráficos 2D e 3D, capaz de gerar gráficos de alta qualidade através de primitivas vetoriais e matriciais.
O OpenGL funciona como uma máquina de estados em que registra-se as ações decorrentes ao acontecimento de eventos como: 
–Mouse foi apertado
–Janela foi redimensionada
–Teclado foi pressionado
Esses eventos são escutados por um monitor do próprio OpenGL que inicia as ações programadas.
Cada evento dispara ações programadas pelo usuário ou seja, os eventos são tratados por rotinas callback da aplicação.

O OpenGL é composto por três partes:
  • —GLUT ( OpenGL Utility Toolkit)
    • —API portátil de acesso aos sistemas de janelas
    • —Encapsula e esconde as camadas proprietárias
    • —Não é parte oficial do OpenGL
  • GLU ( OpenGL Utility Library )
    • Parte do padrão OpenGL
    • NURBS, trianguladores , quádricas , etc.
  • AGL, GLX, WGL
    • Camadas entre o OpenGL os diversos sistemas de janelas

1. Configurando o Glut em Seu Computador

Nos links disponíveis a seguir é apresentado um guia passo a passo que ilustra o processo de configuração da biblioteca glut em Windows e Linux

  • https://sites.google.com/site/rodccosta/tutoriais/computacao-grafica/glut-linux
  • https://sites.google.com/site/rodccosta/tutoriais/computacao-grafica/glut-windows

Bem como utilizar o assistente disponível no CodeBlocks

  • https://sites.google.com/site/rodccosta/tutoriais/computacao-grafica/primeiroprojetoglutnocodeblocks

Estrutura de um Código C que utiliza a biblioteca Glut

#include <windows.h>
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
#include <stdio.h>
#include <stdlib.h>

CARREGAMENTO DE BIBLIOTECAS

OBS: O include <windows.h> é necessário apenas na plataforma windows

/* Declaração de Callbacks */
static void display(void)
{
glColor3d(1,0,0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glutSwapBuffers();
}

Nesta fase são implementadas as ações decorrentes de eventos. Neste exempo é configurada a ação de limpar a tela após cada evento de solicitação de atualização de tela. 

int main(int argc, char *argv[])
{
// inicialização
glutInit(&argc, argv);
glutInitWindowSize(640,480);
glutInitWindowPosition(10,10);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutCreateWindow("GLUT Shapes");

// registro de callbacks
glutDisplayFunc(display);

glClearColor(1,1,1,1);
glutMainLoop();

return EXIT_SUCCESS;
}

Função principal para inicialização do sistema e registro das calbacks para os eventos desejados. 

Neste exemplo só foi configurada a calback para o evento de atualização de tela.

Comentário sobre cada função de inicialização

glutInit ( int * argc , char ** argv )

Estabelece contato com sistema dejanelas. 
Pode-se passar alguns parâmetros aos sistema na chamada de função,

glutInitDisplayMode ( int modo )

Estabelece o tipo de recursos necessáriospara as janelas que serão criadas. Modo é um “ou” bit-a-bit de constantes:

•GLUT_RGB cores dos pixels serão expressos em RGB
•GLUT_DOUBLE bufferização dupla (ao invés de simples)
•GLUT_DEPTH buffer de profundidade (z-buffer)
•GLUT_ACCUM buffer de acumulação
•GLUT_ALPHA buffer de cores terá componente alfa

glutInitWindowPosition ( int x, int y)

Estabelece a posiçãoinicial do canto superior esquerdo da janela a ser criada

glutInitWindowSize ( int width , height )

Estabelece o tamanho (em pixels) da janela aser criada

int glutCreateWindow (char* nome)

Cria uma nova janela primária (top-level). O Nome é tipicamente usado para rotular a janela O número inteiro retornado é usado pelo GLUT para identificar a janela

glutMainDisplayLoop ()

Esta rotina na verdade é o “despachante” de eventos. Uma vez executada, a função principal é bloqueada pois estará tratando os eventos. Uma vez nela, só um evento pode fazer com que ela retorne

3. Registrando Callbacks

Os callbacks são rotinas que serão chamadas para tratar eventos. Para uma rotina callback ser efetivamente chamada ela precisa ser registrada através de funções que tem sintaxe similar a mostrada abaixo:

Exemplos:
  • GlutDisplayFunc ( callback ) 
  • GluMouseFunc ( callback ) 
Na tabela a seguir é apresentada a função de registro de calback e um template para cada função de calback e a descrição de seus parametros de entrada.
Função de Registro Modelo do Calback Descrição e Parametros
glutDisplayFunc(display)

void display ( void )
{
}

evento chamado quando um pixel na janela necessita ser atualizado.
glutReshapeFunc(reshape) void reshape ( int width , int height )
{
}
evento chamado quando a janela é redimensionada. Recebe como parametro os novos tamanho da janela (width, heigth)
glutKeyboardFunc(keyboard)  void keyboard(unsigned char key, int x, int y)
{
}
evento chamado ao pressionar uma tecla. Possui parametros key = tecla pressionada e (x,y) são as coordenadas do mouse.
glutMouseFunc(mouse) 
void mouse (int button, int state, int x, int y)
{

}
evento chamado ao pressionar um clicque do mouse.
Possui parametros button = botao pressionado e (x,y) são as coordenadas do mouse e State é o status do pressionamento (Clique ou liberação).
glutMotionFunc(motionPressed)

void motionPressed(int x, int y) {
}

chamada quando o usuário movimenta o mouseenquanto mantém um botão do mesmo pressionado.
(x,y) são as coordenadas do mouse 
glutPassiveMouseFunc(passiveMotion)  void passiveMotion(int x, int y) chamada quando o usuário movimenta o mouse enquanto mantém um botão do mesmo pressionado.
(x,y) são as coordenadas do mouse 
glutIdleFunc(idle)

void idle(void)
{

}

uma função de callback chamada quando nada nenhum evento foi pressionado. 

4. Desenhando primitivas

Dentro da função display ou qualquer momento do código você pode fazer solicitações de desenho.

  • glClearColor(R,G,B,A); escolhe a cor do fundo;
  • glClear( GL_COLOR_BUFFER_BIT ); limpa a tela
  • glColor3f(R,G,B) : especifica a cor de desenho atual;

Para desenhar algo, deve-se utilizar a estrutura a seguir :

glBegin(PRIMITIVA);
   glVertex2f(x,y);
  .....
glEnd();

Importante: por padrão o opengl só permite visualizar objetos que possuem -1 < x < 1 e -1 < y < 1.

As primitivas são configuráveis e você escolhe-as dentre os tipos a seguir:


Exemplo:

glBegin(GL_LINE_LOOP);
glVertex2f(0.114,-0.048);
glVertex2f(0.160,-0.122);
glVertex2f(0.176,-0.205);
glVertex2f(
0.092,-0.205);
glVertex2f(0.043, -0.130);

Resultado


Comments