CG aula04 OpenGL introd v2 2017 2

Prévia do material em texto

Computação Gráfica I1
 OpenGL é uma API implementada de forma a gerar imagens de alta 
qualidade e aproveitar funções de aceleração gráfica do hardware (se 
disponíveis).
 OpenGL se apresenta como um conjunto aproximadamente 250 
rotinas que permitem que as aplicações manipulem objetos no 
espaço bi e tridimensional. 
 Possui primitivas vetoriais e matriciais (imagens)
 OpenGL é independente de plataformas e de linguagem de 
programação, porque seu conjunto de rotinas pode ser explorado a 
partir de várias linguagens (C/C++, Delphi, VB, etc).
 No ambiente Linux existe uma implementação chamada Mesa
(http://www.mesa3d.org).
 Para obter as diversas bibliotecas e características de implementação 
acesse o site do OpenGL (http://www.opengl.org)
OpenGL - Fundamentos
Computação Gráfica I2
• Uma API atua como interface entre o código da aplicação e o hardware. 
• As APIs mais populares (OpenGL, DirectX, Java3D, PHIGS, GKS-3D) são 
baseadas em modelos de câmeras sintéticas. 
• Possuem funções que especificam e simulam: objetos, observadores, 
fontes de luz e propriedades dos materiais 
OpenGL - Fundamentos
Computação Gráfica I3
Sistemas de Janela
• A Janela é o principal meio de interação homem/máquina em 
ambientes de computação modernos
• A tela é dividida em janelas (eventualmente superpostas), que são 
controladas por aplicações que têm a obrigação de mantê-las 
sempre atualizadas
• Interação do usuário e do próprio sistema de janelas são 
comunicados à aplicação através de eventos:
– Mouse foi apertado
– Janela foi redimensionada
• Eventos são tratados por rotinas callback da aplicação:
– Redesenhar o conteúdo da janela
– Mover um objeto de um lado para outro da janela
• Cada Sistema de Janelas possui uma API distinta
– MS Windows, X, Apple
– Portabilidade: Camada de interface com diversos sistemas de 
janelas mas com API única (ex: GLUT) 
Computação Gráfica I4
 Um programa OpenGL normalmente utiliza três bibliotecas distintas:
 OpenGL: biblioteca básica que implementa os comandos de mais baixo nível 
ou comandos primitivos. Suas funções tem o prefixo gl.
 GLU: biblioteca que utiliza as funcões da biblioteca OpenGL para realizar 
tarefas de mais alto nível, como por exemplo, fazer a renderização de uma 
superfície. Essa biblioteca é fornecida como parte da OpenGL e suas 
funções tem o prefixo glu. Ex: NURBS, trianguladores, quádricas, etc
 GLUT: é uma biblioteca independente de plataforma que incluir elementos 
para gerenciamento de janelas e dispositivos de entrada (menus, mouse, 
joystick, teclado, etc.). As funções dessa biblioteca tem sempre o prefixo 
glut. Encapsula e esconde as camadas proprietárias.
 Logo é necessário ter essas 3 bibliotecas instaladas para poder criar programas 
usando OpenGL.
OpenGL - Bibliotecas
Computação Gráfica I5
 O pipeline gráfico OpenGL pode ser visto de forma simplificada como:
 OpenGL lida somente com objetos gráficos.
 A manipulação de janelas e menus e o tratamento de eventos de mouse 
e teclado são realizados por outras bibliotecas.
OpenGL - Fundamentos
Computação Gráfica I6
 Ordem da Programação: 
– Comandos ou display list 
– Ajuste do estado (transformações geométricas, cores, etc.) 
– Operações de vértice e montagem de primitivas 
– Aplicação das transformações e sombreamentos 
– Criação de triângulos/linhas/pontos 
– Rasterização de primitivas para pixel 
– Operações por pixel, blending, texturas, etc. 
– Frame buffer 
Arquitetura do OpenGL
Computação Gráfica I7
Arquitetura do OpenGL
Listas de
Display
Avaliador
Polinomial
Operações
por vértice
& Montagem
de primitivas
Rasterização
Operações
por Fragmento
Frame
Buffer
Memória de 
Textura
CPU
Operações
sobre
pixels
Computação Gráfica I8
Desenhando com OpenGL
• OpenGL funciona como uma máquina de estados
• API tem rotinas para
– Desenhar primitivas geométricas e imagens
– Alterar variáveis de estado (ex: cor, material, fontes de 
iluminação, etc)
– Consultar variáveis de estado
• OpenGL é um padrão em evolução
– Mecanismo padronizado de extensões
– Novas versões são estabelecidas por um comitê (ARB) de 
usuários e fabricantes
Computação Gráfica I9
Programa básico OpenGL/GLUT
#include <GL/glut.h>
/* Outros headers */
void display (void) {
...
}
/* Outras rotinas callback */
int main (int argc, char *argv[]) {
glutInit (argc, argv);
glutInitDisplayMode( modo );
glutCreateWindow( nome_da_janela );
glutDisplayFunc( displayCallback );
glutReshapeFunc( reshapeCallback );
/* Registro de outras rotinas callback */
glutMainLoop();
return 0;
}
Headers
Rotinas Callback
Inicialização da janela
Registro de callbacks
Laço principal
Inicialização do GLUT
Computação Gráfica I10
Headers OpenGL/GLUT
A declaração: #include <GL/glut.h>
já inclui automaticamente os headers do OpenGL:
#include <GL/gl.h>
#include <GL/glu.h>
• Se GLUT não for usado, os headers OpenGL têm que ser incluídos 
explicitamente, junto com os headers de outra camada de interface
Computação Gráfica I11
GLUT – Registrando Callbacks
• Callbacks são rotinas que serão chamadas para tratar 
eventos. 
• Para uma rotina callback ser efetivamente chamada 
ela precisa ser registrada através da função
glutXxxFunc (callback)
– Onde Xxx designa uma classe de eventos e 
callback é o nome da rotina
• Por exemplo, para registrar uma callback de 
desenho chamada Desenho, usa-se
glutDisplayFunc (Desenho);
Computação Gráfica I12
GLUT – Callback de desenho
• É a rotina chamada automaticamente sempre que a 
janela ou parte dela precisa ser redesenhada 
• Todo programa GLUT precisa ter uma rotina de call-
back para desenho
• Exemplo:
void display ( void )
{
glClear( GL_COLOR_BUFFER_BIT );
glBegin( GL_TRIANGLE_STRIP );
glVertex3fv( v[0] );
glVertex3fv( v[1] );
glVertex3fv( v[2] );
glVertex3fv( v[3] );
glEnd();
glutSwapBuffers(); /* Usamos double-buffering! */
} 
Computação Gráfica I13
GLUT – Callback de redimensionamento
• Chamada sempre que a janela é redimensionada, isto é, 
teve seu tamanho alterado
• Tem a forma
void reshape (int width, int height){...}
– width/height são a nova largura/altura da janela (em pixels)
• Se uma rotina de redimensionamento não for 
especificada, o GLUT usa uma rotina de 
redimensionamento “default” que simplesmente ajusta o 
viewport para usar toda a área da janela 
Computação Gráfica I14
GLUT - Callbacks
• Outras callbacks comumente usadas
• Eventos de teclado
void keyboard (unsigned char key, int x, int y)
• Eventos de mouse
void mouse(int button, int state, int x, int y)
void motion(int x, int y) 
void passiveMotion(int x, int y)
• Chamada continuamente quando nenhum outro evento ocorre
void idle (void)
Computação Gráfica I15
Programa OpenGL/GLUT - Inicialização
• Inicialização da(s) janela(s)
glutInitDisplayMode (int modo)
• Estabelece o tipo de recursos necessários para 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ção inicial do canto inferior esquerdo da 
janela a ser criada
glutInitWindowSize (int width, height)
• Estabelece o tamanho (em pixels) da janela a ser criada
Computação Gráfica I16
Programa OpenGL/GLUT - Inicialização
• Criação da(s) janela(s)
int glutCreateWindow (char* nome)
• Cria uma nova janela primária (top-level)
•Nome é tipicamente usado para rotular a janela
• O número inteiro retornado é usado pelo GLUT para 
identificar a janela
• Outras inicializações
– Após a criação da janela é comum configurar 
variáveis de estado do OpenGL que não mudarão no 
decorrer do programa. Por exemplo:
• Cor do fundo
• Tipo de sombreamento de desejado
Computação Gráfica I17
Programa OpenGL/GLUT – Laço Principal
• Depois de registradas as callbacks, o controle é entregue ao 
sistema de janelas:
glutMainLoop (void)
• Esta rotina na verdade é o “despachante” de eventos
• Ela nunca retorna
Computação Gráfica I18
OpenGL – Primitivas de desenho
glBegin ( PRIMITIVA );
especificação de vértices, cores, coordenadas de textura, 
propriedades de material
glEnd ();
• Entre glBegin() e glEnd() apenas alguns comandos podem 
ser usados. Ex.:
– glMaterial
– glNormal
– glTexCoord
• Uma vez emitido um vértice (glVertex), este é desenhado com 
as propriedades (cor, material, normal, coordenadas de textura 
etc) registradas nas variáveis de estado correspondentes
• Conclusão: Antes de emitir um vértice, assegurar-se que cor, 
material, normal, etc, têm o valor certo
Computação Gráfica I19
OpenGL – Primitivas de desenho
v2
v4
v1
v5
v3
v2
v4
v1
v5
v3
v6
v5
v6
v3
v4
v1
v2 v5
v6
v3
v4
v1
v2
v6
v3
v4
v1
v2
v2
v4
v1
v3
v6
v7v8
v5
v2
v4
v1
v3
v5
v6
GL_POINTS
GL_LINES
GL_LINE_STRIP GL_LINE_LOOP
GL_POLYGON
GL_TRIANGLE_FAN
GL_QUADS
GL_QUAD_STRIP
v2
v1
v4
v5
v3
GL_TRIANGLE_STRIP
v1
v2
v3
v4
v5
v6
GL_TRIANGLES
Computação Gráfica I20
OpenGL – Exemplo de desenho simples
void drawRhombus( GLfloat color[] )
{
glBegin( GL_QUADS );
glColor3fv( color );
glVertex2f( 0.0, 0.0 );
glVertex2f( 1.0, 0.0 );
glVertex2f( 1.5, 1.118 );
glVertex2f( 0.5, 1.118 );
glEnd();
} 
Computação Gráfica I21
OpenGL – Controlando as cores
• Cores especificadas diretamente (default)
– Usar glColorIndex() ou glColor()
• Computadas a partir de um modelo de iluminação 
– Ligar a iluminação: glEnable (GL_LIGHTING);
– Escolher modelo de sombreamento: 
• Constante por face: glShadeModel (GL_FLAT);
• Gouraud (default): glShadeModel (GL_SMOOTH);
– Ligar ao menos uma fonte de luz: glEnable(GL_LIGHT0);
– Especificar propriedades da(s) fonte(s) de luz: glLight()
– Especificar propriedades de material de cada objeto: glMaterial()
– Especificar normais de cada face ou de cada vértice: glNormal()
Computação Gráfica I22
OpenGL – Convenções de Nome
glVertex3fv( v )
Número de
componentes
2 - (x,y) 
3 - (x,y,z)
4 - (x,y,z,w)
Tipo de dado
b - byte
ub - unsigned byte
s - short
us - unsigned short
i - int
ui - unsigned int
f - float
d - double
vetor
omita o “v” qdo
coords dadas uma a uma
glVertex2f( x, y )
Computação Gráfica I23
OpenGL - Especificando Cores
color index mode
Display1
2
4
8
16
www
www
Red Green Blue
0
1
2
3
24
25
26
123 219 74
ww
ww
RGBA mode
Computação Gráfica I24
 Dependendo do compilador e do sistema operacional, existem 
passos distintos para a preparação do ambiente de desenvolvimento 
para uso do OpenGL.
 Veremos os passos para preparação do ambiente no Dev C++ 4.9. 
 A versão Dev C++ 4.9 já vem com as bibliotecas OpenGL e GLU 
pré-instaladas, mas precisamos instalar o GLUT.
OpenGL - Instalação
Computação Gráfica I25
 No menu do Dev C++ selecione a opção Tools->Check for Updates/ 
Packages. A janela de gerenciamento de atualizações irá se abrir.
OpenGL - Instalação
Computação Gráfica I26
 Na lista “Select devpak server” selecione "devpacks.org 
community devpacks“ e depois clique em “Check for updates”.
OpenGL - Instalação
Computação Gráfica I27
 Na lista de atualizações disponíveis, marque GLUT e clique em 
“Dowload selected”
OpenGL - Instalação
Computação Gráfica I28
 Para criarmos um programa OpenGL precisamos informar ao Dev C++ onde
se encontram as diversas bibliotecas necessárias:
 Criar um novo programa
 Acionar a opção Tools->Compiler options
 Ir na aba Compiler
 Preencher os dois campos maiores da tela (vide figura) com os dados:
-DGLUT_STATIC
-lglut32 -lglu32 -lopengl32 -lwinmm -lgdi32
OpenGL – Setup
Computação Gráfica I29
OpenGL – Setup
Computação Gráfica I30
 De forma opcional podemos usar a biblioteca FreeGLUT, sem ter a 
necessidade de instalação:
 Acionar a opção Tools->Compiler options
 Ir na aba Compiler
 Preencher os dois campos maiores da tela (vide figura) com os dados:
-DFREEGLUT_STATIC
-lglu32 -lfreeglut -lopengl32 -lwinmm -lgdi32
OpenGL – FreeGLUT
Computação Gráfica I31
OpenGL – FreeGLUT
Computação Gráfica I32
 Na opção Tools->Compiler options, selecionar na aba Directories
 Na aba Libraries, adicionar o caminho dos subdiretórios onde estão
arquivos correspondentes da biblioteca “freeGLUT”
 Na abas C Includes e C++ Includes adicionar o caminho dos 
subdiretórios onde estão arquivos correspondentes
OpenGL – FreeGLUT
Computação Gráfica I33
OpenGL – FreeGLUT
Computação Gráfica I34
OpenGL – FreeGLUT
Computação Gráfica I35
OpenGL – FreeGLUT
Computação Gráfica I36
OpenGL – FreeGLUT
Computação Gráfica I37
OpenGL – FreeGLUT
Computação Gráfica I38
OpenGL – FreeGLUT
Computação Gráfica I39
#include <gl/glut.h> //#include <gl/freeglut.h>
// Função callback chamada para fazer o desenho propriamente dito
void desenha(void)
{
//Limpa o buffer com a cor de fundo especificada
glClear(GL_COLOR_BUFFER_BIT);
//Executa os comandos OpenGL 
glFlush();
}
// Inicializa parâmetros de renderizacao
void inicializa (void)
{ 
// Define a cor de fundo da janela de visualização (RGBA)
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
}
int main(void)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutCreateWindow("Primeiro Programa");
glutDisplayFunc(desenha);
inicializa();
glutMainLoop();
}
OpenGL – Primeiro programa
Computação Gráfica I40
#include <gl/glut.h>
// Função callback chamada para fazer o desenho propriamente dito
void desenha(void)
{
//Limpa o buffer com a cor de fundo especificada
glClear(GL_COLOR_BUFFER_BIT);
//Executa os comandos OpenGL 
glFlush();
}
// Inicializa parâmetros de renderizacao
void inicializa (void)
{ 
// Define a cor de fundo da janela de visualização (RGBA)
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
}
int main(void)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutCreateWindow("Primeiro Programa");
glutDisplayFunc(desenha);
inicializa();
glutMainLoop();
}
OpenGL – Primeiro programa
Para ter acesso às 
diversas funções 
(OpenGL, GLU, GLUT), 
basta incluir esse 
arquivo
Computação Gráfica I41
#include <gl/glut.h>
// Função callback chamada para fazer o desenho propriamente dito
void desenha(void)
{
//Limpa o buffer com a cor de fundo especificada
glClear(GL_COLOR_BUFFER_BIT);
//Executa os comandos OpenGL 
glFlush();
}
// Inicializa parâmetros de renderizacao
void inicializa (void)
{ 
// Define a cor de fundo da janela de visualização (RGBA)
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
}
int main(void)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutCreateWindow("Primeiro Programa");
glutDisplayFunc(desenha);
inicializa();
glutMainLoop();
}
OpenGL – Primeiro programa
Avisa ao GLUT qual o tipo do 
buffer (GLUT_SINGLE) e o 
esquema de cores RGBA 
(GLUT_RGB).
Com o GLUT_SINGLE todos 
os comandos são 
renderizados diretamente na 
janelade saída. 
Computação Gráfica I42
#include <gl/glut.h>
// Função callback chamada para fazer o desenho propriamente dito
void desenha(void)
{
//Limpa o buffer com a cor de fundo especificada
glClear(GL_COLOR_BUFFER_BIT);
//Executa os comandos OpenGL 
glFlush();
}
// Inicializa parâmetros de renderizacao
void inicializa (void)
{ 
// Define a cor de fundo da janela de visualização (RGBA)
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
}
int main(void)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutCreateWindow("Primeiro Programa");
glutDisplayFunc(desenha);
inicializa();
glutMainLoop();
}
OpenGL – Primeiro programa
Cria uma janela com o título 
especificado
Computação Gráfica I43
#include <gl/glut.h>
// Função callback chamada para fazer o desenho propriamente dito
void desenha(void)
{
//Limpa o buffer com a cor de fundo especificada
glClear(GL_COLOR_BUFFER_BIT);
//Executa os comandos OpenGL 
glFlush();
}
// Inicializa parâmetros de renderizacao
void inicializa (void)
{ 
// Define a cor de fundo da janela de visualização (RGBA)
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
}
int main(void)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutCreateWindow("Primeiro Programa");
glutDisplayFunc(desenha);
inicializa();
glutMainLoop();
}
OpenGL – Primeiro programa
Avisa ao OpenGL que a função 
responsável por desenhar os 
elementos na tela é a função 
desenha().
Essa função é chamada sempre que 
redimensionamos, restauramos ou 
trazemos uma janela para o primeiro 
plano.
Computação Gráfica I44
#include <gl/glut.h>
// Função callback chamada para fazer o desenho propriamente dito
void desenha(void)
{
//Limpa o buffer com a cor de fundo especificada
glClear(GL_COLOR_BUFFER_BIT);
//Executa os comandos OpenGL 
glFlush();
}
// Inicializa parâmetros de renderizacao
void inicializa (void)
{ 
// Define a cor de fundo da janela de visualização (RGBA)
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
}
int main(void)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutCreateWindow("Primeiro Programa");
glutDisplayFunc(desenha);
inicializa();
glutMainLoop();
}
OpenGL – Primeiro programa
A função inicializa() não pertence ao 
OpenGL ou GLUT. Por convenção, os 
programas OpenGL definem uma 
função de inicialização para definir os 
parâmetros gerais da renderização. 
Nesse caso, estamos definindo qual 
vai ser a cor de fundo.
Computação Gráfica I45
#include <gl/glut.h>
// Função callback chamada para fazer o desenho propriamente dito
void desenha(void)
{
//Limpa o buffer com a cor de fundo especificada
glClear(GL_COLOR_BUFFER_BIT);
//Executa os comandos OpenGL 
glFlush();
}
// Inicializa parâmetros de renderizacao
void inicializa (void)
{ 
// Define a cor de fundo da janela de visualização (RGBA)
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
}
int main(void)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutCreateWindow("Primeiro Programa");
glutDisplayFunc(desenha);
inicializa();
glutMainLoop();
}
OpenGL – Primeiro programa
Por último, todo programa OpenGL 
chama essa função, que passa o 
controle para o loop interno da 
biblioteca. Conforme os eventos 
forem acontecendo, o OpenGL vai 
acionar algumas funções do nosso 
programa para tratar esses eventos.
Computação Gráfica I46
#include <gl/glut.h>
// Função callback chamada para fazer o desenho propriamente dito
void desenha(void)
{
//Limpa o buffer com a cor de fundo especificada
glClear(GL_COLOR_BUFFER_BIT);
//Executa os comandos OpenGL 
glFlush();
}
// Inicializa parâmetros de renderizacao
void inicializa (void)
{ 
// Define a cor de fundo da janela de visualização (RGBA)
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
}
int main(void)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutCreateWindow("Primeiro Programa");
glutDisplayFunc(desenha);
inicializa();
glutMainLoop();
}
OpenGL – Primeiro programa
Na inicialização chamamos uma função 
que define a cor de fundo. Essa função 
recebe os parâmetros RGBA, onde A 
significa alpha, ou seja, é o grau de 
opacidade da cor. Os valores RGBA variam 
de 0.0 a 1.0, onde 0.0 significa ausência 
da cor/transparência e 1.0 significa 
intensidade máxima da cor ou opacidade 
máxima.
Computação Gráfica I47
#include <gl/glut.h>
// Função callback chamada para fazer o desenho propriamente dito
void desenha(void)
{
//Limpa a janela de visualizacao com a cor de fundo especificada
glClear(GL_COLOR_BUFFER_BIT);
//Executa os comandos OpenGL 
glFlush();
}
// Inicializa parâmetros de renderizacao
void inicializa (void)
{ 
// Define a cor de fundo da janela de visualização (RGB)
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
}
int main(void)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutCreateWindow("Primeiro Programa");
glutDisplayFunc(desenha);
inicializa();
glutMainLoop();
}
OpenGL – Primeiro programa
Para desenhar a janela a primeira 
coisa que fazemos é limpar o fundo 
para retirar quaisquer elementos 
estranhos que estejam no buffer. A 
cor de fundo usada é aquela definida 
na inicialização.
Computação Gráfica I48
#include <gl/glut.h>
// Função callback chamada para fazer o desenho propriamente dito
void desenha(void)
{
//Limpa o buffer com a cor de fundo especificada
glClear(GL_COLOR_BUFFER_BIT);
//Executa os comandos OpenGL 
glFlush();
}
// Inicializa parâmetros de renderizacao
void inicializa (void)
{ 
// Define a cor de fundo da janela de visualização (RGB)
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
}
int main(void)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutCreateWindow("Primeiro Programa");
glutDisplayFunc(desenha);
inicializa();
glutMainLoop();
}
OpenGL – Primeiro programa
Executa os comandos que estão no 
buffer de comandos do OpenGL (vide 
pipeline).
Sem essa chamada, não veremos o 
resultado na tela.
Computação Gráfica I49
#include <gl/freeglut.h> //#include <gl/glut.h>
// Função callback chamada para fazer o desenho propriamente dito
void desenha(void)
{
//Limpa o buffer com a cor de fundo especificada
glClear(GL_COLOR_BUFFER_BIT);
//Executa os comandos OpenGL 
glFlush();
}
// Inicializa parâmetros de renderizacao
void inicializa (void)
{ 
// Define a cor de fundo da janela de visualização (RGBA)
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutCreateWindow("Primeiro Programa");
glutDisplayFunc(desenha);
inicializa();
glutMainLoop();
}
Primeiro programa - FreeGLUT
Computação Gráfica I50
 Exercício 1: altere o programa anterior para que a cor de fundo seja alterada 
para verde.
OpenGL – Exercício 1
Computação Gráfica I51
 Exercício 1: altere o programa anterior para que a cor de fundo seja alterada 
para verde.
// Inicializa parâmetros de renderizacao
void inicializa (void)
{ 
// Define a cor de fundo da janela de visualização (RGB)
glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
}
OpenGL – Exercício 1
Computação Gráfica I52
 O OpenGL trabalha com sistemas de coordenadas 2D ou 3D.
 Na renderização trabalhamos sempre com coordenadas do mundo real, ou 
seja, usamos as coordenadas do plano bi ou tridimensional que definem o 
objeto.
 Entretanto é preciso fazer o mapeamento do nosso plano para a janela onde 
ele será efetivamente renderizado.
 Para esse mapeamento precisamos definir, primeiramente, a viewport.
 A viewport é a porção da janela do programa que será usada para 
renderização dos objetosgráficos.
 Se não alterarmos o tamanho da viewport, ela ocupará automaticamente 
toda a janela.
OpenGL – Viewport
Computação Gráfica I53
 glViewport(20, 20, 160, 160)
OpenGL – Viewport
200
200
160
160
20
20
A renderização só 
ocorrerá dentro 
dessa área
Computação Gráfica I54
 Agora que temos a viewport, podemos definir os limites do plano cartesiano que será 
mapeado dentro da viewport. Para tal, usamos a função gluOrtho2D(xmin, xmax, ymin, 
ymax).
OpenGL – Coordenadas
160
160
 No exemplo ao lado, se desejássemos mapear 
um plano cartesiano com 1600 pontos no eixo 
x e 1600 pontos no eixo y, teríamos:
gluOrtho2D(-800, 800, -800, 800);
 Com a definição do plano podemos plotar um 
ponto P(400, 400)
 Repare que, nesse exemplo, vários pontos do 
plano cartesiano vão ser mapeados para o 
mesmo pixel.
-800
-800
800
800
P
Computação Gráfica I55
 Por exemplo, para definir o plano cartesiano com intervalo (-10, 10) no 
eixos x e y colocamos o código
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(-10, 10, -10, 10);
na função inicializa().
 Após isso, podemos plotar pontos, segmentos de reta, polígonos, etc., 
nesse plano.
OpenGL – Coordenadas
Computação Gráfica I56
 Para definir o tamanho e a posição iniciais da janela, usamos as 
seguintes funções:
glutInitWindowSize(400,200);
glutInitWindowPosition(10,10);
antes de criar a janela, ou seja, na função main.
OpenGL – Janela
Computação Gráfica I57
#include <gl/glut.h>
// Função callback chamada para fazer o desenho propriamente dito
void desenha(void)
{
//Limpa o buffer com a cor de fundo especificada
glClear(GL_COLOR_BUFFER_BIT);
//Executa os comandos OpenGL 
glFlush();
}
// Inicializa parâmetros de renderizacao
void inicializa (void)
{ 
// Define a cor de fundo da janela de visualização (RGB)
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
// Define o tamanho do plano cartesiano em 10x10
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(-10, 10, -10, 10);
}
int main(void)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(400,200);
glutInitWindowPosition(10,10);
glutCreateWindow(“Segundo programa");
glutDisplayFunc(desenha);
inicializa();
glutMainLoop();
}
OpenGL – Segundo programa
Define o tamanho e posição 
da janela antes de criá-la
Define o tamanho do 
plano cartesiano 
Computação Gráfica I58
Exemplo
#include <GL/glut.h>
void display(void)
{
/* Limpar todos os pixels */
glClear (GL_COLOR_BUFFER_BIT);
/* Desenhar um polígono branco (retângulo) */
glColor3f (1.0, 1.0, 1.0);
glBegin(GL_POLYGON);
glVertex3f (0.25, 0.25, 0.0);
glVertex3f (0.75, 0.25, 0.0);
glVertex3f (0.75, 0.75, 0.0);
glVertex3f (0.25, 0.75, 0.0);
glEnd();
/* Não esperar! */
glFlush ();
}
Computação Gráfica I59
Exemplo
void init (void) 
{ 
/* selecionar cor de fundo (preto) */
glClearColor (0.0, 0.0, 0.0, 0.0);
/* inicializar sistema de viz. */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (250, 250); 
glutInitWindowPosition (100, 100);
glutCreateWindow ("hello");
init ();
glutDisplayFunc(display); 
glutMainLoop();
/* C ANSI requer que main retorne um inteiro */
return 0;
}