www.cin.ufpe.br/~vhr/opengl
Luiz Fernando
Marcio Neves
Petrônio Gomes
Thiago Monteiro
Victor Hazin
Roteiro












O que é OpenGL?
O Pipeline de Renderização
O que é GLUT?
Formato dos Comandos em OpenGL
Primitivas Geométricas
Visualização
Cores
Transformações Geométricas
Iluminação
Configurando OpenGL e GLUT
Textura
Referências
O que é OpenGL ?
 A OpenGL é uma máquina de estados porque é
possível colocá-la em vários estados (ou modos) que
não são alterados, a menos que uma função seja
chamada para isso.
 Muitas delas referem-se a modos que podem ser
ativados ou desativados com os comandos glEnable()
e glDisable().
O Pipeline de Renderização
O que é GLUT ?
 OpenGL Utility Toolkit
 Sistema de Janelas independente de plataforma para desenvolvimento de




aplicações OpenGL
 Possui funções para:
 Criar/Destruir janelas
 Tratar entradas de teclado, mouse e joysticks
Baseado em funções de callback para tratamento de eventos
API simples, não possuindo recursos diretos para criação de GUI's
Independente do sistema de janelas nativo
Programação orientada a eventos
Formato dos Comandos em
OpenGL
Primitivas Geométricas
 OpenGL possui 10 primitivas geométricas
 um tipo de ponto
 três tipos de linhas
 seis tipos de polígonos
 Os vértices são definidos pelo comando Vertex
glVertex2f( float x, float y);
//vértice para um eixo 2D
glVertex3d(double x,double y, double z); //vértice para um exixo 3D
 As primitivas precisam ser delimitadas através de Begin ...
End conforme abaixo:
Begin ( nome da primitiva);
... // aqui serão colocados comandos Vertex.
End (void);
Primitivas Geométricas
 Ponto
 a primitiva responsável em desenhar pontos na tela é GL_POINTS
 O código no exemplo abaixo desenha 3 pontos na tela. Cada vértice torna-se
um ponto
glBegin( GL_POINTS );
glVertex2f( xf, yf);
glVertex2f( xf, yf);
glVertex2f( xf, yf);
glEnd();
Primitivas Geométricas
 Linhas
 GL_LINES : O terceira coordenada ( z ) é ignorada pois a linha é formada
por dois vértices.
 Se houvesse um quarto vértice, uma nova linha entre o terceiro e quarto
vértice seria exibida
 GL_LINE_STRIP: cria linhas consecutivas, ligando o primeiro vértice com
o segundo, o segundo com o terceiro e assim por diante
 GL_LINE_LOOP : Funciona de maneira semelhante ao anterior, porém o
último vértice é ligado a primeira, devido a isso o LOOP no seu nome. O
espessura de uma linha pode ser modificada através do comando
glLineWidth (GLint espessura), bastando passar como parâmetro a
espessura da linha
Primitivas Geométricas
 Polígonos
 Áreas formadas por várias linhas conectadas
 Arestas do polígono não podem se cruzar
 Devem ser áreas convexas
 O número de segmentos do polígono não é restrito
 OpenGL assume que todos os polígonos são simples
 Problema da superfície construída a partir de quadriláteros
 Quadriláteros são polígonos não planares
 Caso seja feita alguma transformação, podem deixar de
ser polígonos simples
 Para evitar que isto aconteça, é sempre bom utilizar
triângulos para compor as superfícies, pois triângulos são sempre
co-planares
Primitivas Geométricas
 Polígonos
 GL_TRIANGLES: Desenha triângulos a cada 3 vértices fornecidos;
 GL_TRIANGLE_STRIP: Uma série de triângulos conectados. Após




o desenho do primeiro triângulo, cada vértice adicional forma um
novo triângulo com dois últimos pontos fornecidos;
GL_TRIANGLE_FAN: Uma série de triângulos com um único
vértice em comum. O vértice comum é o primeiro vértice fornecido;
GL_QUADS: Desenha um quadrilátero a cada 4 vértices fornecidos;
GL_QUAD_STRIP: Desenha uma série de quadriláteros. Após o
primeiro, apenas mais 2 vértices precisam ser fornecidos para o
desenho do segundo quadrilátero;
GL_POLYGON: Desenha polígonos convexos simples com um
número arbitrário de vértices
Visualização
 Para permitir a visualização de objetos tridimensionais
é necessário usar projeção para converter as
coordenadas 3D em coordenadas 2D que
correspondem a uma visão específica do objeto.
 Existem dois tipos de projeção: a perspectiva e a
paralela.
Visualização
 Projeção em perspectiva: é a que acontece no
processo de formação de imagens em nossos olhos ou
numa câmera fotográfica, por isso é a que gera imagens
mais realistas.
Visualização
 Projeção paralela ou ortogonal : é a forma mais
simples de projeção. Nela a imagem de um ponto é
definida como a projeção normal deste ponto no plano
de projeção. A projeção paralela pode ser vista como
uma projeção perspectiva onde o centro de projeção
está no infinito.
Visualização
 Projeção ortogonal:
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glOrtho(X min, X max, Y min, Y max, Near, Far);
Visualização
 Projeção em perspectiva:
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glPerspective(fovy, aspect, near, far);
Visualização
 Caso você faça a projeção com os comandos glOrtho ou
glFrustum, o OpenGL especifica uma matriz default,
na qual a câmera está alinhada com o eixo z.
 A posição da câmera pode ser alterada através das
transformações geométricas sobre a matriz de
visualização.
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glRotatef(-30, 1.0, 0.0, 0.0);
glRotatef(30, 0.0, 1.0, 0.0);
glRotatef(30, 0.0, 0.0, 1.0);
glTranslatef(2.0,0.0,0.0);
Cores
 As cores em OpenGL são determinadas pelo comando Color
 Seguem o padrão RGB (Red Green Blue) adotados em diversos sistemas
 Em OpenGL:
Color3 {f,d} ( XRed, XGreen, XBlue), onde :
XRed: porcentagem de vermelho (variando de 0.0 a 1.0)
XGreen: porcentagem de verde (variando de 0.0 a 1.0)
XBlue: porcentagem de azul (variando de 0.0 a 1.0)
Transformações Geométricas
 Em muitas aplicações de computação gráfica, há a necessidade de
alterar e manipular o conteúdo de uma cena
 Animações, por exemplo, são produzidas pelo movimento da câmera
ou dos objetos presentes na cena
 Mudanças em orientação, tamanho e formato estão ligadas às
transformações geométricas
 São cumulativas, ou seja, podem ser aplicadas umas sobre as outras
 Uma transformação geométrica de OpenGL é armazenada
internamente em uma matriz
 A cada tranformação esta matriz é alterada e usada para desenhar os
objeto a partir daquele momento, até que seja novamente alterada
Transformações Geométricas
 Translação
 Quando aplicada a um objeto, reposiciona o mesmo mudando suas
coordenadas (x,y,z) no espaço tridimensional, por fatores Tx, Ty e Tz,
respectivamente. Dessa forma, considerando, inicialmente, um objeto com
coordenadas espaciais (x,y,z), sua nova posição (x',y',z') após uma operação
de translação será:
x‘ = x + Tx
y‘ = y + Ty
z‘ = z + Tz
Transformações Geométricas
 Translação
 Em OpenGL:
Translate {f,d} ( Tx, Ty, Tz ), onde:
Tx: é o quanto se quer transladar o objeto em relação ao eixo X
Ty: é o quanto se quer transladar o objeto em relação ao eixo Y
Tz: é o quanto se quer transladar o objeto em relação ao eixo Z
glTranslatef(xf, yf, zf);
glBegin(GL_POLYGON);
glVertex2f( xf, yf);
glVertex2f( xf, yf);
glVertex2f( xf, yf);
glEnd();
Transformações Geométricas
 Rotação
 É o ato de efetuar um giro em um objeto de acordo com um
ângulo e um eixo definidos anteriormente.
 Para efetuar uma rotação há o comando glRotatef(Angulo, x, y, z)
que gira o objeto ao redor do vetor (x,y,z). O giro é de Angulo graus,
no sentido anti-horário.
glRotatef(45.0f,0.0f,0.0f,1.0f);// roda 45 graus no eixo z
glBegin(GL_POLYGON);
glVertex2f( xf, yf);
glVertex2f( xf, yf);
glVertex2f( xf, yf);
glEnd();
Iluminação
 Cria a sensação de Profundidade
 Sem iluminação Objetos parecem planos
 Adiciona Realismo à cena
 A sensação de profundidade provê mais realismo
 Deixa a cena mais bonita
 Criada através de Fontes de luz:
 Um ponto no Infinito (ex: o Sol)
 Um ponto próximo (ex: uma lâmpada incandescente)
 Uma fonte de luz distribuída (ex: lâmpadas de Neon ou
de Gás)
Iluminação
 Como pretendemos utilizar iluminação, é
indispensável definir vetores normais para o nosso
objeto
Iluminação
 OpenGL permite dois tipos de Shading: O GL_FLAT, o
GL_SMOOTH.
 O GL_FLAT é implementado levando em consideração
apenas os vetores normais relativos ao triangulo.
 O GL_SMOOTH é implementado levando em
consideração o modelo de iluminação de Gouraud.
Iluminação
 OpenGL aproxima a iluminação assumindo que a luz
pode ser dividida nas suas componentes de vermelho,
verde e azul (RGB).
 As fontes de luz são caracterizadas pelas quantidades
RGB que emitem
 Os materiais das superfícies são caracterizados pelas
percentagens dos componentes RGB recebidos que são
refletidos nas várias direções.
Iluminação
 OpenGL considera várias formas de reflexão da luz
incidente:
 Emitida: Simula a luz que se origina de um objeto; a cor
emissiva de uma superfície adiciona intensidade ao objeto,
mas não é afetada por qualquer fonte de luz; ela também não
introduz luz adicional da cena.
 Ambiente: Resultado da luz refletida no ambiente; é uma luz
que vem de todas as direções.
 Difusa: Luz que vem de uma direção, atinge a superfície e é
refletida em todas as direções; assim, parece possuir o mesmo
brilho independente de onde a câmera está posicionada.
 Especular: Luz que vem de uma direção e tende a ser
refletida numa única direção.
Iluminação
 A iluminação é definida apenas uma vez, na função para
inicialização do GLUT
GLfloat mat_specular[] = {1.0, 1.0, 1.0, 1.0};
GLfloat mat_shininess[] = {25.0};
GLfloat light_position[] = {-1.0, 1.0, 1.0, 0.0};
/*Inicia as características gerais dos materiais */
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
/* Inicia a iluminação */
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
Configurando OpenGL e GLUT
 Criando um projeto
 No menu File -> New -> Project...
 Escolher Visual Studio Projects escolha Win32 Console Aplication
 Selecionar o nome do projeto, por exemplo,OpenGL Cube
 Selecionar o nome da solução, por exemplo, OpenGL Apps
 Selecionar o caminho do projeto, por exemplo, C:\Temp
 Clicar em OK
 Na tela que aparecer clica em next e marcar a opção empty project
 Baixe os arquivos necessários para a configuração em
www.cin.ufpe.br/~vhr/opengl
Configurando OpenGL e GLUT
Clique com o botão direito no ícone do projeto e depois em propriedades
Configurando OpenGL e GLUT
Clique em C/C++
depois em
General e coloque
o diretório com o
glut.h em
Additonal Include
Directories
coloque o
diretório com o
glut.h em
Additonal Include
Directories
Configurando OpenGL e GLUT
Agora no menu
C/C++/Preprocessor em Preprocessor Definition coloque
GLUT_NO_LIB_PRAGMA
Configurando OpenGL e GLUT
Agora no menuLinker/General coloque o diretorio que
contém glut32.lib em additional library directories
Configurando OpenGL e GLUT
Em Linker/Input va em additional dependencies coloque
glut32.lib glu32.lib opengl32.lib nessa ordem.
E depois clique em e copie o arquivo glut32.dll para a pasta
do executável
Exercício
 Pegar o código inicial em
http://www.cin.ufpe.br/~vhr/opengl/exercicio.txt
 Desenvolver as funções que não estão implementadas
no código dado e usando os conceitos acima explicadas
 Lista de funções para ajudar em:
http://www.cin.ufpe.br/~vhr/opengl/Lista de
Funções.docx
Textura
 A idéia de textura é, de maneira geral, a sobreposição
de um objeto 3D por uma imagem. Dessa forma, é
possível dar impressão de relevo, chegando a um maior
nível de detalhamento e realismo.
 Em OpenGL
 Uma textura costuma ser guardada em uma matriz que
contém a informação de cada elemento da textura, que
corresponde a um pixel na imagem original,
denominado textel.
Textura
 Inicialização da Textura: é necessário especificá-la
através da função glTexImage2D().
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, TEXTURE_WIDTH,
TEXTURE_HEIGHT, 0, GL_RGB, GL_UNSIGNED_BYTE, texture_data);
Textura
 Os parâmetros GL_TEXTURE_MAG_FILTER e
GL_TEXTURE_MIN_FILTER referem-se,
respectivamente, aos casos em que existe aumento
(magnification) e redução (minification).
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 Para definir como a textura será aplicada a cada pixel
utiliza-se a função glTexEnvf().
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
Textura
 Para desenhar alguns objetos com texturas e outros
sem texturas, podemos utilizar as funções glEnable() e
glDisable() para ativá-las apenas quando necessárias.
 É necessário atribuir coordenadas de textura a cada
vértice do objeto
glTexCoord2fv(xTextura, yTextura);
glNormal3fv(xVertice, yVertice, zVertice);
glVertex3fv(xVetorNormal, yVetorNormal, zVetorNormal);
Exercício
 Baixar projeto exemplo em
www.cin.ufpe.br/~vhr/opengl
 Tentar modificar a textura no exemplo dado.
Referências
 http://www.dcc.ufla.br/~bruno/aulas/cg/monte-mor/
 http://www2.dc.ufscar.br/~saito/download/comp-
grafica/OPENGL-Spy.ppt
 http://www.xmission.com/~nate/opengl.html
 http://w3.ualg.pt/~srnunes/CG/exemplo4.html
 http://www.inf.pucrs.br/~manssour/OpenGL/Bibliogr
afiaLinks.html