O documento apresenta uma introdução à OpenGL, uma biblioteca gráfica para modelagens 2D e 3D, destacando suas características, restrições e implementações. Ele inclui um exemplo de programa básico em OpenGL e discute a estrutura do código, callbacks e primitivas de desenho. Além disso, sugere exercícios práticos para aperfeiçoar o entendimento da biblioteca.

1. Introdução à Computação Gráfica
Aula – Introdução à OpenGL
Herbet Ferreira
herbet@di.ufpb.br
08/04/2010 1

2. Introdução à OpenGL
• Open Graphic Library (http://www.opengl.org)
• Biblioteca de rotinas gráficas de modelagens 2D e 3D, extremamente
portável e rápida;
• Introduzida em 1992 pela Silicon Graphics;
– Conceber API gráfica independente do dispositivo de exibição
• Gerenciado por um consórcio formado pelas principais empresas da área:
– 3Dlabs, Apple, Nvidia, SGI e SUN;
– Frequentes revisões proporcionam a incorporação das mais recentes técnicas
e da evoluação do hardware;
• Todas as rotinas são implementadas em C/C++
08/04/2010 2

3. Características
• Recursos gráficos:
– Desenhos de primitivas:
• Pontos, Linhas e Polígonos;
– Iluminação;
– Sombreamento;
– Mapeamento de Texturas;
– Transparência;
• Implementações de OpenGL:
– opengl32.dll (Microsoft)
– opengl.dll (SGI)
– mesa3d (GNU)
08/04/2010 3

4. Restrições
• As funcionalidades fornecidas pela OpenGL são de baixo nível;
• Não fornecem funcionalidades e gerenciamento de janelas e
tratamento de eventos.
• Solução:
– Extensão da OpenGL através de novas bibliotecas
– GLU (OpenGL Utility Library)
• Manipulação de matrizes;
• Orientação da visualização;
• Geração de superfícies quadráticas;
– GLUT (OpenGL Utility Toolkit)
• Criação de janelas e menus
• Gerenciamento de janelas e interações do usuário
08/04/2010 4

5. Programa Básico em OpenGL
#include <GL/glut.h> // headers
void Desenha (void) { // rotinas
...
}
int main(int argc, char **argv)
{
glutInit(&argc,argv); // inicia a GLUT
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); // define o modo de exibição
glutInitWindowSize(400,350); // tamanho da janela gráfica
glutInitWindowPosition(10,10); // define posição da janela
glutCreateWindow (“Quadrado"); // cria a janela gráfica
glutDisplayFunc(Desenha); // apresentação da cena
Inicializa(); // definir estado inicial da opengl
glutMainLoop(); // inicia o laço gráfico
}
08/04/2010 5

6. Cabeçalhos
#include <GL/glut.h>
• Já inclui automaticamente os headers da
OpenGL:
– #include <GL/gl.h>
– #include <GL/glu.h>
• Se a GLUT não for usada, os cabeçalhos da
OpenGL tem que ser incluídos explicitamente.
08/04/2010 6

7. Estrutura do Main
• Inicialização da glut:
glutInit(&argc, argv);
• Informar o modo do display a ser utilizado:
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
– GLUT_SINGLE
• janela com buffer simples (todos os desenhos serão feitos
nessa janela)
– GLUT_RGB
• sistema de cor utilizado será o RGB
08/04/2010 7

8. Estrutura do Main
• Definir tamanho, posição inicial e nome da
janela criada:
glutInitWindowSize (400, 350);
glutInitWindowPosition (10, 10);
glutCreateWindow (“Nome da Janela");
• Definir estado inicial do OpenGL:
Inicializa();
void Inicializa(void)
{
glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // cor de fundo da tela
glMatrixMode(GL_PROJECTION); // seleciona matriz de projeção
glLoadIdentity(); // lê a matriz de identidade
gluOrtho2D(0.0, 250.0, 0.0, 250.0); // projeção paralela
}
08/04/2010 8

9. Registrando Callbacks
• Callbacks são rotinas que serão chamadas
para tratar eventos;
• Para uma rotina callback ser efetivamente
chamada, ela precisar ser registrada através
da função:
glutXXFunc (callback);
– Onde XX designa uma classe de eventos;
– callback é o nome da rotina;
08/04/2010 9

10. Callback de desenho
• É a rotina chamada sempre que a janela
precisa ser redesenhada;
glutDisplayFunc(Desenha);
void Desenha (void)
{
glClear(GL_COLOR_BUFFER_BIT); // limpa buffers
glColor3f(1.0f, 0.0f, 0.0f); // cor vermelha
glBegin(GL_QUADS); // inicio do desenho
glVertex2i(100,150);
glVertex2i(100,100);
glVertex2i(150,100);
glVertex2i(150,150);
glEnd(); // fim do desenho
glFlush(); // exibe o desenho na tela
}
08/04/2010 10

11. Resultado do Exemplo
08/04/2010 11

12. Primitivas de Desenho
• Parâmetros de glBegin():
– GL_POINTS: cada vértice como simples ponto
– GL_LINES: cada par de vértices forma uma reta
– GL_LINE_STRIP: traça um grupo de segmentos do
primeiro ao último vértice
– GL_LINE_LOOP: traça um grupo de segmentos do primeiro
ao último vértice, e retorna ao primeiro
– GL_TRIANGLES: cada trio de vértices como sendo os
vértices de um triângulo
– GL_QUADS: cada grupo de 04 vértices como sendo os
vértices de um quadrilátero
– GL_POLYGON: grupo de vértices como sendo os vértices de
um polígono
08/04/2010 12

13. Primitivas de desenho
08/04/2010 13

14. Outros Callbacks
glutKeyboardFunc(keyborad);
– Eventos do teclado
glutSpecialFunc(special);
– Teclas especiais  Home, End, PageDown, PageUp
glutMouseFunc(mouse);
– Interação com o muse
glutMotionFunc(motion);
– Movimentos do mouse
08/04/2010 14

15. Convenções de Nomes
glVertex3f(x, y);
Tipo de dado
Número de componentes b – byte
2 – (x, y) ub – unsigned byte
3 – (x, y, z) s – short
4 – (x, y, z, w) us – unsigned short
i – int
ui – unsigned int
f – float
d - double
08/04/2010 15

16. Exercícios
1. A partir do programa básico, implemente
outras primitivas de desenho da OpenGL.
2. Implemente os algoritmos de traçado de
linhas DDA e Bresenham, fazendo a
comparação do tempo de execução de cada
um para uma mesma reta.
08/04/2010 16