Luiz Fernando Marcio Neves Petrônio Gomes Thiago Monteiro Victor Hazin www.cin.ufpe.br/~vhr/opengl

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); 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); 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); 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/BibliografiaLinks.html