Opengl - Um Tutorial: Resumo

OpenGL Um tutorial
Luis Valente
Instituto de Computao - Universidade Federal Fluminense
[email protected]
Dezembro, 2004
Resumo
OpenGL uma biblioteca para modelagem e visualizao tridimensional em tempo real,
que est disponvel para vrios sistemas operacionais. Desenvolvida inicialmente pela
Silicon Graphics em 1992, hoje um dos padres da indstria.
Este trabalho uma introduo a conceitos bsicos do OpenGL, desde a configurao
inicial at mapeamento por textura. Assume-se que o leitor possui conhecimento de
linguagem C e saiba utilizar algum compilador ou ambiente de desenvolvimento C
(como o GCC ou Microsoft Visual C++). O ambiente de desenvolvimento usado como
referncia o Microsoft Visual C++, mas os conceitos apresentados so independentes
do ambiente e sistema operacional.
Abstract
OpenGL is an API applied in 3D modeling and real-time 3D visualization, which is
available for many operating systems. The development of OpenGL was started by
Silicon Graphics in 1992, and today it's considered an industry standard.
This work introduces basic OpenGL concepts, from instalation to texture mapping. It's
assumed that the reader has knowledged of the C language and is comfortable in using
C compilers and/or development environments for C (like GCC or Microsoft Visual
C++). Microsoft Visual C++ was adopted as the reference development environment in
this work, although the concepts presented here are compiler and operating system
independent.
UFF - Mestrado em Computao
Luis Valente
1. Introduo
OpenGL (Open Graphics Library) uma biblioteca (API1) para Computao Grfica 3D e 2D
que foi desenvolvida inicialmente por Silicon Graphics Inc. (SGI). Atualmente, adminstrada pela
ARB (Architecture Review Board)2. A ARB uma entidade que congrega vrios representantes da
indstria, como SGI, Intel, NVIDIA e Sun Microsystems.
A API do OpenGL oferece algumas primitivas bsicas (como pontos, linhas, tringulos,
quadrilteros e polgonos), operaes para manipulao do sistema de coordenadas e operaes com
matrizes (translao, rotao e escala) e efeitos como mapeamento de textura, entre outros
comandos.
OpenGL foi projetado para ser utilizado em vrias plataformas e sistemas operacionais, como
Mac OS, OS/2, Unix, Windows, Linux, OPENStep e BeOS. Pode ser utilizado em diversos
ambientes de desenvolvimento de linguagens de programao como Delphi, Visual Basic, C/C++,
Java, Fortran e Python, entre outros. Devido a esse propsito, existem vrias funcionalidades que
no esto disponveis em OpenGL, porque so dependentes da plataforma nativa. Entre essas
funcionalidades, encontram-se janelas (e interface grfica), fontes para texto e comandos para
interao com o usurio (como processamento de eventos do teclado e mouse).
A verso atual do OpenGL 1.53. A biblioteca possui dois componentes principais:
GL: Representa o ncleo do OpenGL, que agrega as funes principais.
GLU: uma biblioteca utilitria, que possui funes diversas para quadrics, NURBS e
matrizes, entre outras.
Uma caracterstica importante de OpenGL que o OpenGL uma API de modo imediato
(immediate mode). Em APIs de modo imediato, os comandos submetidos alteram o estado do
hardware grfico assim que so recebidos. O estado do hardware grfico representa um tipo de
configurao que est em uso no momento, e como essa configurao aplicada internamente pelo
hardware. Por exemplo, uma aplicao pode utilizar iluminao em uma cena. Desta forma, diz-se
que o estado de iluminao est ligado. Quando esse estado ligado, o hardware configurado
internamente para realizar uma srie de operaes que tm a ver com essa funcionalidade.
2. Usando OpenGL
No sistema operacional Windows, o OpenGL j est pronto para uso (em modo simulado, por
software, pelo menos). A implementao da biblioteca est contida em arquivos DLL (opengl32.dll
e glu32.dll) no Windows e em arquivos .so (libGL.so, libGLU.so) no Linux.
Para utilizar plenamente os recursos oferecidos pelo hardware com o OpenGL, preciso
instalar o driver especfico da placa grfica. Esses drivers podem ser encontrados nos sites dos
fabricantes dos chipsets da placa grfica (como NVIDIA4 ou ATI5). No Linux, uma das solues
instalar a Mesa3D6, que uma implementao no-oficial da API do OpenGL. Alguns fabricantes
(como a NVIDIA) oferecem drivers nativos para Linux, que podem ser obtidos no site da empresa.
1
2
3
4
5
6
Application Programming Interface

http://www.opengl.org/about/arb/
A verso 2.0 j est sendo desenvolvida.
http://www.nvidia.com
http://www.ati.com
http://www.mesa3d.org
2
Luis Valente
2.1. Configurao inicial

Esta seo contm instrues de configurao do ambiente de desenvolvimento para criar
aplicaes com OpenGL.
Grande parte dos compiladores C e C++ disponveis j possuem os arquivos necessrios para se
desenvolver programas com OpenGL. Entretanto, a verso do OpenGL que pode ser usada atravs
desses arquivos pode variar bastante. A verso que vm com o Visual C++ 1.1, enquanto o
MinGW (GCC para Windows) possui a verso 1.3.
2.2. Visual C++

Para usar o OpenGL com o Visual C++, preciso incluir os seguintes arquivos nos programas:
#include <windows.h>
#include <GL/gl.h>
#include <GL/glu.h>
O arquivo gl.h possui as funes principais do OpenGL, enquanto o glu.h possui as funes da
biblioteca utilitria.
Os arquivos de ligao com as DLLs so dois: opengl32.lib e glu32.lib (caso se use a GLU).
Esses arquivos podem ser includos nos projetos da seguinte forma:
Visual C++ 6: Acesse o menu Projects e depois Settings. A seguir, acesse a aba
Linker. No campo Object/library modules acrescente opengl32.lib glu32.lib (sem
aspas).
Visual C++ 7 (.NET): Acesse o menu Project e depois Properties. No painel da

esquerda, escolha a pasta Linker e depois Input. No campo Additional dependencies,
acrescente opengl32.lib glu32.lib (sem aspas).
necessrio incluir o arquivo principal do Windows (windows.h), antes dos arquivos do

OpenGL ou erros de compilao sero gerados.
2.3. GCC
Para usar o OpenGL com o GCC, preciso incluir os seguintes arquivos nos programas:
#include <GL/gl.h>
#include <GL/glu.h>
O arquivo gl.h possui as funes principais do OpenGL, enquanto o glu.h possui as funes da
biblioteca utilitria.
Os arquivos de ligao com as DLLs podem ser especificados atravs dos parmetros
-lopengl32 e -lglu32 (caso se use a GLU), tanto em Windows quanto em Linux.
2.4. Convenes
Todos os comandos do OpenGL seguem uma conveno, que pode ser observada na Figura 2.1.
Luis Valente
Figura 2.1 Comando tpico do OpenGL (WrSw99)
O comando retratado na figura possui as seguintes caractersticas:

Um prefixo que indica de qual parte da API o comando pertence. Alguns valores possveis
so gl (funes principais), glu (biblioteca utilitria), wgl (funes especficas para Windows),
glx (funes especficas para Unix/X11) e agl (funes especficas para Mac OS).
O nome principal do comando. O exemplo da figura representa um comando para se

alterar a cor atual.
O nmero de argumentos aceitos pela funo. A funo do exemplo aceita 3 argumentos.
O tipo dos argumentos. No exemplo, o tipo dos argumentos ponto flutuante. Dessa
forma, a funo aceita 3 nmeros de ponto flutuante.
Como um dos objetivos do OpenGL ser independente de plataforma, so definidos vrios

tipos de dados, que so descritos na tabela 1.
Sufixo
Tipo de dado
Tipo definido no OpenGL
Tipo correspondente
na linguagem C
inteiro 8 bits
GLbyte
signed char
inteiro 16 bits
GLshort
short
inteiro 32 bits
GLint, GLsizei
int, long
ponto flutuante 32 bits
GLfloat, GLclampf
float
ponto flutuante 64 bits
GLdouble, GLclampd
double
ub
inteiro 8 bits sem sinal
GLubyte, GLboolean
unsigned char
us
GLushort
unsigned short
ui
GLuint, GLenum, GLbitfield
unsigned int, unsigned

long
array, usado em conjunto com os outros
Tabela 2.1 Tipos de dados do OpenGL
Luis Valente
comum que existam diversas variaes de comandos, que diferem entre si pelo tipo e nmero
de argumentos aceitos. Exemplos:
glColor3f (1.0f, 1.0f, 1.0f);
GLfloat color [3];
glColor3fv (color);
3. Sistemas de janelas
Devido portabilidade do OpenGL, a API no possui funes para lidar com sistemas de
janelas, cujas caractersticas dependem do sistema operacional usado. Esse o primeiro problema a
ser enfrentado pelo desenvolvedor, j que para usar o OpenGL preciso abrir uma janela.
Eventualmente, a aplicao ter que interagir com o usurio, quando ser necessrio tratar eventos
relacionados com o teclado e o mouse.
O desenvolvedor possui duas opes:
Usar a API especfica do sistema operacional. Essa opo torna a aplicao dependente do
sistema operacional. Entretanto, possvel utilizar caractersticas avanadas (e/ou otimizadas)
relacionadas ao sistema sistemas. Obviamente, ser preciso aprender a utilizar a API do
sistema operacional escolhido.
Usar algum toolkit ou biblioteca que oferea uma abstrao para o sistema de janelas.
Existem vrios exemplos de ferramentas desse tipo disponveis na internet. Muitas delas esto
disponveis para vrios sistemas operacionais e possuem o cdigo aberto. Suas APIs
geralmente so bem mais fceis de aprender (e menos complexas) do que as APIs de sistemas
operacionais especficos. Entretanto, por tentar oferecer caractersticas que sejam comuns a
vrios sistemas operacionais, podem ter algumas limitaes em termos de funcionalidades.
A opo a se tomar depende dos objetivos da aplicao.

Como o objetivo deste trabalho ensinar OpenGL somente, a segunda opo foi escolhida aqui.
O toolkit usado neste trabalho o freeglut7.
O freeglut uma biblioteca de cdigo aberto que est disponvel em diversas plataformas. Ela
originria do GLUT (OpenGL utility toolkit), que era o toolkit padro para demonstrar conceitos
sobre OpenGL. Dessa forma, possvel encontrar na internet vrios programas com exemplos de
utilizao de OpenGL escritos com o GLUT. Entretanto, o GLUT no mais desenvolvido (sua
ltima verso de 1998).
3.1. Instalao do freeglut

Esta seo assume que o compilador utilizado o Visual C++. Inicialmente, preciso ir no site
(http://freeglut.sourceforge.net/) do freeglut e baixar o cdigo fonte.
7 http://freeglut.sourceforge.net/
5
Luis Valente
3.1.1. Compilao
A seguir, preciso compilar o cdigo fonte para gerar as DLLs e arquivos .lib. Para isso,
descompacte o arquivo para um diretrio qualquer (ex: c:\freeglut). Depois, basta abrir o arquivo do
workspace (freeglut.dsw). Esse arquivo de projeto foi construdo para ser usado com o Visual C++
6, mas pode ser utilizado pelo Visual C++ .NET sem problemas.
Nesse workspace, constam dois projetos: o freeglut_static e o freeglut (que est selecionado por
padro). O primeiro usada para se construir uma biblioteca esttica e o outro para se construir a
DLL. Neste trabalho, ser usada a verso em DLL.
Para compilar o projeto, preciso acessar o menu Build e depois Build freeglut.dll, caso o
compilador seja o Visual C++ 6. Se for o Visual C++ .NET, os menus so Build e depois Build
freeglut.
Essas instrues geram a verso debug da DLL. Caso se queira gerar a verso release
(recomendado), basta acessar os menus Build, Set active configuration e escolher freeglut
Win32 Release, no Visual C++ 6. No Visual C++ .NET, o caminho Build, Configuration
Manager ... e escolher Release em Active Solution Configuraration. A seguir preciso
construir a DLL como explicado anteriormente.
3.1.2. Configurao
Aps a construo da DLL, preciso configurar o Visual C++ para que seja possvel usar o
freeglut. Isso pode ser feito com os passos descritos aqui (supondo que o diretrio do freeglut seja
c:\freeglut).
3.1.2.1. Visual C++ 6

Acrescentar o diretrio c:\freeglut\include no Visual C++. Seguir pelos menus Tools,
Options e escolher a aba Directories. Em Show directories for, escolher include files.
Criar uma nova entrada e acrescentar o nome do diretrio.
Copiar a .lib gerada para um diretrio c:\freeglut\lib (esse passo no estritamente

necessrio, mas conveniente).
Acrescentar o diretrio onde est o freeglut.lib (ex: c:\freeglut\lib) no Visual C++.

Seguir pelos menus Tools, Options e escolher a aba Directories. Em Show directories
for, escolher library files. Criar uma nova entrada e acrescentar c:\freeglut\lib (ou outro
diretrio onde esteja o arquivo).
3.1.2.2. Visual C++ .NET

Acrescentar o diretrio c:\freeglut\include no Visual C++. Seguir pelos menus Tools,
Options e escolher Projects no painel da esquerda. A seguir, escolher VC++ Directories
e em Show directories for, escolher Include files. Criar uma nova entrada e acrescentar o
nome do diretrio.
Copiar a .lib gerada para um diretrio c:\freeglut\lib (esse passo no estritamente

necessrio, mas conveniente).
Acrescentar o diretrio onde est o freeglut.lib (ex: c:\freeglut\lib) no Visual C++.

Seguir pelos menus Tools, Options e escolher Projects no painel da esquerda. A seguir,
Luis Valente
escolher VC++ Directories e em Show directories for, escolher library files. Criar uma
nova entrada e acrescentar c:\freeglut\lib (ou outro diretrio onde esteja o arquivo).
3.1.3. Outros compiladores

Para usar o freeglut com outros compiladores, ser necessrio compilar o cdigo e gerar os
arquivos de ligao com o compilador em questo. O cdigo fonte do freeglut j vem com makefiles
que podem ser usados para compilar o cdigo com o GCC.
Existem verses pr-compiladas do freeglut para o GCC do Linux e Windows (MinGW). Essas
verses podem ser obtidas em http://jumpgate.homelinux.net/random/freeglut-fedora/ (pacote RPM
para Linux) e http://www.nigels.com/glt/devpak/ (Windows, pacote DevPak para o DevC++8).
3.2. Exemplo de uso

O exemplo demonstra um programa simples com freeglut e serve para testar a instalao. Aqui
est o exemplo:
#include <GL/freeglut.h>
void OnDisplay ()
{
glClearColor (0.0f, 0.0f, 0.25f, 1.0f);
glClear (GL_COLOR_BUFFER_BIT);
}
glFlush ();
int main (int argc, char * argv [])

{
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutCreateWindow (Exemplo 1);
glutDisplayFunc (OnDisplay);
glutMainLoop ();
}
return 0;
3.2.1. Arquivos de incluso

O freeglut possui um arquivo de incluso principal:
8 O DevC++ uma IDE (Integrated Development Environment) para o GCC do Windows. gratuita e est disponvel
em http://www.bloodshed.net/dev/devcpp.html
7
Luis Valente
Esse arquivo permite utilizar todas as funes do freeglut. Esse arquivo j inclui
automaticamente os arquivos principais do OpenGL (o gl.h e o glu.h). Dessa forma, no preciso
especific-los. No necessrio incluir o arquivo principal do Windows (windows.h).
3.2.2. Funo principal

A funo principal main o ponto de entrada do programa. Na primeira linha, tm-se:
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
Todas as funes do freeglut possuem o prefixo glut, seguindo a conveno adotada pelo
OpenGL. A funo da primeira linha especifica uma configurao para o OpenGL. Essa
configurao definida por uma combinao de vrias flags. A configurao do exemplo requisita
que seja usado um nico buffer para a janela e o modo de cores usado seja RGB. No modo
GLUT_SINGLE (single-buffered), todas as operaes de desenho so executadas diretamente na
janela da aplicao. Esse modo no adequado para animao, porque o usurio percebe quando a
imagem apagada e desenhada ao mesmo tempo. Esse problema conhecido como flicker. A
alternativa usar o modo double-buffered, que cria dois buffers. Nessa configurao, o contedo de
um dos buffers est visvel enquanto o outro permanece invisvel. Os comandos de desenho so
executados no buffer que est oculto, e no final da operao, o que est visvel torna-se invisve, e
vice-versa. Dessa forma, a animao resultante suave e sem flicker. A constante para esse modo
GLUT_DOUBLE.
A prxima linha da funo contm:
glutCreateWindow (Exemplo 1);
Essa funo responsvel por criar a janela. O argumento correponde ao texto que aparecer na
barra de ttulo da janela.
A prxima linha demonstra um conceito importante no freeglut:
glutDisplayFunc (OnDisplay);
Essa funo indica ao freeglut que a funo OnDisplay ser usada para desenhar na janela.
Essa funo um exemplo das funes callback do freeglut. Uma funo callback uma funo
definida pelo usurio e registrada no freeglut, para ser executada na ocorrncia de algum evento
especfico. Nesse exemplo, OnDisplay ser executada toda vez que for necessrio redesenhar a
janela.
Existem diversos tipos de eventos que podem ser tratatos atravs de funes callback. Para cada
tipo de evento que pode ser tratado, existe uma funo especfica responsvel por registrar uma
funo callback.
A seguir, tm-se a seguinte linha de cdigo:
glutMainLoop ();
Esse comando requisita que o freeglut inicie o lao principal da aplicao. Nesse lao, ocorre o
processamento dos eventos da aplicao (que podem ser tratados atravs de callbacks). O lao
principal da aplicao executado at que seja requisitado o trmino do programa.
Luis Valente
3.2.3. Comandos do OpenGL

A funo OnDisplay possui vrios comandos do OpenGL que sero analisados a seguir. Na
primeira linha, tm-se:
Esse comando estabelece a cor de fundo da janela. No exemplo, a cor de fundo ser uma
variao de azul. As cores em OpenGL (como ser explicado em outras sees) so especificadas no
formato RGBA. Nas funes que aceitam argumentos de ponto flutuante, o valor de cada
componente varia de 0.0 (ausncia) a 1.0 (intensidade mxima).
Aps definir a cor de fundo, a tela preenchida com a cor de fundo (ou seja, limpa) com o
seguinte comando:
glClear (GL_COLOR_BUFFER_BIT);
O argumento da funo indica qual o tipo de buffer que ser afetado. Em OpenGL, um buffer
uma rea de memria com algumas propriedades especiais. A constante
GL_COLOR_BUFFER_BIT corresponde area de memria que contm os pixels da janela (ou seja,
a tela). Existem diversos tipos de buffers em OpenGL.
A ltima linha da funo OnDisplay listada a seguir:
glFlush ();
Esse comando requisita ao OpenGL que execute todos os comandos pendentes. comum que o
OpenGL agrupe vrios comandos (internamente, sem conhecimento do usurio) para que sejam
executados de uma nica vez. O objetivo disso melhorar o desempenho da aplicao.
4. Primitivas
Uma primitiva um objeto simples que pode ser usado para a criao de outros objetos
complexos. As primitivas disponveis no OpenGL esto resumidas na figura 4.1.
A especificao de primtivas no OpenGL segue um padro, demonstrado no seguinte trecho de
cdigo:
glBegin (nome da primitiva)
...
// comandos que especificam os componentes da primitiva
glEnd ();
O nome da primitiva uma constante que indica qual o tipo de primitiva usado. Essas
constantes esto presentes na figura 4.1.
Para se especificar os vrtices da primitiva, o seguinte comando usado:
glVertex* ()
O * usado aqui para indicar que existem diversas variaes do comando, por exemplo:
glVertex3f
glVertex3i
glVertex2d
glVertex4f
Luis Valente
(10.0f, 40.0f, 0.0f);

(5, 5, 5);
(20.0, 10.0);
(0.0f, 30.0f, 10.0f, 1.0f);
//
//
//
//
x,
x,
x,
x,
y,
y,
y,
y,
z,
z,
0,
z,
1
1
1
w
Figura 4.1 Primitivas do OpenGL (NeDa97)
4.1. Pontos
Para especificar pontos simples, necessrio usar a constante GL_POINTS.
glBegin (GL_POINTS);
glVertex3f (0.0f, 0.0f, 0.0f);
glVertex3f (10.0f, 20.0f, -3.0f);
glVertex3f (4.0f, -10.0f, 1.0f);
glEnd ();
O exemplo desenha trs pontos na janela. Por padro, o OpenGL desenha os pontos com
tamanho igual a 1 pixel. Entretanto, possvel desenhar pontos maiores. Para isso, preciso usar o
seguinte comando:
glPointSize (GLfloat tamanho);
10
Luis Valente
O maior valor possvel depende do hardware onde o programa ser executado. O nico valor
garantido a existir 1.0 (que corresponde a um pixel). Para consultar a faixa de valores possveis,
basta usar o seguinte trecho de cdigo:
GLfloat faixa [2];
glGetFloatv (GL_POINT_SIZE_RANGE, faixa);
GLfloat min = faixa [0];
GLfloat max = faixa [1];
A faixa de valores possveis para o tamanho dos pontos apenas uma das propriedades do
OpenGL que podem ser consultadas. Existem diversas outras, que podem ser obtidas usando
funes como glGetFloatv , glGetIntegerv, glGetDoublev e glGetBooleanv.
Outra propriedade interessante que pode ser alterada a suavizao no desenho dos pontos
(anti-aliasing). O comando para especific-la :
glEnable (GL_POINT_SMOOTH);
O comando glEnable responvel por habilitar alguma propriedade do OpenGL (ou seja,
ligar o estado). O comando correspondente, para desligar, glDisable. Dessa forma, para
desligar a suavizao no desenho dos pontos, basta usar este comando:
glDisable (GL_POINT_SMOOTH);
4.2. Linhas
Existem trs primitivas relacionadas
GL_LINE_STRIP e GL_LINE_LOOP.
a linhas em OpenGL que so
GL_LINE,
A primitiva GL_LINE corresponde a linhas simples:

glBegin (GL_LINE)
glVertex3f (10.0f, 10.0f, 5.0f);
glVertex3f (5.0f, -20.0f, 0.0f);
// descartado
glEnd ();
Quando essa primitiva usada, cada par de vrtices usado para desenhar uma linha. Caso
exista um nmero mpar de vrtices, o ltimo vrtice descartado.
Na primitiva GL_LINE_STRIP, os vrtices especificados so conectados em sequncia,
conforme so especificados:
glBegin (GL_LINE_STRIP)
glVertex3f (10.0f, 10.0f, 5.0f);
glVertex3f (5.0f, -20.0f, 0.0f);
glEnd ();
11
Luis Valente
Nesse exemplo, existiro dois segmentos de reta.

A primitiva GL_LINE_LOOP semelhante primitiva GL_LINE_STRIP, s que o ltimo
vrtice especificado conectado ao primeiro, formando um ciclo.
Por padro, as linhas desenhadas possuem a espessura igual a 1 pixel. Essa propriedade pode ser
alterada com o seguinte comando:
glLineWidth (GLfloat valor);
O nico valor garantido a existir 1.0, para consultar a faixa de valores permitida, o
procedimento semelhante quele usado para consultar a faixa de valores para os pontos:
GLfloat faixa [2];
glGetFloatv (GL_LINE_WIDTH_RANGE, faixa);
GLfloat min = faixa [0];
GLfloat max = faixa [1];
Tambm possvel desenhar as linhas com anti-aliasing, usando o comando:
glEnable (GL_LINE_SMOOTH);
4.3. Polgonos
O OpenGL permite usar trs tipos de polgonos: tringulos, quadrilteros e polgonos genricos.
Comum a todos eles, existe uma propriedade importante: a ordenao dos vrtices (a ordem em que
so especificados) deve ser consistente. As ordenaes possveis so ilustradas na figura 4.2.
Figura 4.2 Ordenaes possveis. (a) Sentido horrio. (b) Sentido anti-horrio.
Essa propriedade importante porque a ordenao dos vrtices define o lado do polgono que
est voltado para a frente e o lado do polgono que est voltado para trs. O padro usado pelo
OpenGL (e neste trabalho) que as faces voltadas para frente so especificadas em sentido antihorrio. Esse padro pode ser alterado com o seguinte comando:
glFrontFace (ordem);
12
Luis Valente
A ordem pode ser GL_CW (sentido horrio) ou GL_CCW (sentido anti-horrio).

Para entender porque a importncia dessa especificao, considere o seguinte exemplo: Imagine
que em um programa, o usurio visualize um cubo. O cubo formado por seis polgonos, mas na
verdade existem doze faces: seis que esto voltadas para frente e seis que esto voltadas para trs
(porque cada polgono possui duas faces). O OpenGL, por padro, processa as doze faces.
O processo de eliminao das faces que no podem ser vistas pelo usurio (as que esto no
interior do cubo, supondo que o usurio esteja for a dele) conhecido como backface culling. Para
habilitar o backface culling, necessrio usar esse comando:
glEnable (GL_CULL_FACE);
Os polgonos podem ser desenhados de diversas maneiras: com preenchimento de cor (padro),
em wireframe ou s com os vrtices.
Para alterar o modo de renderizao dos polgonos, usa-se o seguinte comando:
glPolygonMode (tipo de face, modo);
Os tipos de face aceitos so: GL_FRONT (afeta as faces da frente), GL_BACK (afeta as faces de
trs) e GL_FRONT_AND_BACK (afeta ambas). As constantes para os modos de renderizao so
GL_FILL (slido), GL_LINE (wireframe) e GL_POINT (somente vrtices). Dessa forma, para
desenhar as faces da frente dos polgonos em modo wireframe, basta usar este comando:
glPolygonMode (GL_FRONT, GL_LINE);
importante observar que o modo especificado afeta apenas o tipo de face desejado. Por
exemplo, caso se queira desenhar as faces da frente em modo slido e as de trs como wireframe,
estes comandos seriam usados (para que ambas sejam visualizadas, o backface culling teria que
estar desligado):
glPolygonMode (GL_FRONT, GL_FILL);
glPolygonMode (GL_BACK, GL_LINE);
4.3.1. Tringulos
Os triangulos so o tipo de primitiva mais usado em OpenGL (e em grficos 3D, em geral). No
OpenGL, existem trs variaes sobre o tema: GL_TRIANGLES, GL_TRIANGLE_STRIP e
GL_TRIANGLE_FAN.
A primitiva GL_TRIANGLE permite desenhar tringulos simples:
glBegin (GL_TRIANGLES)
glVertex2f (10.0f, 10.0f);
glVertex3f (20.0f, -5.0f);
glVertex3f (-20.0f, -5.0f);
glVertex3f (100.0f, -8.0f);
// descartado
// descartado
glEnd ();
13
Luis Valente
Quando essa primitiva usada, o OpenGL usada cada trinca de vrtices para desenhar um
tringulo. Caso exista uma trinca incompleta, esta descartada.
A primitiva GL_TRIANGLE_STRIP usada para se desenhar uma tira de tringulos
(tringulos conectados sequencialmente). Esse esquema pode ser visualizado na figura 4.3.
Figura 4.3 Sequncia de especificao de vrtices para GL_TRIANGLE_STRIP
Os trs primeiros vrtices so usados para formar o primeiro tringulo. A seguir, cada vrtice
subsequente conectado aos dois vrtices anteriores. Na figura 4.3, a ordenao dos vrtices segue
o sentido anti-horrio.
A primitiva GL_TRIANGLE_FAN usada para se conectar vrios tringulos em torno de um
ponto central, tal como um leque (fan):
glBegin (GL_TRIANGLE_FAN);
glVertex3f
glVertex3f
glVertex3f
glVertex3f
(10.0f, -1.0f, 0.0f);

(10.0f, 9.0f, 0.0f);
( 0.0f, 12.0f, 0.0f);
(-10.0f, 8.0f, 0.0f);
glEnd ();
O primeiro vrtice especificado na primitiva o ponto central do leque. Os dois vrtices
seguintes formam o primeiro tringulo. A partir de ento, preciso somente especificar um novo
vrtice para formar um novo tringulo (o tringulo ser construdo usando o novo vrtice e dois
vrtices especificados antes deste).
A figura 4.4. ilustra um leque formado por essa primitiva.
14
Luis Valente
Figura 4.4 Malha gerada por GL_TRIANGLE_FAN
4.3.2. Quadrilteros
As primitivas para quadrilteros em OpenGL so duas: GL_QUADS e GL_QUAD_STRIP.
O uso de GL_QUADS possibilita que sejam gerados quadrilteros simples. O OpenGL utiliza
quatro vrtices de cada vez para formar um quadriltero, como neste exemplo:
glBegin (GL_QUADS);
glVertex3f
glVertex3f
glVertex3f
glVertex3f
(-10.0f, -10.0f, 0.0f);

(10.0f, -10.0f, 0.0f);
(10.0f, 10.0f, 0.0f);
(-10.0f, 10.0f, 0.0f);
glVertex3f (-30.0f, -10.0f, 0.0f);

glVertex3f (30.0f, -10.0f, 0.0f);
// descartado
// descartado
glEnd ();
Figura 4.5 GL_QUADS
Caso no existam vrtices suficientes para formar um quadriltero, eles so descartados.
15
Luis Valente
A primitiva GL_QUAD_STRIP serve para formar tiras de quadrilteros conectados. Seu modo
de uso quase idntico ao de GL_TRIANGLE_STRIP. Em GL_QUAD_STRIP preciso
especificar quatro vrtices iniciais (para formar o primeiro quadrado) e mais dois vrtices de cada
vez para formar os outros quadrados. O uso dessa primitiva ilustrado na figura 4.6.
Figura 4.6 Aplicao de GL_QUAD_STRIP
4.3.3. Polgonos genricos

A construo de polgonos genricos pode ser feita usando a primitiva GL_POLYGON. No h
limites para o nmero de vrtices, mas existem duas regras para o uso de GL_POLYGON.
A primeira delas que o polgono a ser gerado deve pertencer a um nico plano (ou seja, todos
os vrtices devem estar no mesmo plano). A segunda regra que os polgonos devem ser convexos.
5. Cores e sombreamento
Cores em OpenGL so especificadas como RGBA. O comando para alterar as cores :
glColor* ()
Assim como vrios comandos, o glColor possui diversas variaes. Nas verses que aceitam
argumentos de ponto flutuante, os valores para cada componente variam entre 0.0 (ausncia) e 1.0
(intensidade mxima). Exemplos de uso:
glColor3f (1.0f, 1.0f, 1.0f);
glColor3f (0.0f, 0.0f, 0.0f);
glColor3f (1.0f, 0.0f, 0.0f);
// branco
// preto
// vermelho puro
Nas variaes que trabalham com nmeros inteiros sem sinal, os valores dos componentes
variam de 0 (ausncia) a 255 (intensidade mxima).
O OpenGL trabalha internamente com RGBA, de forma que se forem especificadas apenas trs
componntes, o quarto componente (alfa) ser 1.0 por padro.
glColor3f (0.0f, 1.0f, 0.0f);
// verde , alfa = 1.0
glColor4f (1.0f, 1.0f, 0.0f, 0.25f) // amarelo, alfa = 0.25
16
Luis Valente
Quando um comando de cor usado, a cor especificada ser usada para todas as primitivas at
que uma outra cor seja especificada. Segue um pequeno exemplo:
glColor3f (1.0f, 0.0f, 0.0f);
glBegin (GL_TRIANGLES);
glVertex3f ( 0.0f, 10.0f, 5.0f);
glVertex3f (-10.0f, 0.0f, 5.0f);
glVertex3f ( 10.0f, 0.0f, 5.0f);
glEnd ();
Nesse exemplo, o tringulo ser preenchido com a cor vermelha. Entretanto, as cores tambm
podem ser especificadas para cada vrtice, como no prximo exemplo:
glColor3f (1.0f, 0.0f, 0.0f);
glVertex3f (0.0f, 10.0f, 5.0f);
glColor3f (0.0f, 1.0f, 0.0f);
glVertex3f (-10.0f, 0.0f, 5.0f);
glColor3f (0.0f, 0.0f, 1.0f);
glVertex3f (10.0f, 0.0f, 5.0f);
glEnd ();
Para entender o que acontece nesse exemplo, preciso explicar o conceito de modo de
sombreamento.
O modo de sombreamento do OpenGL indica como ser feita a colorao das primitivas (e
preenchimento dos polgonos. Existem dois modos possveis: o sombreamento suave (Gouraud) e
sombreamento fixo. No sombreamento fixo, uma nica cor usada para preencher o polgono. No
caso de sombreamento suave, o OpenGL ir realizar uma interpolao entre as cores dos vrtices
para preencher os polgonos.
O resultado desses dois modos (aplicados no exemplo) pode ser conferido na figura 5.1.
17
Luis Valente
Figura 5.1 Modos de sombreamento. (a) Sombreamento fixo. (b) Sombreamento suave.
Para determinar o modo de sombreamento, o seguinte comando usado:

glShadeModel (modo);
O modo de sombreamento suave corresponde constante GL_SMOOTH e o modo de
sombreamento fixo corresponde constante (GL_FLAT). O modo padro usado pelo OpenGL
GL_SMOOTH.
6. Z-Buffer
O OpenGL usa o z-buffer para determinar a visibilidade dos objetos desenhados na cena. Esse
teste ocorre na etapa de rasterizao.
O z-buffer um dos vrios buffers que existem no OpenGL. Tipicamente, a implementao do
z-buffer feita no hardware da placa grfica. O z-buffer armazena valores que tm a ver com a
profundidade dos pixels da tela. Dessa forma, o z-buffer possui o mesmo tamanho da janela ou tela
da aplicao.
De maneira simplificada, o algoritmo de z-buffer usado da seguinte maneira: no incio da
aplicao (ou antes de imagem ser construda, por exemplo, no incio de um quadro de animao do
programa), o z-buffer preenchido (limpo) com um certo valor (um valor muito grande, por
exemplo). Quando um pixel precisa ser pintado na tela, o algoritmo consulta o valor correspondente
a esse pixel que est armazenado no z-buffer. Se o valor for menor (o que quer dizer que o novo
pixel estaria mais perto), o pixel pintado na tela e o valor de profundidade armazenado no zbuffer. Caso esse valor fosse maior do que aquele que l estivesse, o pixel no seria pintado. A
consequncia da aplicao desse algoritmo que a cena desenhada corretamente (em termos de
determinao de visibilidade).
18
Luis Valente
Para se usar o z-buffer no OpenGL, preciso requisitar sua criao. No freeglut, basta usar a
constante GLUT_DEPTH junto com as outras na hora da inicializao:
glutInitDisplayMode (GLUT_DOUBLE | GLUT_DEPTH | GLUT_RGB);
A seguir, preciso habilitar o uso do z-buffer no OpenGL (que est desligado por padro). Isso
pode ser feito com o seguinte comando:
glEnable (GL_DEPTH_TEST);
Caso se queira desligar o teste de z-buffer, basta usar o comando glDisable
(GL_DEPTH_TEST).
Durante o ciclo de vida da aplicao, o z-buffer dever ser zerado toda vez que se desejar criar
uma nova imagem. Isso normalmente feito no mesmo momento em que se limpa a tela. Para
realizar essa operao conjunta, basta usar este comando:
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
O funcionamento do z-buffer e suas configuraes podem ser alteradas com grande
flexibilidade, mas esse detalhamento est fora do escopo deste trabalho. Para maiores informaes,
por favor, consulte a documentao do OpenGL.
7. Transformaes e projees
O OpenGL usa diversos tipos de transformaes geomtricas na especificao da cena. Essas
transformaes podem ser dos seguites tipos: Viewport, Modelagem, Projeo e Cmera.
O sistema de coordenadas tridimensional usado no OpenGL o sistema de coordenadas da mo
direita, que pode ser visualizado na figura 7.1.
Figura 7.1 Sistema de coordenadas da mo direita
7.1. Viewport
A transformao de viewport indica a rea da janela onde sero realizadas as operaes de
desenho. A figura 7.2 ilustra um exemplo de viewport.
19
Luis Valente
Figura 7.2 Uma viewport (WrSw99)
A origem da viewport o canto inferior esquerdo. Para se determinar a viewport, o seguinte

comando usado:
glViewport (origem_x, origem_y, largura, altura);
Dessa forma, para especificar a viewport da figura 7.2, basta submeter este comando:
glViewport (0, 0, 150, 100);
7.2. Matrizes
O OpenGL usa matrizes para implementar todas as transformaes existentes. Normalmente, o
usurio no precisa lidar com as matrizes diretamente (embora isso seja possvel se for desejado),
pois existem vrios comandos para manipul-las.
As transformaes de modelagem e projeo so independentes entre si. Internamente, o
OpenGL mantm uma matriz para cada um desses tipos.
Em um dado momento, s permitido usar um dos tipos de matriz. O tipo de matriz usado no
momento determinado pelo seguinte comando:
glMatrixMode (nome da matriz);
O nome da matriz de modelagem GL_MODELVIEW e o da matriz de projeo
GL_PROJECTION. Segue um exemplo:
glMatrixMode (GL_PROJECTION);
// a partir deste momento, a matriz afetada a de
// projeo
...
// comandos que afetam a matriz de projeo
glMatrixMode (GL_MODELVIEW);
20
Luis Valente
// a partir deste momento, a matriz afetada a de

// modelagem
...
// comandos que afetam a matriz de modelagem
Existem algumas operaes pr-definidas que podem ser aplicadas em matrizes. Esses
comandos afetam o tipo de matriz selecionado no momento. As operaes principais so translao,
rotao, escala e carregar a matriz identidade.
A matriz identidade serve para reiniciar o sistema de coordenadas, ou seja, a posio
selecionada ser a origem, no existiro rotaes e a escala ser igual a 1 em todos os eixos. O
comando para carregar a matriz identidade :
glLoadIdentity ();
A operao de translao desloca o sistema de coordenadas pelo nmero de unidades
especificadas. O comando correspondente :
glTranslate* (x, y, z);
// * = f ou d
Esse comando acumulativo (assim como todos os outros), como descrito neste exemplo:
glLoadIdentity ();
// posio = 0,0,0
glTranslatef (10.0f, 0.0f, 0.0f);

glTranslatef (0.0f, 5.0f, -1.0f);
// posio = 10,0,0
// posio = 10,5,-1
A operao de rotao pode ser expressa com este comando:

glRotate* (angulo, x, y, z);
// * = f ou d
O ngulo expresso em graus, e os parmetros x, y, e z representam o eixo de rotao. Dessa

forma, para realizar uma rotao de 30 em torno do eixo Z, este trecho de cdigo usado:
glRotatef (30, 0.0f, 0.0f, 1.0f);
A operao de escala feita com o seguinte comando:
glScale* (escala_x, escala_y, escala_z);
// * = f ou d
Os parmetros representam os fatores de escala em cada eixo. O valor 1.0 no afeta a escala.
7.3. Modelagem
Como exemplo, suponha que se queria desenhar um tringulo na posio (10, 10, 0). Isso pode
ser feito com o seguite trecho de cdigo:
glLoadIdentity ();
glTranslatef (10, 10, 0);
21
Luis Valente

glVertex2f (-10.0f, 0.0f);
glEnd ();
Agora, suponha que se queira desenha o mesmo tringulo com uma rotao de -20 em torno do
eixo Z:
glLoadIdentity ();
glRotatef (-20.0f, 0.0f, 0.0f, 1.0f);
glVertex2f (-10.0f, 0.0f);
glEnd ();
7.4. Projeo
O OpenGL possui funes para configurar dois tipos de projees: projees ortogrficas e
projees em perspectiva.
7.4.1. Projeo ortogrfica

A projeo ortogrfica pode ser especificada com o seguinte comando:
void glOrtho (GLdouble
GLdouble
GLdouble
GLdouble
GLdouble
GLdouble
left,
right,
bottom,
top,
near,
far
);
Os parmetros correspondem aos valores dos planos que formam o volume de viso da projeo
ortogrfica. Esse volume de viso pode ser visualizado na figura 7.3.
22
Luis Valente
Figura 7.3 Volume de viso da projeo ortogrfica (WrSw99)
O volume de viso da projeo ortogrfica um paraleleppedo (ou um cubo), de forma que

todos os objetos (primitivas, etc) que estiverem for a desse volume no aparecero na imagem final.
Por exemplo, suponha que se queria construir uma projeo que possua um comprimento de 20
unidades em todos os eixos, e que a origem esteja no centro da janela9. Isso pode ser feito com o
seguinte trecho de cdigo:
glLoadIdentity ();
glOrtho (-10.0, 10.0, -10.0, 10.0, -10.0, 10.0);
glLoadIdentity ();
No caso dos parmetros near e far, valores negativos indicam que o plano est atrs do
observador (o near negativo porque o exemplo tem como objetivo posicionar a origem no centro
do volume de viso).
O exemplo tambm demonstra uma conveno que adotada em programas que usam OpenGL.
A determinao da projeo uma tarefa que realizada poucas vezes. Na maioria dos casos, os
comandos de matrizes afetam a matriz de modelagem. Dessa forma, a conveno assumir sempre
que a matriz atual a de modelagem. Caso se queira alterar algum outro tipo de matriz, altera-se o
tipo de matriz e realiza-se as operaes desejadas. No final das operaes, restaura-se o determinase que o tipo de matriz a de modelagem. O objetivo dessa conveno evitar erros que podem
ocorrer quando se altera a matriz errada (por exemplo, alterar a matriz de projeo acidentalmente).
9 Na verdade, que esteja no centro da viewport. Nesse exemplo, considera-se que a viewport ocupe toda a janela (o
que bastante comum).
23
Luis Valente
Em relao a projees ortogrficas, existe ainda um outro tipo de problema a se tratar. No

exemplo, foi criada uma projeo quadrada. Entretanto, comum que a janela da aplicao seja
retangular. Dessa forma, tem-se o seguinte problema: Suponha que a projeo foi criada como no
exemplo. Os eixos X, Y e Z podem representar valores de -20 a 20. Suponha que a janela da
aplicao possui tamanho igual a 300x100. A proporo da janela (largura/altura) diferente da
proporo da projeo (que 1). Sendo assim, as imagens desenhadas na janela sero
desproporcionais, conforme pode ser visualizado na figura 7.4.
Figura 7.4 Viewport e projeo desproporcional
Para corrigir essa distoro, necessrio levar em considerao a razo de aspecto da janela ao
se calcular a projeo. Isso pode ser feito da seguinte forma:
// largura e altura da viewport
largura = ...
altura = ...
glLoadIdentity ();
GLdouble proporcao = largura/altura;
if (proporcao >= 1.0)
glOrtho (left * proporcao, right * proporcao, bottom, top,
near, far);
else
glOrtho (left, right, bottom / proporcao, top / proporcao,
near, far);
glLoadIdentity ();
24
Luis Valente
7.4.2. Projeo em perspectiva

Para definir uma projeo em perspectiva, necessrio especificar os planos que formam o
frustum (que o volume de viso dessa projeo). O frustum um volume tridimensional em forma
de uma pirmide imaginria limitada pelos planos delimitadores near e far, que correspondem a
distncias relativas ao observador, na direo de sua linha de viso. O frustum ilustrado na figura
7.5.
Figura 7.5 Frustum (WrSw99)
Para especificar o frustum, existe o seguinte comando do OpenGL:

glFrustum (left, right, bottom, top, near, far);
Entretanto, especificar os planos do frustum no conveniente na maioria das vezes. Por essa
razo, a GLU oferece uma funo para especificar o frustum de outra forma:
gluPerspective (campo de viso, proporo, near, far);
A figura 7.6 ilustra os parmetros de gluPerspective:
Figura 7.6 Parmetros de gluPerspective (WrSw99)
O primeiro parmetro corresponde ao campo de viso vertical (ngulo em graus). O segundo

parmetro corresponde proporo entre a altura e largura da viewport. Os dois ltimos parmetros
correspondem aos planos delimitadores near e far, como na outra funo.
25
Luis Valente
7.5. Cmera
A separao do conceito de transformao de cmera, em OpenGL, apenas uma notao de
convenincia. No existe uma matriz separada para transformao de cmera, na verdade, essa
transformao afeta a matriz de modelagem.
A transformao de cmera serve para posicionar e orientar o ponto de vista na cena. O
OpenGL oferece uma funo para especificar essa transformao:
gluLookAt (pos_x , pos_y , pos_z,
alvo_x, alvo_y, alvo_z,
up_x , up_y , up_z);
Os primeiros trs parmetros correspondem posio do observador (ou da cmera) na cena. Os
trs seguintes correspondem ao ponto para onde a cmera est apontada. Os trs ltimos
especificam um vetor que indica qual a direo que pode ser considerada para cima. Por
exemplo, se o usurio est posicionado em (0, 0, 0) e olhando para (0, 0, -20), a direo para cima
corresponde a (0, 1, 0).
A transformao de cmera deve ser a primeira a ser especificada na renderizao da cena:
// supondo que o modo de matriz atual seja GL_MODELVIEW
void desenharCena ()
{
glLoadIdentity ();
glLookAt (0.0, 0.0, 0.0,
0.0, 0.0, -20.0,
0.0, 1.0, 0.0);
// comandos para posicionar, rotacionar, desenhar, etc

...
Se nenhuma transformao de cmera for especificada, o usurio estar posicionado em (0, 0, 0)

e olhando para (0, 0, -1) e a direo considerada para cima o eixo Y.
A transformao de cmera pode ser implementada usando os comandos de manipulao de
matrizes (que devem ser usados para que se possa construir outros tipos de transformaes).
Por exemplo, suponha que a configurao da cmera seja a padro. Se for necessrio mover a
cmera 20 unidades para a esquerda, pode-se executar essa tarefa com este trecho de cdigo:
glLoadIdentity ();
glTranslatef (-20.0f, 0.0f, 0.0f);
interessante notar que esse exemplo equivalente a este outro:
glLoadIdentity ();
26
Luis Valente
glLookAt (-20.0, 0.0, 0.0,

0.0, 0.0, -1.0,
0.0, 1.0, 0.0);
7.6. Hierarquia de transformaes

Suponha que seja necessrio desenhar duas esferas em uma cena, como na figura 7.7.
Figura 7.7 Cena com duas esferas (WrSw99)
Como sabe-se que as operaes de transformao de matrizes so cumulativas, uma primeira

tentativa de se resolver esse caso poderia ser feita da seguinte forma:
glLoadIdentity ();
desenharEsfera ();
glLoadIdentity ();
Entretanto, esse exemplo inadequado por vrios motivos. Primeiramente, quando existem
muitos objetos na cena, essa abordagem torna-se confusa e ineficiente (vrias chamadas a
glLoadIdentity). Outro problema quando alguns objetos dependem de outros. Por exemplo,
se uma das esferas girasse em torno da outra, seria bem mais complicado implementar esse modelo
se a cada transformao fosse necessrio carregar a matriz identidade.
Para resolver esses problemas, o OpenGL fornece pilhas de matrizes. As pilhas podem ser
usadas para salvar o valor de alguma matriz, realizar as operaes desejadas e depois restaurar o
valor da matriz anterior.
O OpenGL mantm uma pilha para cada tipo de matriz existente. Assim como os comandos de
manipulao de matrizes, os comandos de manipulao da pilha afetam apenas o tipo de matriz
atual. Esses comandos so glPushMatrix e glPopMatrix.
Aqui est um exemplo de utilizao desses comandos:
glLoadIdentity ();
27
Luis Valente
// salva a matriz atual (identidade)

glPushMatrix ();
desenharEsfera ();
glPopMatrix ();
/* a matriz atual volta a ser a identidade */
glPushMatrix ();
desenharEsfera ();
glPopMatrix ();
7.7. Outras operaes (avanado)

Alm das operaes implementadas pelo OpenGL, possvel realizar operaes personalizadas.
O OpenGL possui dois comandos para definir essas operaes:
glLoadMatrix* (m);
// * = f ou d
glMultMatrix* (m);
// * = f ou d
A funo glLoadMatrix* permite substituir a matriz atual pela matriz especificada como
parmetro. A funo glMultMatrix* permite multiplicar a matriz atual por uma matriz
qualquer.
A definio da matriz m deve ser feita usando um array simples:
GLfloat matriz [16];
O OpenGL trabalha internamente vetores coluna, por isso a matriz m tratada da seguinte
forma:
Figura 7.8 Armazenamento interno da matriz
28
Luis Valente
O formato das matrizes usadas em OpenGL diferente do formato usual de matrizes na

linguagem C:
float matriz [4][4];
// C convencional
O problema que na linguagem C, as matrizes so armazenadas em memria por ordem de

linha. Dessa forma, os quatro primeiros elementos correspondem primeira linha, os quatro
seguintes segunda linha, e assim sucessivamente. Assim, o elemento m (i, j) da matriz declarada
em C representa o elemento a (j, i) da matriz do OpenGL.
Para ilustrar o uso dessas funes, o exemplo a seguir implementa a funcionalidade da funo
glTranslatef:
void translate (GLfloat x, GLfloat y, GLfloat z)
{
GLfloat * m = {1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
x
, y
, z
, 1.0f};
glMultMatrixf (m);
}
8. Composio de objetos
A maneira mais simples de se desenhar algum objeto seria especificar os seus vrtices em
alguma funo qualquer, como por exemplo:
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
desenharMeuObjeto ();
Existem vrias desvantagens em se usar essa abordagem. Por exemplo, se for necessrio realizar
clculos complexos para gerar a geometria do objeto, nesse exemplo esses clculos seriam
realizados vrias vezes (quando eles poderiam ser feitos uma vez s, como na inicializao do
programa).
Com o OpenGL, possvel agrupar comandos para serem executados em uma nica chamada,
com as diplay lists. Display lists so listas de comandos do OpenGL pr-processados.
No exemplo do clculo da geometria do objeto, ao se usar uma display list, somente o resultado
final do processo (como os vrtices) seria armazenado.
As display lists so referenciadas por um identificador, que um nmero simples. Entretanto,
preciso requisitar ao OpenGL que gere um identificador vlido. Isso pode ser feito da seguinte
forma:
GLuint minhaLista = glGenLists (1);
A varivel minhaLista contm o identificador da lista, e o argumento da funo glGenLists
indica quantas listas devero ser criadas. Caso sejam criadas vrias listas, elas podero ser acessadas
sequencialmente, a partir do identificador principal. Por exemplo, caso se queira criar cinco listas:
29
Luis Valente
GLuint listas = glGenLists (5);

As listas criadas podero ser acessadas usando listas, listas+1, listas+2, ...,
listas+4.
Aps a criao da lista, necessrio preench-la com comandos. Para fazer isso, usa-se:
glNewList (minhaLista, GL_COMPILE);
... // clculos, comandos do OpenGL
glEndList ();
A constante GL_COMPILE indica ao OpenGL que os comandos devem ser agrupados na lista.
Uma outra alternativa usar GL_COMPILE_AND_EXECUTE, que indica que os comandos devero
ser armazenados e executados.
Alguns comandos como glNewList e glEndList no so armazenados na lista (existem
outros, que esto descritos na documentao do OpenGL).
Depois que a lista foi definida, possvel executar os comandos armazenados a qualquer
momento, com o seguinte comando:
glCallList (minhaLista);
Ao final da aplicao, necessrio liberar os recursos alocados pela lista, com este comando:
glDeleteLists (minhaLista, 1);
O primeiro argumento refere-se ao identificador da lista, e o segundo quantidade de listas que
sero apagadas.
Uma observao importante em relao a display lists que as display lists so estticas, ou
seja, no possvel alterar os dados armazenados na lista depois que elas forem preenchidas.
Entretanto, possvel substituir o seu contedo:
glNewList (minhaLista, GL_COMPILE);
... // novos comandos
glEndList ();
9. Iluminao
Para usar iluminao em OpenGL, preciso seguir alguns passos:
Habilitar o uso de iluminao;
Especificar os vetores normais;
Configurar o material dos objetos;
Configurar as fontes de luz.
30
Luis Valente
O uso de iluminao est desabilitado por padro. Para habilitar a iluminao, necessrio usar
o seguinte comando:
glEnable (GL_LIGHTING);
A iluminao pode ser desligada a qualquer momento usando este comando:
glDisable (GL_LIGHTING);
9.1. Vetores normais

Os vetores normais so usados pelo OpenGL para calcular a incidncia de luz sobre uma
superfcie. O comando para especificar vetores normais :
glVertex3* ()
Esses vetores podem ser associados a superfcies inteiras ou a vrtices individuais. Para
especificar os vetores normais por vrtice, basta especific-los com os vrtices questo, como no
exemplo a seguir:
glNormal3f (0.0f, 1.0f, 0.0f);
glVertex3f (a, b, c);
glNormal3f (0.0f, 0.0f, 1.0f);
glVertex3f (d, e, f);
Por questes de otimizao, o OpenGL espera que os vetores normais fornecidos sejam
unitrios. possvel requisitar ao OpenGL que normalize os vetores conforme estes forem
submetidos, com o seguinte comando:
glEnable (GL_NORMALIZE);
Entretanto, isso representa um custo adicional que pode ser evitado.
Outra observao importante que os comandos glScale* afetam o comprimento dos
vetores normais, o que pode ocasionar erros no clculo de iluminao.
9.2. Materiais
Os materiais so propriedades de uma superfcie que definem sua aparncia. Essas propriedades
tm a ver com a componente da luz que eles so capazes de refletir.
Os tipos de material que podem ser especificados no OpenGL so: GL_AMBIENT,
GL_DIFFUSE, GL_SPECULAR, GL_EMISSION e GL_SHININESS.
O GL_AMBIENT, GL_DIFFUSE e GL_SPECULAR especificam a reflectncia de luz ambiente,
difusa e especular, respectivamente. O GL_EMISSION especifica a intensidade de luz emitida pelo
material,. O GL_SHININESS especifica um valor (specular exponent) que tem a ver com a
concentrao de brilho em uma superfcie. Quando maior esse valor, mais concentrado o brilho
especular (a rea ocupada por ele menor).
31
Luis Valente
A primeira alternativa para se especificar materiais usar a funo glMaterial*. Essa

funo recebe trs parmetros: qual o tipo de face a ser afetado (frente, trs ou ambas), qual a
propriedade a ser alterada e os valores da propriedade.
Como exemplo, tem-se o seguinte trecho de cdigo:
GLfloat cinza [] = {0.60, 0.60, 0.60, 1.0};
glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, cinza);
glVertex3f (0.0f, 10.0f, 30.0f);
glVertex3f (-50.0f, 0.0f, 30.0f);
glVertex3f (50.0f, 0.0f, 30.0f);
glEnd ();
O exemplo especifica que o material refletido pelo tringulo, sob luz ambiente e difusa uma
variao de cinza. importante notar que somente a face da frente ser afetada. Caso se queira
afetar ambas as faces, necessrio usar a constante GL_FRONT_AND_BACK.
Para configurar materiais de modo que possuam efeitos especulares, pode ser usado este trecho
de cdigo:
GLfloat cor [] = {1.0f , 1.0f, 1.0f, 1.0f};
glMaterialfv (GL_FRONT, GL_SPECULAR, cor);
glMaterialf (GL_FRONT, GL_SHININESS, 128.0f);
A varivel cor indica qual ser a cor refletida pela luz especular. No exemplo, cor indica que
todas as cores sero refletidas. O parmetro GL_SHININESS pode variar de 0 a 128.
Caso uma cena possua muitos materias diferentes, o uso de glMaterial* pode tornar-se
ineficiente. Por isso, existe uma outra alternativa para se especificar propriedades dos materiais.
A outra opo usar o chamado color tracking. Quando o color tracking est ativado, a
propriedade do escolhida determinada com o uso de glColor*.
Inicialmente, preciso habilitar o color tracking:
glEnable (GL_COLOR_MATERIAL);
A seguir, preciso configur-lo, com o seguinte comando:
void glColorMaterial (GLenum face, GLenum mode);
O parmetro face indica qual o tipo de face afetada (GL_FRONT, GL_BACK ou
GL_FRONT_AND_BACK). O parmetro mode indica qual a propriedade do material a ser usada, e
pode
ser
GL_EMISSION,
GL_AMBIENT,
GL_DIFFUSE,
GL_SPECULAR,
ou
GL_AMBIENT_AND_DIFFUSE (padro). Exemplo de uso:
32
Luis Valente
glEnable (GL_COLOR_MATERIAL);
glColorMaterial (GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glColor3f (1.0f, 0.0f, 0.0f);
glVertex3f (0.0f, 10.0f, 30.0f);
glVertex3f (-50.0f, 0.0f, 30.0f);
glVertex3f (50.0f, 0.0f, 30.0f);
glEnd ();
9.3. Fontes de luz

possvel especificar uma valor de luz ambiente global para a cena. Isso pode ser feito
alterando-se o modelo de iluminao usado pela aplicao, que demonstrado no seguinte trecho de
cdigo:
GLfloat luz_ambiente [] = {1.0f, 1.0f, 1.0f, 1.0f};
glLightModelfv (GL_LIGHT_MODEL_AMBIENT, luz_ambiente);
Por padro, o valor padro de luz ambiente para ess modelo {0.2, 0.2, 0.2, 1.0}. Existem
outros modelos que podem ser alterados.
A especificao do OpenGL prev um nmero mnimo de oito fontes de luz que podem ser
usadas em um programa. Entretanto, nem todas elas necessitam ser implementadas em hardware
(algumas implementaes podem ter apenas uma fonte de luz em hardware).
Existem trs tipos de fonte de luz no OpenGL: fontes de luz direcionais, fontes de luz pontuais
e fontes de luz refletoras (spot lights). A especificao do tipo de fonte de luz feita atravs da
configurao de seus parmetros (no existe uma diferenciao explcita entre esses tipos).
Aqui est um exemplo de configurao de fonte de luz:
GLfloat corAmbiente [] = {0.5f, 0.5f, 0.5f, 1.0f};
GLfloat corDifusa
[] = {1.0f, 1.0f, 1.0f, 1.0f};
GLfloat posicao [] = {0.0f, 0.0f, 50.0f, 1.0f};
glLightfv (GL_LIGHT0, GL_AMBIENT, corAmbiente);
glLightfv (GL_LIGHT0, GL_DIFFUSE, corDifusa);
glLightfv (GL_LIGHT0, GL_POSITION, posicao);
glEnable (GL_LIGHT0);
Todas as propriedades da fonte de luz so especificadas pela funo glLight*. Em linhas
gerais, esse comando recebe como parmetros uma contante que indica a fonte de luz a ser alterada
(GL_LIGHT0, GL_LIGHT1, ..., GL_LIGHT7), a propriedade a ser altera e valor dessa
propriedade.
33
Luis Valente
No exemplo, foram especificadas as componentes de cor difusa e ambiente da fonte de luz,

assim como sua posio. A diferena entre entre fontes de luz direcionais e pontuais determinada
pelo parmetro de posio. Se o quarto parmetro (w) for 1.0, significa que a fonte de luz pontual
(e est localizada naquela posio). Caso o valor seja 0.0, significa que a fonte de luz direcional
(ou seja, ela est localizada a uma distncia infinita ao longo do vetor especificado como posio).
Por ltimo, necessrio habilitar o uso da fonte de luz desejada.
O valor do componente especular da fonte de luz pode ser alterado com a propriedade
GL_SPECULAR:
GLfloat corEspecular [] = {1.0f , 1.0f, 1.0f, 1.0f};
glLightfv (GL_LIGHT0, GL_SPECULAR, corEspecular);
Para a criao de spot lights, existem algumas propriedades que podem ser alteradas, conforme
descrito neste exemplo:
GLfloat
spotDirection [] = {0.0f, 0.0f, -1.0f};
glLightfv (GL_LIGHT0, GL_SPOT_DIRECTION, spotDirection);

glLightf (GL_LIGHT0, GL_SPOT_CUTOFF, 60.0f);
glLightf (GL_LIGHT0, GL_SPOT_EXPONENT, 100.0f);
A principal propriedade a ser alterada o ngulo (em graus) que define o cone de luz, que
corresponde constante GL_SPOT_CUTOFF. Essa propriedade ilustrada na figura 9.1.
Figura 9.1 Propriedade GL_SPOT_CUTOFF (NeDa97)
Os valores possveis para essa propriedade variam de 0 a 90. Existe um valor especial, 180,
que pode ser usado para desabilitar essa propriedade (efetivamente desabilitando esse tipo de fonte
de luz). Esse valor o padro.
A propriedade GL_SPOT_DIRECTION indica qual a direo do feixe de luz. O valor da
propriedade expresso em coordenadas do objeto (ou seja, em relao fonte de luz).
A propriedade GL_SPOT_EXPONENT indica a intensidade de distribuio da luz. Os valores
aceitos variam de 0 a 128. Quanto maior o valor, mais concentrada a luz no centro do cone. O
valor padro 0, que resulta em uma distribuio uniforme da luz.
34
Luis Valente
10. Mapeamento de textura

O mapeamento de texturas em OpenGL feito com os seguintes passos:
Habilitar o uso de texturas;
Leitura da imagem em disco (ou gerao dos dados da textura atravs de algum
algoritmo);
Transferir os dados da textura para o OpenGL;
Selecionar a textura para uso e especificar as coordenadas de textura dos vrtices.
Esses passos sero explicados nas sees seguintes.
10.1. Habilitar o uso de texturas

O mapeamento de texturas, por padro, est desligado no OpenGL. O OpenGL permite o uso de
texturas de uma, duas ou trs dimenses. Neste trabalho, o enfoque ser dirigido ao uso de texturas
de duas dimenses.
Para habilitar o mapeamento de texturas de duas dimenses, necessrio usar o seguinte
comando:
glEnable (GL_TEXTURE_2D);
De forma anloga a de outras propriedades, o mapeamento de texturas pode ser desligado com o
comando correspondente glDisable.
10.2. Identificadores de texturas

Todas as texturas em OpenGL so referenciadas por um identificador (nmero). Os
identificadores podem ser requisitados ao OpenGL com o seguinte trecho de cdigo:
GLuint identificador;
glGenTextures (1, & id);
O primeiro argumento do comando glGenTextures indica a quantidade de identificadores a
serem criados enquanto o segundo parmetro indica onde esses identificadores sero armazenados.
Como possvel perceber, vrios identificadores podem ser gerados de uma s vez, como
exemplificado a seguir:
GLuint texturas [5];
glGenTextures (5, texturas);
Para que seja possvel usar a textura, necessrio informar ao OpenGL que a textura ser usada.
Para isso, necessrio usar este comando:
glBindTexture (GL_TEXTURE_2D, identificador);
A partir desse momento, todas as operaes envolvendo texturas fazem referncia e/ou afetam a
textura representada por identificador.
35
Luis Valente
Quando a textura no for mais necessria, ser preciso liberar os recursos que foram alocados.
Essa tarefa realizada como no exemplo a seguir:
glDeleteTextures (1, & identificador);
glDeleteTextures (5, texturas);
O comando glDeleteTextures recebe como parmetros a quantidade de texturas a terem
seus recursos devolvidos ao sistema e um local (uma varivel ou array) que contm os
identificadores das texturas.
10.3. Transferncia dos dados para o OpenGL

Para transferir os dados da textura para o OpenGL, necessrio usar este comando:
void glTexImage2D(GL_TEXTURE_2D,
GLint level,
GLint components,
GLsizei width,
GLsizei height,
GLint border,
GLenum format,
GLenum type,
const GLvoid *pixels
);
O parmetro level indica o nvel de detalhe da textura. O nvel de detalhe usado para se
especificar mipmaps. O nvel zero (0) corresponde imagem original.
O parmetro components indica o nmero de componentes de cor existentes na imagem. Os
valores permitidos so 1, 2, 3 ou 4.
Os parmetros width e height indicam a largura e a altura da imagem em pixels,
respectivamente. Uma observao importante que esses valores precisam ser potncia de 2.
O parmetro border indica se a textura possui uma borda. Os valores possveis so 0 ou 1.
O parmetro format indica qual o formato dos dados da imagem. Existem vrias constantes
para representar esses tipos, como GL_RGB, GL_RGBA e GL_LUMINANCE (esses valores esto
listados na documentao).
O parmetro type indica qual o tipo verdadeiro do array pixels. Por exemplo, se os dados
da imagem foram carregados em um array de GLubytes, o tipo ser GL_UNSIGNED_BYTE (os
outros valores esto listados na documentao.
O ltimo parmetro corresponde ao array que contm os dados da imagem.
Um exemplo simples de uso dessa funo descrito no trecho de cdigo a seguir:
/**
* Carregar uma imagem RGB de 64x64 do disco e transfer-la
* para o OpenGL
*/
unsigned int * buffer;
36
GLuint
...
Luis Valente
id;
// alocar buffer para imagem e carrega imagem do disco
// (isso ainda ser visto com mais detalhes)
// habilita o uso de texturas 2D

// gerar um identificador de textura
glGenTextures (1, & id);
// selecionar a textura para uso
glBindTexture (GL_TEXTURE_2D, id);
// transferir os dados para o OpenGL
glTexImage2D (GL_TEXTURE_2D,
0,
// nvel de detalhe
3,
// nmero de componentes de cor
64,
// largura
64,
// altura
0,
// borda
GL_RGB,
// formato
GL_UNSIGNED_BYTE // tipo de dados do array
buffer
// array contendo os
// dados da imagem
);
10.3.1. Mipmaps
A tcnica de mipmaps foi definida por Lance Williams no artigo Pyramidal Parametrics
(SIGGRAPH '83). A tcnica consiste em se criar vrias verses de uma mesma imagem, em
resolues diferentes, como ilustrado na figura 10.1.
37
Luis Valente
Figura 10.1 Exemplo de uma cadeia de mipmaps (NeDa97)
Esse processo realizado at que se chegue menor imagem possvel (com 1 pixel). As
mipmaps podem ser aplicadas para mapeamento de texturas em polgonos da seguinte forma: os
polgonos que esto distantes do observador usariam verses de menor resoluo das texturas,
enquanto os que esto prximos do observador utilizariam uma textura de maior resoluo.
Algumas vantagens desse mtodo so:
Melhoria do desempenho da aplicao, porque como as imagens so pr-fltradas,
possvel escolher uma imagem que possua tamanho prximo ao do polgono a ser mapeado,
reduzindo o custo do processamento em tempo real da interpolao. Adicionalmente, podem
ser aplicados filtros mais custosos (que produzam melhores resultados visuais) na etapa de
inicializao (gerao das mipmaps), o que talvez no poderia ser feito em tempo real.
Diminuio de artefatos visuais causados pelo aliasing.
Uma das desvantagens a quantidade de espao adicional para se armazenar as imagens.

O OpenGL possui uma funo para a gerao automtica de mipmaps, que est definida na
GLU. Essa funo pode ser usada da seguinte forma:
gluBuild2DMipmaps (GL_TEXTURE_2D,
components,
width,
height,
format,
type,
pixels
//
//
//
//
//
//
igual
igual
igual
igual
igual
igual
ao
ao
ao
ao
ao
ao
glTexImage2D
glTexImage2D
glTexImage2D
glTexImage2D
glTexImage2D
glTexImage2D
);
10.4. Leitura da imagem em disco

O OpenGL no oferece nenhuma funcionalidade para ler e interpretar arquivos de imagem do
disco. Essa tarefa de responsabilidade do desenvolvedor. Entretanto existem diversas bibliotecas
disponveis na internet para auxiliar o desenvolvedor nessa tarefa. Neste trabalho, ser usada a
biblioteca DevIL para a leitura dos dados em disco.
38
Luis Valente
10.4.1. Instalao da DevIL

A biblioteca DevIL (Developer's Image Library) est disponvel em http://www.imagelib.org.
Essa biblioteca gratuita e possui o cdigo aberto, est disponvel para vrias plataformas. Ela foi
escolhida por ser fcil de se usar e possuir um modelo de uso parecido com o OpenGL.
Inicialmente, preciso baixar do site da DevIL a verso pr-compilada da biblioteca (a no ser
que ser queira compil-la para gerar as DLLs). A verso pr-compilada para Windows est pronta
para ser usada com o Visual C++.
A seguir, necessrio configurar o compilador para usar os arquivos .h e os arquivos de ligao.
As instrues supem que o arquivo tenha sido descompactado em c:\devil.
Para configurar a DevIL no Visual C++ 6:
Acesse os menus Tools, Options e escolher a aba Directories. Em Show directories
for, escolher include files. Criar uma nova entrada e acrescente c:\devil\include.
Acesse os menus Tools, Options e escolher a aba Directories. Em Show directories

for, escolher library files. Criar uma nova entrada e acrescentar c:\devil\lib.
Para configurar a DevIL no Visual C++ .NET:

Acesse os menus Tools, Options e escolher Projects no painel da esquerda. A
seguir, escolher VC++ Directories e em Show directories for, escolher Include files.
Criar uma nova entrada e acrescentar c:\devil\include.
Acesse os menus Tools, Options e escolher Projects no painel da esquerda. A

seguir, escolher VC++ Directories e em Show directories for, escolher library files.
Criar uma nova entrada e acrescentar c:\devil\lib.
10.4.2. Leitura da imagem em disco

Uma vez que DevIL foi configurada corretamente, possvel usar suas funes para ler os
dados da imagem do disco, conforme demonstra o trecho de cdigo a seguir:
/**
* Esta funo demonstra como carregar um arquivo em disco
* com a DevIL.
*
* Retorna um identificador de textura do OpenGL.
* Caso seja 0, porque algum erro ocorreu no processo.
*/
GLuint CarregarImagem (const char * arquivo)
{
// esta varivel representa um identificador para a imagem
ILuint image;
// cria um id para a imagem
ilGenImages (1, & image);
// seleciona a imagem para uso
39
Luis Valente
ilBindImage (image);
// determinamos que o 0,0 da figura o canto
// inferior esquerdo
ilEnable (IL_ORIGIN_SET);
ilOriginFunc (IL_ORIGIN_LOWER_LEFT);
// carregamos a imagem do disco
ilLoadImage (arquivo);
// algum erro no carregamento do arquivo ?
ILenum erro = ilGetError ();
if (erro != IL_NO_ERROR)
{
// desaloca recursos usados para carregar a imagem
ilDeleteImages (1, & image);
}
return 0;
// recuperamos dados sobre a imagem

int width
= ilGetInteger (IL_IMAGE_WIDTH);
int height
= ilGetInteger (IL_IMAGE_HEIGHT);
int bytesPerPixel = ilGetInteger (IL_IMAGE_BYTES_PER_PIXEL);
ILenum imageFormat = ilGetInteger (IL_IMAGE_FORMAT);
ILubyte * imageData = ilGetData ();
// envia os dados para o OpenGL
GLuint tex = 0;
// habilita o uso de texturas
// gera um identificador para a textura
glGenTextures (1, & tex);
// seleciona a textura para uso
glBindTexture (GL_TEXTURE_2D, tex);
// carrega os dados para o OpenGL
glTexImage2D (GL_TEXTURE_2D,
0,
// nvel de detalhe
40
Luis Valente
bytesPerPixel, //
width,
height,
0,
imageFormat,
GL_UNSIGNED_BYTE
imageData
);
nmero de componentes de cor

// largura
// altura
// borda
// formato
// tipo de dados do array
// array contendo os dados
// (pixels) da imagem
// desaloca os recursos usados para carregar

// a imagem com a DevIL
ilDeleteImages (1, & image);
// retorna o identificador de textura
return tex;
}
10.4.3. Outras consideraes

Para se usar as funes da DevIL, preciso incluir o seu arquivo principal:
#include <IL/il.h>
Antes que as funes da DevIL possam ser usadas, necessrio inicializar a biblioteca. Ao final
do programa, necessrio finalizar a biblioteca. Esses comandos correspondem a:
ilInit ();
// inicializar a DevIL
ilShutDown (); // finalizar a DevIL

Para a ligao com a DLL, preciso especificar o arquivo de ligao. No Visual C++ 6, isso
pode ser feito da seguinte forma:
Acesse o menu Projects e depois Settings. A seguir, acesse a aba Linker. No campo
Object/library modules acrescente devil.lib (sem aspas).
J no Visual C++ .NET, o procedimento este:

Acesse o menu Project e depois Properties. No painel da esquerda, escolha a pasta
Linker e depois Input. No campo Additional dependencies, acrescente devil.lib (sem
aspas).
10.5. Coordenadas de textura

Para efetivamente aplicar a textura nos polgonos, preciso especificar as coordenadas de
textura.
O sistema de coordenadas de textura (2D), ilustrado na figura 10.2.
41
Luis Valente
Figura 10.2 Sistema de coordenadas de textura 2D
As coordenadas de textura 2D so especificadas com este comando:

glTexCoord2* (s, t)
O eixo s corresponde ao eixo horizontal da figura 10.2 e o eixo t corresponde ao eixo vertical da
mesma figura. No exemplo a seguir, uma textura mapeada em um quadrado:
glBindTexture (GL_TEXTURE_2D, id);
glColor3f (1.0f, 1.0f, 1.0f);
glBegin (GL_QUADS);
glTexCoord2f (0.0f, 0.0f);
glVertex3f (-10.0f, -10.0f, 0.0f);
glVertex3f (10.0f, -10.0f, 0.0f);
glVertex3f (10.0f, 10.0f, 0.0f);
glVertex3f (-10.0f, 10.0f, 0.0f);
glEnd ();
Como visto na figura 10.2, as coordenadas de textura variam de 0.0 a 1.0 nos dois eixos.
Entretanto, caso sejam especificados valores fora dessa faixa, ocorrer uma destas alternativas: a
textura ser truncada (GL_CLAMP) ou a textura ser repetida pelo polgono (GL_REPEAT, que
o padro). A figura 10.3 ilustra esses resultados:
42
Luis Valente
Figura 10.3 Resultados (NeDa97) (a) Truncamento. (b) Repetio (padro)
Esse comportamento pode ser redefinido utilizando-se o seguinte trecho de cdigo:

glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, modo);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, modo);
A constante GL_TEXTURE_WRAP_S indica que a alterao ser efetuada somente para o eixo
S, enquanto que a constante GL_TEXTURE_WRAP_T indica que o eixo T ser o afetado. Dessa
forma, possvel determinar comportamentos diferentes para cada um dos eixos.
10.6. Outros parmetros

Existem diversos parmetros que afetam a aparncia de textura que podem ser configurados.
Um dos mais interessantes aquele que determina qual ser o filtro utilizado para interpolar a
textura sobre o polgono.
Os filtros disponveis podem ser de dois tipos: filtros de reduo ou filtros de ampliao. Os
filtros de reduo so usados quando a textura maior do que o polgono a ser mapeado, enquanto o
filtro de ampliao usado quando o polgono maior do que a textura. Os filtros podem ser
especificados com este trecho de cdigo:
glTextureParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
filtro);
glTextureParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
filtro);
A constante GL_TEXTURE_MIN_FILTER indica que o filtro que ser alterado o filtro de
reduo. J o filtro de ampliao representado pela constante GL_TEXTURE_MAG_FILTER.
Os filtros existentes so os seguintes:
GL_NEAREST: Utiliza o texel mais prximo (vizinho) do pixel que est sendo mapeado.
o filtro de melhor desempenho, porm o de menor qualidade. Pode ser usado como filtro de
ampliao ou reduo.
43
Luis Valente
GL_LINEAR: Utiliza interpolao linear. Prov melhores resultados visuais, mas mais
custoso em termos computacionais. Pode ser usado como filtro de reduo e ampliao. Esse
filtro o selecionado por padro.
GL_NEAREST_MIPMAP_NEAREST: Escolhe a mipmap com tamanho semelhante ao do

polgono que est sendo mapeado e usa o mesmo critrio que GL_NEAREST para escolher o
texel da textura.
GL_NEAREST_MIPMAP_LINEAR: Escolhe a mipmap com tamanho semelhante ao do

polgono que est sendo mapeado e usa o mesmo critrio que GL_LINEAR para escolher o
texel da textura.
GL_LINEAR_MIPMAP_NEAREST: Escolher duas mipmaps com tamanhos mais

prximos ao do polgono que est sendo mapeado e usar o filtro GL_NEAREST para escolher
o texel de cada textura. O valor final uma mdia entre esses dois valores.
GL_LINEAR_MIPMAP_LINEAR: Escolher duas mipmaps com tamanhos mais prximos

ao do polgono que est sendo mapeado e usar o filtro GL_LINEAR para escolher o texel de
cada textura. O valor final uma mdia entre esses dois valores.
Outro parmetro que pode ser alterado indica o modo como a textura ser afetada pelas cores
dos polgonos e informaes de iluminao calculadas. O modo padro (GL_MODULATE) indica
que essas informaes sejam interpoladas com os dados da textura. J o modo GL_DECAL indica
que o mapeamento deve ignorar essas informaes (a textura mapeada como se fosse um
adesivo).
Esses modos podem ser determinados com o comando:
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_MODE, modo);
11. Objetos mais complexos

O OpenGL oferece meios de desenhar objetos mais complexos do que linhas e polgonos, como
curvas de Bzier e NURBS.
Esta seo explica um outro tipo de objeto que pode ser desenhado em OpenGL: as superfcies
quadrticas. Com o uso de superfcies quadrticas, possvel desenhar cilindros, discos e esferas.
As superfcies quadrticas so representadas em OpenGL pelo
GLUquadricObj. Inicialmente, preciso criar um objeto desses para uso:
tipo
de
dados
#include <GL/glu.h>
GLUquadricObj * quadric = gluNewQuadric ();
Quando no for mais necessrio usar o objeto quadric, ser necessrio liberar os recursos
alocados para a superfcie:
gluDeleteQuadric (quadric);
Existem vrias propriedades da superfcie que podem ser configuradas atravs de comandos da
GLU.
44
Luis Valente
O comando gluQuadricStyle afeta o modo como o objeto desenhado. Os modos

possveis so GLU_FILL (slido), GLU_LINE (wireframe), GLU_SILHOUETTE (desenha
somente a silhueta) e GLU_POINT (desenha somente os vrtices). A sintaxe desse comando :
gluQuadricStyle (quadric, estilo);
O comando gluQuadricNormals controla o modo como os vetores normais do objeto so
gerados. O modo GLU_NONE indica que os vetores normais no devem ser gerados. O modo
GLU_FLAT indica que os vetores normais devem ser gerados para cada face somente, o que resulta
em uma aparncia facetada para o objeto. J o modo GLU_SMOOTH indica que os vetores normais
devem ser gerados para cada vrtice, para que a aparncia resultante seja suave. Os vetores normais
afetaro a aparncia do objeto caso a iluminao esteja sendo usada. O comando pode ser usado da
seguinte forma:
gluQuadricNormals (quadric, modo);
Outra propriedade relacionada com iluminao indica qual a orientao usada para os vetores
normais. Existem duas opes: os vetores podem apontar para fora do objeto ou para dentro do
objeto. As opes correspondentes so GLU_OUTSIDE e GLU_INSIDE. Geralmente, escolhe-se
gerar os vetores normais apontando para dentro do objeto quando se deseja posicionar o observador
dentro desse objeto. O comando para alterar essa propriedade :
gluQuadricOrientation (quadric, valor);
As superfcies quadrticas tambm podem texturizadas. Existe um comando para determinar se
as coordenadas de textura do objeto devem ser geradas automaticamente, como exemplificado a
seguir:
gluQuadricTexture (quadric, flag);
As opes possves so GLU_TRUE (gerar as coordenadas) e GLU_FALSE (no gerar as
coordenadas).
11.1. Cilindros
Os cilindros podem ser desenhados com o seguinte comando:
void gluCylinder (GLUquadricObj * qobj,
GLdouble baseRadius,
GLdouble topRadius,
GLdouble height,
GLint
slices,
GLint
stacks
);
Os parmetros baseRadius e topRadius indicam os raio da base do cilindro e do topo do
cilindro, respectivamente. O parmetro height indica qual a altura do cilindro. O parmetro
slices indica qual o nmero de faces na lateral do cilindro. J o parmetro stacks indica
quantas divises existem ao longo do corpo do cilindro. Esses parmetros so ilustrados na figura
11.1.
45
Luis Valente
Figura 11.1 Parmetros de gluCylinder. (a) slices. (b) stacks.
A base do cilindro desenhada em z = 0, e o topo estar em z = height. As extremidades do

cilindro no so preenchidas, ou seja, o cilindro no fechado.
11.2. Discos
Os discos podem ser desenhados com a seguinte funo:
void gluDisk (GLUquadricObj * qobj,
GLdouble innerRadius,
GLdouble outerRadius,
GLint
slices,
GLint
loops
);
Os parmetros innerRadius e outerRadius correspondem aos raios interno e externo do
disco. O parmetro slices indica quantos lados o disco possui. Esses parmetros so ilustrados na
figura 11.2.
Figura 11.2 Parmetros raio interno e externo de gluDisk
46
Luis Valente
Finalmente, o parmetro loops indica o nmero de crculos concntricos que devem ser
desenhados entre os raios interno e externo.
O disco desenhado no plano z = 0.
11.3. Discos incompletos

A funo gluDisk permite desenhar discos completos. possvel desenhar discos
incompletos (que no possuem uma circunferncia completa). Para isso, usa-se esta funo:
void gluPartialDisk (GLUquadricObj * qobj,
GLdouble innerRadius,
GLdouble outerRadius,
GLint
slices,
GLint
loops,
GLdouble startAngle,
GLdouble sweepAngle
);
A diferena entre gluDisk e gluPartialDisk nesta ltima funo, uma frao do disco
desenhada, com incio no ngulo startAngle e fim no ngulo startAngle+sweepAngle.
O ngulo startAngle especificado no sentido horrio quando visto a partir do topo do disco.
O disco desenhado no plano z = 0.
11.4. Esferas
Para se desenhar esferas, utilizado o seguinte comando:
void gluSphere (GLUquadricObj * qobj,
GLdouble radius,
GLint slices,
GLint stacks
);
A esfera desenhada de forma que o seu centro coincida com a origem. O parmetro radius
define raio da esfera. O parmetro slices indica o nmero de divises da esfera em torno do eixo
Z (como longitude). J o parmetro stacks indica o nmero de divises da esfera ao longo do
eixo Z (como latitude). A figura 11.3 ilustra os parmetros slices e stacks.
47
Luis Valente
Figura 11.3 Parmetros de glSphere. (a) slices. (b) stacks.
12. Exemplo com freeglut

Esta seo apresenta um esqueleto de programa que pode ser usado como ponto de partida para
o desenvolvimento de aplicaes simples com freeglut e OpenGL. Nesse programa, um quadrado
vermelho ser animado e desenhado em uma janela. Quando o quadrado colidir contra as bordas da
parede (na verdade, da viewport), sua velocidade ser alterada de modo que o objeto ir quicar. O
usurio poder encerrar a aplicao usando a tecla ESC do teclado.
O primeiro passo incluir os arquivos necessrios e declarar as funes que trataro eventos no
freeglut, como feito neste trecho de cdigo:
GLfloat quad_x = 0.0f;
GLfloat quad_y = 0.0f;
GLfloat quad_z = 0.0f;
GLfloat vx = 0.01f;
GLfloat vy = 0.005f;
GLfloat vz = 0.008f;
void
void
void
void
OnUpdate ();
OnResize (int width, int height);
OnRender ();
OnKeyPress (unsigned char key, int x, int y);
void InitGL ();

O nico arquivo que precisa ser includo o do freeglut. A posio atual do quadrado
armazenada nas variveis quad_x, quad_y e quad_z. O ponto de referncia o centro do
quadrado. A velocidade do quadrado armazenada nas variveis vx, vy e vz.
48
Luis Valente
As funes OnUpdate, OnResize, OnRender e OnKeyPress so usadas para tratar

eventos. A atualizao da animao realizada em OnUpdate. A funo OnResize
responsvel por tratar o evento que ocorre quando a janela redimensionada. As operaes de
desenho so feitas em OnRender, e a funo OnKeyPress responsvel por tratar o teclado.
Finalmente, na funo InitGL, estabelecida uma configurao inicial para o OpenGL.
O programa principal definido no seguinte trecho de cdigo:
void main ()
{
glutInitDisplayMode (GLUT_DOUBLE | GLUT_DEPTH | GLUT_RGB);
glutCreateWindow (Exemplo de animao);
glutDisplayFunc
glutReshapeFunc
glutKeyboardFunc
glutIdleFunc
(OnRender);
(OnResize);
(OnKeyPress);
(OnUpdate);
InitGL ();
glutMainLoop ();
}
12.1. Funo principal

A primeira linha do programa requisita ao freeglut que sejam usados dois buffers para a janela,
um z-buffer e modo de cores RGB. Como a aplicao usa uma animao, o modo double-buffered
necessrio para evitar o efeito de flicker.
As funes responsveis por tratar eventos so especificadas ao freeglut logo depois, como
repetido aqui:
glutDisplayFunc
glutReshapeFunc
glutKeyboardFunc
glutIdleFunc
(OnRender);
(OnResize);
(OnKeyPress);
(OnUpdate);
A funo glutReshapeFunc especifica qual a callback usada para se tratar o evento de

redimensionamento da janela. importante que esse evento seja tratado para que se possa atualizar
a viewport e a projeo usada pelo programa quando a janela mudar de tamanho (o OpenGL no faz
isso automaticamente).
Uma das funes disponveis para especificar a callback responsvel tratar eventos do teclado
glutKeyboardFunc.
Em glutIdleFunc, especificada uma funo que ser executada quando no houver outros
eventos a serem tratados (em outras palavras, essa funo executada quando a aplicao est
ociosa).
Logo adiante, os estados iniciais do OpenGL so determinados e a aplicao inicia seu lao
principal de execuo.
49
Luis Valente
12.2. Inicializao
Na etapa de inicializao, so submetidos comandos que determinam funcionalidades que sero
usadas no restante da aplicao. A funo correspondente descrita a seguir:
void InitGL ()
{
glEnable (GL_DEPTH_TEST);
glEnable (GL_CULL_FACE);
glLoadIdentity ();
}
Essa funo requisita que o testes de z-buffer e eliminao de faces escondidas (backface
culling) sejam habilitados.
A seguir, a cor de fundo da janela estabelecida. (preto).
Finalmente, determina-se que o tipo de projeo usado a partir deste momento ser a matriz de
modelagem.
12.3. Deteminao da projeo

A projeo usada pelo programa determinada pela funo OnResize:
void OnResize (int width, int height)
{
glViewport (0, 0, width, height);
glLoadIdentity ();
glOrtho (-12.0f, 12.0f, -12.0f, 12.0f, -12.0f, 12.0f);
glLoadIdentity ();
}
A primeira linha determina que a viewport usada pelo programa corresponde janela inteira. A
projeo usada pelo programa uma projeo ortogrfica com as mesmas medidas em todos os
eixos.
Durante o ciclo de vida da aplicao, esse evento executado pelo menos uma vez (depois que
o lao principal de execuo iniciado).
50
Luis Valente
12.4. Atualizao
A funo OnUpdate atualiza a posio do quadrado e verifica se existiu alguma coliso contra
as bordas da janela (viewport, na verdade). Caso exista, a posio do quadrado corrigida e a sua
velocidade invertida (no eixo onde ocorreu a coliso). O quadrado possui aresta de tamanho igual
a 4 unidades.
void OnUpdate ()
{
quad_x += vx; quad_y += vy;
quad_z += vz;
if (quad_x > 10.0f || quad_x < -10.0f)

vx = - vx;
if (quad_y > 10.0f || quad_y < -10.0f)
vy = - vy;
if (quad_z > 10.0f || quad_z < -10.0f)
vz = - vz;
glutPostRedisplay ();
}
A funo glutPostRedisplay informa ao freeglut que necessrio redesenhar o contedo
da janela. Se essa funo no for usada, no ser possvel visualizar as alteraes.
12.5. Teclado
A funo OnKeyPress recebe como parmetros a tecla que foi pressionada e a posio do
mouse no momento em que a tecla foi pressionada.
void OnKeyPress (unsigned char key, int x, int y)
{
switch (key)
{
case 'q': case 'Q' :
exit (0); break;
}
}
Existem outras funes para se tratar eventos do teclado, que podem ser consultadas na
documentao do freeglut ou do GLUT.
12.6. Renderizao
A funo responsvel pela renderizao inicia com a requisio para que a tela e o z-buffer
sejam limpos.
51
Luis Valente
A seguir, a matriz identidade carregada, para que o sistema de coordenadas seja reiniciado
para a origem.
void OnRender ()
{
glLoadIdentity ();
glTranslatef (quad_x, quad_y, quad_z);
glColor3f (1.0f, 0.0f, 0.0f);
glBegin (GL_QUADS);
glVertex3f
glVertex3f
glVertex3f
glVertex3f
(2.0f, 2.0f, 0.0f);

(-2.0f, 2.0f, 0.0f);
(-2.0f, -2.0f, 0.0f);
(2.0f, -2.0f, 0.0f);
glEnd ();
glutSwapBuffers ();
}
A seguir, necessrio posicionar o quadrado, o que feito com o comando glTranslatef.
O quadrado , ento, especificado.
A funo glutSwapBuffers requisita que o buffer usado para as operaes de renderizao
seja exibido na tela.
13. Concluses
OpenGL uma API muito rica e cheia de recursos. Este trabalho aborda apenas uma parte do
que poderia ser usado.
Existem tutoriais e outros recursos para se aprender mais sobre OpenGL em vrios lugares na
internet. Aqui esto alguns deles:
Site oficial do OpenGL: http://www.opengl.org
Nate Robins Programas interativos com demonstrao de vrios conceitos sobre

OpenGL: http://www.xmission.com/~nate/tutors
NeHe Tutoriais variados sobre OpenGL: http://nehe.gamedev.net
GameTutorials Vrios tutoriais sobre OpenGL, com enfoque para programao de jogos:
http://www.gametutorials.com
JOGL Biblioteca para uso OpenGL em Java: https://jogl.dev.java.net
Dephi3D OpenGL e programao 3D com Delphi: http://www.delphi3d.net
52
Luis Valente
14. Referncias Bibliogrficas

OGL04
OpenGL, site oficial: http://www.opengl.org, 2004
WrSw99
Wright, Richard S.; Sweet, Michael OpenGL SuperBible Second Edition, Waite
Group Press, 1999
NeDa97
Neider, Jackie; Davis, Tom OpenGL Programming Guide, 2nd Edition,

Addison-Wesley, 1997
FGLUT04
freeglut, site oficial: http://freeglut.sourceforge.net, 2004
DEVIL04
DevIL, site oficial: http://www.imagelib.org, 2004
53

Opengl - Um Tutorial: Resumo

Enviado por

Direitos autorais:

Formatos disponíveis

Opengl - Um Tutorial: Resumo

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Opengl - Um Tutorial: Resumo

Enviado por

Direitos autorais:

Formatos disponíveis

OpenGL Um tutorial

UFF - Mestrado em Computao

GL: Representa o ncleo do OpenGL, que agrega as funes principais.

Application Programming Interface

UFF - Mestrado em Computao

2.1. Configurao inicial

2.2. Visual C++

Visual C++ 7 (.NET): Acesse o menu Project e depois Properties. No painel da

necessrio incluir o arquivo principal do Windows (windows.h), antes dos arquivos do

UFF - Mestrado em Computao

Figura 2.1 Comando tpico do OpenGL (WrSw99)

O comando retratado na figura possui as seguintes caractersticas:

O nome principal do comando. O exemplo da figura representa um comando para se

O nmero de argumentos aceitos pela funo. A funo do exemplo aceita 3 argumentos.

Como um dos objetivos do OpenGL ser independente de plataforma, so definidos vrios

Tipo definido no OpenGL

ponto flutuante 32 bits

ponto flutuante 64 bits

inteiro 8 bits sem sinal

inteiro 16 bits sem sinal

inteiro 32 bits sem sinal

GLuint, GLenum, GLbitfield

unsigned int, unsigned

array, usado em conjunto com os outros

Tabela 2.1 Tipos de dados do OpenGL

UFF - Mestrado em Computao

A opo a se tomar depende dos objetivos da aplicao.

3.1. Instalao do freeglut

UFF - Mestrado em Computao

3.1.2.1. Visual C++ 6

Copiar a .lib gerada para um diretrio c:\freeglut\lib (esse passo no estritamente

Acrescentar o diretrio onde est o freeglut.lib (ex: c:\freeglut\lib) no Visual C++.

3.1.2.2. Visual C++ .NET

Copiar a .lib gerada para um diretrio c:\freeglut\lib (esse passo no estritamente

Acrescentar o diretrio onde est o freeglut.lib (ex: c:\freeglut\lib) no Visual C++.

UFF - Mestrado em Computao

3.1.3. Outros compiladores

3.2. Exemplo de uso

int main (int argc, char * argv [])

3.2.1. Arquivos de incluso

UFF - Mestrado em Computao

3.2.2. Funo principal

UFF - Mestrado em Computao

3.2.3. Comandos do OpenGL

// comandos que especificam os componentes da primitiva

UFF - Mestrado em Computao

(10.0f, 40.0f, 0.0f);

Figura 4.1 Primitivas do OpenGL (NeDa97)

UFF - Mestrado em Computao

a linhas em OpenGL que so

A primitiva GL_LINE corresponde a linhas simples:

UFF - Mestrado em Computao

Nesse exemplo, existiro dois segmentos de reta.

UFF - Mestrado em Computao

A ordem pode ser GL_CW (sentido horrio) ou GL_CCW (sentido anti-horrio).

UFF - Mestrado em Computao

Figura 4.3 Sequncia de especificao de vrtices para GL_TRIANGLE_STRIP

(10.0f, -1.0f, 0.0f);

UFF - Mestrado em Computao