Introdução ao OpenGL

Prévia do material em texto

ao	OpenGL
Sumário
Programando com OpenGL Exemplos
O que é OpenGL? [1]
Open Graphics Library
Interface de software para hardware gráfico. É uma biblioteca de modelagem e gráficos 3D, altamente portável e muito rápida.
Independente de SO e de hardware.
Muito mais rápido do que implementação puramente em software, como: motores de gráficos ou software de ray-tracing.
Inicio:
Biblioteca gráfica desenvolvida para rodar aplicações gráficas sobre o hardware proprietário da Silicon Graphis Inc. (SGI).
Primeira versão foi o IRIS GL, biblioteca gráfica das estações IRIS Graphics da SGI.
Hardware que provia transformações de matrizes com altíssima performance.
OpenGL surge da decisão de portar a IRIS GL para um padrão aberto, para suportar outros fabricantes de dispositivos gráficos, outras plataformas de hardware e outros sistemas operacionais.
OpenGL ARB:
API aberta não pode ser de propriedade de uma empresa apenas.
Surge então o OpenGL Architecture Review Board (ARB)
Consórcio, originalmente, formado por SGI, Digital Equipament Corporation, IBM, Intel e Microsoft. Outras empresas fazem parte do consórcio, como: SUN, nVIDIA, ATI, ...
01/07/1992 sai a primeira versão da especificação da OpenGL.
A partir de 2006 SGI transfere o controle sobre o padrão OpenGL para o grupo de trabalho The Khronos Group (www.khronos.org).
Atualmente, este grupo promove o OpenGL e outros padrões como o OpenGL ES (para dispositivos móveis).
OpenGL está na versão 4.0. Utilizaremos OpenGL na versão 2.0 da especificação.
Software x hardware:
SW tem muito menos performance que HW e alguns efeitos especiais podem ser proibitivos nas aplicações gráficas.
SW pode executar em qualquer plataforma sem que o usuário necessite de hardware especial, no caso hardware gráfico.
HW tem performance, porém maior custo.
OpenGL interage com o hardware. Uma aplicação gráfica que use a OpenGL necessitará que o dispositivo gráfico (placa-de- vídeo) e o driver gráfico implementem a especificação da OpenGL.
Como funciona a OpenGL
API Procedural. Programador invoca comandos OpenGL para compor uma cena. OpenGL não renderiza uma cena descrita, ela deve ser “programada” em código.
De forma mais básica, os objetos são desenhados com	primitivas gráficas: pontos, linhas e polígonos em 3D.
Permite visualização de objetos em qualquer ponto de um espaço 3D.
OpenGL suporta também iluminação e sombreamento, mapeamento de textura, blending, transparência, animação e diversos outros efeitos especiais.
Faz a conversão das primitivas para imagem – rasterização. Não possui funcionalidades para gerenciamento de janela,
interação com o usuário ou acesso a arquivos (I/O). É necessário
utilizar alguma biblioteca adicional (GLUT, SDL, ...)
Também não existe nenhum formato de arquivo associado ao OpenGL para modelos ou ambientes virtuais. O programador deve fazer a carga e interpretação dos formatos de arquivos comuns e converter para primitivas gráficas.
Matriz
Largura da linha
Como funciona a OpenGL
Brilho
Cor do fog
Framebuffer
Luz
Erro
Cor atual
Textura
Como funciona a OpenGL
OpenGL em software x em hardware
X
Implementação Microsoft Processamento passa por GDI Mais lenta
Limitação de funcionalidades
Implementação no driver do HW Comunicação direta com dispositivo Mais rápida
Como funciona a OpenGL
Pipeline OpenGL
Aplicação executa chamadas as funções da API da OpenGL. Comandos e dados (vértices, textura e etc) são armazenados no
command buffer.
Quando do “flush” os vértices passam pelo processamento matemático (transformações geométricas e de iluminação)
Depois é feita a rasterização para cria uma imagem colorida a partir da geometria, cor e dados de textura.
A imagem é colocada num framebuffer, que é a memória do dispositivo gráfico.
Dados 2D/3D
OpenGL/GLUT/SDL/DirectX
Modelo da Aplicação
Sistema Gráfico
Aplicação
Manipula dados e define o que será desenhado e aonde.
Aplicação
Dados 2D/3D
Modelo da Aplicação
GLUT
Manipula dados e define o que será desenhado e aonde.
GLUT – sistema de janelas independente de sistema. Não é livre
Dados 2D/3D
Modelo da Aplicação
Aplicação
Manipula dados e define o que será desenhado e aonde.
SDL – Simple DirectMedia Layer. LGPL. É livre
Bibliotecas OpenGL
Microsoft Windows  opengl32.dll
OpenGL utility library (GLU)  glu32.dll
Conjunto de funções utilitárias para tarefas comuns e complexas, algumas matrizes especiais para cálculo e suporte para curvas e superfícies.
Headers:
gl.h  header de prototipação das funções OpenGL
glu.h  header de prototipação das funçoes GLU
Exemplo de “#include” para um programa OpengGL:
	#include		// não vem no VisualC++ Express
	#include
#include #include	
 “glee.h” //	extensões da OpenGL
	#include	“glut.h” //	freeglut
Tipos de dados para se usar com a API OpenGL
Convenção de nomes
glVertex3f(0.0f, 0.0f, 0.0f); glVertex3i(0, 0, 0); glVertex3v(vertex[0]);
Convenção de nomes
Começam com gl...
Próximas palavras começa com a primeira letra maiúscula.
glBegin()
Constantes começam com GL_ e são sempre em maiúsculas.
GL_COLOR_BUFFER_BIT
Lembre-se:
OpenGL é máquina de estados, desenha primitivas e o estado das variáveis altera o resultado da síntese da imagem.
Um objeto é desenhado com a cor que está definida, com iluminação que está definida, com as transformações previamente definidas e etc.
Portanto, um vez definida um propriedade, ela ficará “residente” até tenha o seu estado limpo ou alterado com outro valor.
Por exemplo, quando uma cor é definida ela será usada em qualquer processo de colorização até que ocorra um novo comando de cor.
OpenGL não faz interação com usuário, portanto, não gerencia entrada e saída de dados. É necessário o uso de alguma biblioteca para gerenciamento de GUI. Padrão GLUT.
Como uma máquina de estados, os comandos também podem ter seu estado definido/alterado apenas como ligado ou desligado.
glEnable() e glDisable()
É o caso da iluminação:
glEnable(GL_LIGHTING)
CUIDADO: a troca frequente de estados afeta a performance. O melhor é “setar” os estados uma vez só, quando possível.
Desenho de primitivas:
Basicamente, é a definição dos vértices das primitivas e das propriedades de cor, normais, texturas e etc.
Tudo definido entre glBegin() e glEnd()
Exemplo:
glBegin(GL_TRIANGLES); glColor3f(0.0, 0.0, 1.0);
glVertex3f(0.0, 0.0, 0.0);
glVertex3f(1.0, 0.0, 0.0);
glVertex3f(0.5, 0.5, 0.0); glEnd();
Outros comandos utilizados dentro do bloco:
glColor*(), glNormal*(), glMaterial*()
Primitivas:
	Primitiva / Constante	Descrição
	GL_POINTS	Pontos individuais
	GL_LINES	Par de vértices = 1 linha
	GL_LINE_STRIP	Pontos conectados por linhas
	GL_LINE_LOOP	= strip + 1 linha para fechar
	GL_TRIANGLES	3 pontos = 1 triângulo
	GL_TRIANGLE_STRIP	Série de triângulos conectados
	GL_TRIANGLE_FAN	Todos tri compartilham ponto zero
	GL_QUADS	4 pontos = 1 quadrilátero
	GL_QUAD_STRIP	Série de quads. conectados
	GL_POLYGON	Todos pontos = 1 polígono
Primitivas:
Primitivas. Exemplos:
glBegin(GL_POLYGON); // ou glBegin(GL_POINTS); glVertex2f(0.0, 0.0);
glVertex2f(0.0, 3.0);
glVertex2f(4.0, 3.0);
glVertex2f(6.0, 1.5);
glVertex2f(4.0, 0.0); glEnd();
glColor3f(0.0f, 0.5f, 1.0f); glBegin(GL_POLYGON);
glVertex… glEnd();
glColor(0.0f, 0.0f, 0.0f); glBegin(GL_LINE_LOOP);
glVertex… glEnd();
24
Tipos de polígonos:
Válidos
Inválidos
Objetos curvos são aproximados por retas:
Exemplo. Desenhando um círculo:
#define PI 3.1415926535898
GLfloat circle_points = 100.0f;
GLfloat angle, raioX=1.0f, raioY=1.0f; glBegin(GL_LINE_LOOP);
for (int i = 0; ique:
O tamanho do círculo é dado pelo raio, no exemplo é desenhado um círculo com raio 1
Definindo o valor dos raios X e Y com valores diferentes, pode-se desenhar uma elipse.
Modo de polígono:
glPolygonMode(,)
GL_FRONT_AND_BACK GL_FRONT
GL_BACK
GL_POINT GL_LINE GL_FILL
Tratamento de erros em OpenGL:
Quando fazemos algo inválido em OpenGL ou GLU o programa não pára; apenas não faz o que a gente espera. Isso dificulta a depuração!
Quando um erro ocorre um flag é setado com um código de erro. Para acessar esse código deve-se usar glGetError();
Por outro lado… cada chamada OpenGL a mais afetam a performance… Em alguns casos quando queremos renderização em tempo real temos que eliminar o maior número possível dessas chamadas! Lembre-se: todos os comandos são bufferizados e processados.
Matrizes:
Três tipos de matrizes: GL_MODELVIEW:
A matriz modelview controla as transformações dos vértices dos objetos da cena
GL_PROJECTION
A matriz de projeção controla como a cena 3-D é projetada em 2-D
GL_TEXTURE
A matriz de texturas (geralmente pouco conhecida e utilizada) transforma as coordenadas das textura para obter efeitos como projetar e deslocar texturas
Matrizes de projeção: glFrustum(left,right,bottom,top,near,far) glOrtho(left,right,bottom,top,near,far)
gluPerspective(fovy,aspect,zNear,zFar) gluOrtho2D(left,right,bottom,top)
gluLookAt(eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz)
Coordenadas de Tela
glViewport(x, y, width, height)
Transformações:
Modelagem
glTranslate{fd}(x, y, z)
glRotate{fd) (angle, x, y, z ) glScale{fd}(x,y,z)
Propriedades Materiais glMaterial*()
ambiente, difuso, especular Fontes de Luz glLight*() cor, posição, atenuação, etc
Exemplo:
// Estabelece o modo de projeção glMatrixMode(GL_PROJECTION);
// limpa matrizes
glLoadIdentity();
// especifica o Frustum
glFrustum(-1, 1, -1, 1, 0.0, 40.0);
// habilita estado de modelagem glMatrixMode(GL_MODELVIEW);
// cria matriz de transformação glPushMatrix();
// define uma transformação de rotação em X,Y,Z glRotatef(45.0, 1.0, 1.0, 1.0);
render();	// invoca um método do programa glPopMatrix();
Dicas:
Lembre-se que a origem do OpenGL é no canto esquerdo (e é baseado em um sistema de coordenadas left-hand )
Lembre-se de (1) ativar o modo de preenchimento desejado (por ex.: glEnable(GL_DEPTH_TEST);) e de (2) Limpar os respectivos buffers! (por ex.: glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);)
Evitar mudanças constantes de estado
Maior freqüência de erros: posicionamento de câmera. Atente-se para olhar de um ponto e para um ponto que seja coerente com os objetos renderizados.
Dicas:
Ao manipular as matrizes OpenGL lembre-se de verificar se o tipo de matriz correto está ativado.
Por exemplo: glMatrixMode(GL_PROJECTION); glLoadIdentity();
glFrustum(-1, 1, -1, 1, 0.0, 40.0);
/* glMatrixMode(GL_MODELVIEW); */
glPushMatrix(); glRotatef(45.0, 1.0, 1.0, 1.0);
render(); glPopMatrix();
Renderização de textos:
OpenGL não dá nenhum suporte nativo para o tratamento textos e de fontes gráficas. Portanto, o texto não considerado uma “primitiva” ou algo do gênero para ser renderizado.
Deve ser utilizado algum recurso de biblioteca para fazer esta tarefa.
GLUT e SDL possuem métodos para suportar a renderização como uma imagem:
Exemplo GLUT:
//Para posicionar na coordenada (x,y) glRasterPos2f(x,y);
//Chamada GLUT para escrita
glutBitmapCharacter(fonte,*(texto++));
Renderização de textos:
Usado em fonte GL_BITMAP_8_BY_13 GL_BITMAP_9_BY_15 GL_BITMAP_TIMES_ROMAN_10 GL_BITMAP_TIMES_ROMAN_24 GL_BITMAP_HELVETICA_10 GL_BITMAP_HELVETICA_12 GL_BITMAP_HELVETICA_18
Alguns métodos normalmente presentes em programas OpenGL:
init() – inicializiação de variáveis e de estados permanentes.
display() – é que a coisa acontece!! Desenho das primitivas e definição dos estados relacionados a elas, como cor, textura e outros aspectos.
update() – alterações a serem realizadas quando do redimensionamento da janela.
getInputs() – processamento de entradas como teclado e mouse.
Exemplos de código para o método init():
void init(){
glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(50.0, 1.0, -10.0, 7.0); glEnable(GL_LIGHTING);
const float specularColor[]={1.0f,0.0f,1.0f,0.5f};
glLightfv(GL_LIGHT0, GL_SPECULAR, specularColor); glMatrixMode(GL_MODELVIEW);
}
Exemplos de método update():
Exemplos de método display():
Exemplos de método getInputs():
OpenGL
Fake or Real?
Bibliografias
www.opengl.org www.khronos.org
OpenGL Programming Guide (Woo, Neider, Davis - Addison-Wesley ) OpenGL Programming for the X Window
System
OpenGL Game Programming (Astle, Hawkins, LaMothe)
Bibliografias
Red Book
http://fly.cc.fer.hr/~unreal/theredbook/
Tutorial de OpenGL (Português)
http://www.ingleza.com.br/opengl/index.html
Referência (API) para PyOpenGL
http://pyopengl.sourceforge.net/documentation/manual/
Documentação para PyOpenGL
http://pyopengl.sourceforge.net/documentation/index.html
Referência (API) para wxPython
http://www.wxpython.org/onlinedocs.php
Tutorial básico de wxPython
http://www.wxpython.org/tutorial.php
WRIGHT Jr., Richard S.; LIPCHAK,
Benjamin; HAEMEL, Nicholas. OpenGL Superbible: Comprehensive Tutorial and Reference. 4ed.: Addison-Wesley. 2007.
Slides do prof. Dr. Christian Hofsetz. Slides do prof. João Bittencourt
image2.png
image3.jpg
image4.png
image5.png
image6.png
image7.png
image8.png
image9.png
image10.png
image11.png
image12.png
image13.png
image14.jpg
image15.jpg
image16.jpg
image17.png
image18.png
image19.jpg
image20.jpg
image21.jpg
image22.png
image23.jpg
image24.png
image25.png
image26.jpg
image27.jpg
image28.jpg
image29.jpg
image30.png
image31.jpg
image32.jpg
image33.jpg
image34.png
image35.jpg
image36.png
image37.png
image38.png
image39.png