Luiz FernandoMarcio Neves

Petrônio GomesThiago Monteiro

Victor Hazinwww.cin.ufpe.br/~vhr/opengl

RoteiroRoteiroO que é OpenGL?O Pipeline de RenderizaçãoO que é GLUT?Formato dos Comandos em OpenGLPrimitivas GeométricasVisualizaçãoCoresTransformações Geométricas IluminaçãoConfigurando OpenGL e GLUTTexturaReferê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étricasOpenGL possui 10 primitivas geométricas

um tipo de pontotrês tipos de linhasseis 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étricasPonto

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étricasLinhas

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étricasPolígonos

Áreas formadas por várias linhas conectadasArestas do polígono não podem se cruzarDevem ser áreas convexasO número de segmentos do polígono não é restritoOpenGL assume que todos os polígonos são simples

Problema da superfície construída a partir de quadriláterosQuadriláteros são polígonos não planaresCaso seja feita alguma transformação, podem deixar de

ser polígonos simplesPara 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étricasPolí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çãoPara 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çãoProjeçã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çãoProjeçã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çãoProjeção ortogonal:

glMatrixMode( GL_PROJECTION );  glLoadIdentity();  glOrtho(X min, X max, Y min, Y max, Near, Far);

VisualizaçãoProjeção em perspectiva:

glMatrixMode( GL_PROJECTION ); glLoadIdentity(); glPerspective(fovy, aspect, near, far);

VisualizaçãoCaso 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étricasEm 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étricasTranslaçã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étricasTranslaçã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étricasRotaçã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çãoCria a sensação de Profundidade

Sem iluminação Objetos parecem planosAdiciona Realismo à cena

A sensação de profundidade provê mais realismoDeixa a cena mais bonitaCriada 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çãoComo pretendemos utilizar iluminação, é

indispensável definir vetores normais para o nosso objeto

IluminaçãoOpenGL 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çãoOpenGL 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 emitemOs materiais das superfícies são caracterizados

pelas percentagens dos componentes RGB recebidos que são refletidos nas várias direções.

IluminaçãoOpenGL 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çãoA iluminação é definida apenas uma vez, na

função para inicialização do GLUTGLfloat 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 GLUTCriando 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 GLUTAgora no menuC/C++/Preprocessor  em Preprocessor Definition

coloque GLUT_NO_LIB_PRAGMA

Configurando OpenGL e GLUTAgora 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ícioPegar 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

TexturaA 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 OpenGLUma 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.

TexturaInicializaçã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);

TexturaOs 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);

TexturaPara 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ícioBaixar projeto exemplo em

www.cin.ufpe.br/~vhr/opengl

Tentar modificar a textura no exemplo dado.

Referênciashttp://www.dcc.ufla.br/~bruno/aulas/cg/

monte-mor/http://www2.dc.ufscar.br/~saito/download/

comp-grafica/OPENGL-Spy.ppthttp://www.xmission.com/~nate/opengl.htmlhttp://w3.ualg.pt/~srnunes/CG/

exemplo4.htmlhttp://www.inf.pucrs.br/~manssour/

OpenGL/BibliografiaLinks.html