Escolar Documentos
Profissional Documentos
Cultura Documentos
Apostila Básica - OpenGL PDF
Apostila Básica - OpenGL PDF
Dezembro 2003
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
Orientadores:
Dezembro 2003
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
Introduo
Sobre a apostila
Sobre a OpenGL
Apndice
I - A linguagem C
II - Como instalar a OpenGL no Dev C/C++
III - Guia para consultas rpidas (funes mais utilizadas)
IV - Seleo de Sites
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
Introduo
Sobre a apostila
Esta apostila foi desenvolvida pelo grupo de estudos sobre modelagem geomtrica
computacional, apoiado pela UFMG atravs do programa PAD (Programa de Aprimoramento
Discente), como um complemento para o curso oferecido durante a Semana do Conhecimento.
O objetivo deste trabalho capacitar pessoas com um pequeno conhecimento prvio em
programao a, em poucos dias, desenvolver programas simples de computao grfica,
utilizando a biblioteca OpenGL. Devido ao tempo curto proposto para aprendizagem, no ser
dada nfase teoria envolvida nos processos de modelagem. Em vez disso, o tempo ser
integralmente concentrado na parte prtica dos mesmos.
Ao longo da apostila, sero apresentados programas-exemplos ou passagens destes
que usam a teoria explicada, alm de propostas de exerccios utilizando-os. Estes programas
podem ser encontrados no CD-ROM disponvel junto com esta apostila ou pelo site do grupo.
Os exerccios propostos devem ser feitos medida em que forem solicitados pelo palestrante; e
qualquer eventual dvida deve ser enviada para cursodeopenglufmg@yahoogrupos.com.br. O
e-mail ser respondido o mais breve possvel. No se esquea de antes se inscrever na lista,
mandando um e-mail para cursodeopenglufmg-subscribe@yahoogrupos.com.br.
Este material divide-se em cinco captulos subdivididos em tpicos. No primeiro captulo
ser dada a base para a criao de uma janela e um volume (ou plano) de visualizao
adequado. Estes passos so extremamente importantes, pois formam os pilares para a
construo de qualquer programa utilizando o OpenGL.
O captulo dois compreende o assunto de maior nfase dado na apostila: a modelagem
geomtrica. Aps seu estudo, o leitor deve ser capaz de modelar objetos 2D e 3D, tais como
pontos, retas, planos, tringulos, esferas, cubos, paraleleppedos, dentre outros. E ainda:
utilizando estes objetos bsicos e aproveitando as ferramentas que permitem a realizao de
transformaes geomtricas e hierarquia de transformaes, o leitor estar apto a representar
praticamente qualquer cena desejada, tal como uma casa, um carro ou at mesmo estruturas
mais complexas como um rob.
A parte de interao usurio-programa, utilizando a OpenGL e suas bibliotecas
auxiliares, extremamente simplificada, e o captulo trs se encarrega de fornecer informaes
para tal. Alm disso, ser explicada uma forma simples de fazer animao sem depender de
nenhum tipo de interao.
O captulo quatro trata de um recurso utilizado para otimizar o realismo de qualquer
cena: a iluminao. Este assunto de constante pesquisa entre programadores do mundo
inteiro e, de fato, apresenta-se como um diferencial entre os trabalhos de computao grfica.
Ele o ltimo captulo sobre tpicos utilizando a OpenGL e a sua leitura dever ser suficiente
para criar uma iluminao simples em qualquer cena.
Os apndices fornecem suporte para o aprendizado: uma introduo linguagem C, um
guia de como instalar a OpenGL no Dev C++, uma seleo dos melhores sites de OpenGL
encontrados na web (muito importante para quem pretende se aprofundar no assunto), um
guia para consultas rpidas sobre as funes mais utilizadas da OpenGL, GLUT e GLU.
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
Sobre a OpenGL
A OpenGL (Open Graphics Library) foi desenvolvida em 1992 pela Silicon Graphics,
maior empresa de computao grfica e animao em todo o mundo. Por ser uma ferramenta
portvel e rpida, amplamente utilizada na construo de jogos eletrnicos, tal como Counter
Strike, Quake, dentre outros. importante no confundir: OpenGL no uma linguagem de
programao, e sim uma eficiente API (Aplication Programming Interface). Quando se diz que
um programa escrito em OpenGL significa que so feitas uma ou mais chamadas s suas
funes.
A OpenGL considerada uma ferramenta relativamente simples, j que, para se
alcanar a aparncia desejada, preciso apenas determinar os passos que devem ser feitos
para tal finalidade, poupando assim bastante tempo na construo de qualquer programa. Para
isso, so oferecidas vrias primitivas de baixo nvel, sistemas de iluminao, colorao, textura
e diversos outros recursos. J o sistema de gerenciamento de janelas, em nossa apostila, ser
feito pela biblioteca GLUT (OpenGL Utility Toolkit). Alm disso, outra biblioteca ser tambm
incorporada aos nossos programas: a GLU (OpenGL Utility library) por nos fornecer vrias
funes auxiliares, principalmente primitivas grficas como superfcies qudricas e Splines.
Devido s funcionalidades providas pela OpenGL, esta API tem se tornado um padro
largamente utilizado em diversos setores. Possuir rotinas estveis, boa documentao
disponvel e ser de fcil aprendizado s ajudou a concretizar este fato.
A maioria das implementaes, em OpenGL, segue uma ordem de operaes chamada
OpenGL Pipeline. Apesar de no ser uma regra de como a OpenGL implementada, o Pipeline
fornece um guia para entender melhor como e quando a OpenGL realiza suas operaes.
Talvez no fique claro, de princpio, o conceito de Pipeline, muito menos sua aplicao,
mas medida em que as lies forem sendo lecionadas, ser interessante consult-lo.
Abaixo, um esquema muito simples e didtico do Pipeline da OpenGL:
Nem todas as funes seguem exatamente esse formato. Por exemplo, funes que
no recebem parmetros, como "glFlush()", ou que s podem receber um tipo, como
"glClearColor()", no possuem nenhum tipo de referncia aos argumentos.
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
Exemplos:
gl Color 3 f => Color o nome da funo, 3 o nmero de variveis passadas para a
funo e f o tipo de varivel
gl Light fv => Light o nome da funo e fv o tipo de varivel (float vector)
A OpenGL funciona como uma mquina de estado, ou seja, uma parte da memria
reservada para guardar o estado atual das diversas variveis envolvidas no processo de
renderizao. Ento, ao se desenhar algo, todos esses valores armazenados na memria so
usados para sua representao na tela, ou seja, primeiro necessrio fornecer todas as
caractersticas do objeto para s depois desenh-lo. Isto no muito intuitivo de incio, mas sua
praticidade se torna evidente em pouco tempo.
Exemplo: Caso voc queira desenhar um quadrado azul rotacionado de 45 graus, primeiro
necessrio especificar a cor, depois rotacion-lo (ou vice-versa, neste caso a ordem dessas
alteraes no importa) e somente depois desenh-lo efetivamente.
Para o processo de criao de janela, utilizamos a biblioteca GLUT, como j foi dito
anteriormente. A seguir, ser apresentado um trecho, usado para criar a janela, que foi retirado
do primeiro programa exemplo:
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(450, 450);
glutInitWindowPosition(50, 50);
glutCreateWindow("Minha Primeira Janela");
Obs.: Vale lembrar que o GLUT oferece ferramentas extremamente simples e portveis para a
criao de janelas. Para um trabalho mais detalhado e completo, recomenda-se o uso de outras
bibliotecas ou at mesmo o processo de criao de janelas do prprio sistema operacional.
Comandos apresentados:
glutInit(&argc, argv): inicializa o GLUT. Esta chamada tem que vir antes de qualquer outra da
biblioteca GLUT.
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB): determina o sistema de display: o
argumento GLUT_SINGLE significa que estamos usando um buffer simples (buffer duplo pode
ser usado para uma animao, por exemplo, como veremos mais na frente) e GLUT_RGB
siginifica que o sistema de cores ser dado pelo sistema RGB (Fraes de Vermelho, Verde e
Azul, respectivamente).
glutInitWindowSize(450, 450) e glutInitWindowPosition(50, 50): dizemos que nossa janela
ter um tamanho de x=450 e y=450 (comprimento e altura, respectivamente, em pixel) e estar
na posio x=50 e y=50, onde o (0,0) o canto superior esquerdo da tela.
glutCreateWindow("Primitivas OpenGl"): cria uma janela efetivamente com o ttulo
"Primitivas OpenGL". Perceba que primeiro demos todas as coordenadas da janela para s
depois cri-la. Isto porque, como j vimos antes, a OpenGL uma mquina de estado. No
preocupe com os outros comandos ainda. Por enquanto, saber como criar uma janela um
passo bem grande.
Mas, apenas essas funes no so suficientes para se criar uma janela. Perceba que
criamos uma funo INIT(). Nela existe a funo glClearColor (vermelho, verde, azul,
alpha): na qual se define a cor de fundo da janela. importante saber que estes parmetros
devem variar de zero a um e que tal funo apenas define a cor de preenchimento e no
executa tal.
Em seguida temos a funo glutDisplayFunc(funo): responsvel por chamar a
funo DISPLAY(void) a cada vez que o estado da cena alterado. Caso voc no se recorde
da noo de estado, aconselhvel retornar seo anterior.
na funo DISPLAY(void) que esto contidas as informaes necessrias a respeito
da cena e do desenho que ser feito na janela criada. Como explicamos anteriormente, em
OpenGL usamos matrizes para operar sobre nossa cena. Sendo assim, devemos sempre
definir em qual matriz estamos trabalhando e, para isso, existe a funo glMatrixMode(nome
da matriz). Em nosso caso, estamos trabalhando com a GL_PROJECTION, que est
relacionada com tudo aquilo que diz respeito ao volume de visualizao, e a matriz
MODEL_VIEW, que est relacionada com o desenho em si. Muitas vezes, quando
selecionamos uma matriz, necessrio que a multipliquemos pela matriz identidade. O efeito
disso como se estivssemos simplesmente anulando toda a matriz. Isso ficar mais claro em
captulos posteriores. Para usar a matriz identidade, basta chamar a funo glLoadIdentity().
Note que, quando estamos operando sobre a matriz de projeo, definimos nosso
volume de visualizao usando a funo glOrtho(parmetros). Os valores destes parmetros
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
so os da posio de planos em relao origem absoluta do sistema. Tudo aquilo que for
desenhado fora deste volume no ser exibido na tela; portanto, requerida ateno ao se
passar valores ao programa. Em seguida, temos a funo glClear (parmetros), que
responsvel por limpar o fundo da janela. Para tal, necessrio tambm que o parmetro
assuma o valor de GL_CLEAR_BIT.
A ltima funo a ser vista nesta seo a glutMainLoop(). Ela responsvel por
manter todas as funes da GLUT ativas para qualquer mudana de estado ocorrida no
sistema. Ou seja, ela quem gerencia os loops do nosso programa.
No deixe de consultar o apndice de cores ao final desta apostila. Nele, voc
encontrar vrias combinaes de nmeros que geram diferentes cores.
Exerccio:
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-10,10,-10,10,-10,10);
//gluPerspective(45,1,0,15);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glClear(GL_COLOR_BUFFER_BIT);
gluLookAt(0,10,0,0,0,0,1,0,0);
A funo glMatrixMode() define qual matriz ser alterada da pra frente. Se o argumento
passado for GL_PROJECTION, os prximos comandos iro alterar a matriz de projeo. Se for
GL_MODELVIEW, iro alterar a matriz de modelamento e viso. Todos os programas daqui
para frente faro alteraes nessas duas matrizes.
H quatro funes para especificar esse volume, duas da glu e duas da opengl:
*gluOrtho2D (esquerda, direita, baixo, cima): por ltimo, esse comando cria um plano ao
invs de um volume de visualizao. Note que s necessrio passar coordenadas
bidimensionais para a funo. Se um programa no gerar imagens tridimensionais, essa a
melhor maneira de se especificar onde ser renderizada a cena. Por esse motivo, a grande
maioria dos programas daqui pra frente usar esse comando.
Outro ponto importante a ser definido em um programa onde a "cmera" estar e para
onde ela estar apontando. Isso pode ser feito atravs do comando:
Obs.: um cubo, ao ser visto de frente, sem deformao devido distncia, seria visualizado de
que forma? E com a deformao? Verifique os resultados atravs do programa exemplo.
Imagine duas situaes: revelar uma foto num filme 3 por 4 e num filme 3 por 6. O
resultado ter, na segunda situao, uma foto alongada em um dos eixos por uma escala 6/4.
Situao parecida acontece quando redimensionamos a janela em que estamos trabalhando:
analogamente, nosso filme foi redimensionado tambm. Para evitar tais distores, a funo
glutReshapeFunc(Redimensiona) utilizada. Ela avisa ao programa que, ao ser realizada
qualquer alterao na janela criada pela GLUT, a funo Redimensiona() ser chamada. Esta
funo tem que, necessariamente, receber dois inteiros: largura e altura da nova configurao
da tela, respectivamente. A funo abaixo usada para ajustar o volume de visualizao
quando a tela redimensionada.
Para evitar a distoro das imagens quando aumentamos, por exemplo, o comprimento
da janela, devemos provocar uma distoro igual no nosso volume (ou plano) de visualizao.
Veja bem as ltimas linhas da funo abaixo:
Ex.: Suponha que temos um quadrado de lado unitrio dentro de uma janela de tamanho 2 por
2. Ento, redimensionamos a tela para um tamanho 4*2. Se no tiver nenhuma funo para
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
glBegin(parmetros);
glColor3ub(parmetros);
glVertex3f(parmetros);
glEnd();
glBegin(parmetro);
glVertex3f(-600.0, -600.0 , 0.0);
glVertex3f(600.0, -600.0 , 0.0);
glVertex3f(600.0, 600.0 , 0.0);
glVertex3f(-600.0, 600.0 , 0.0);
glEnd();
Tudo o que houver entres eles ser desenhado na janela criada, conforme o
parmetro passado para a funo glBegin().
O que queremos dizer que ser esse parmetro que ir definir quais tipos de primitivas que
sero desenhadas.Tal parmetro pode assumir os seguintes valores:
GL_POINTS, GL_LINES , GL_LINE_LOOP , GL_LINE_STRIP, GL_QUADS,
GL_QUAD_LOOP, GL_QUAD_STRIP, GL_TRIANGLES, GL_TRIANGLE_STRIP,
GL_TRIANGLE_FAN, GL_POLYGON.
Segue-se uma breve descrio de cada uma das primitivas.
GL_POINTS: Cada vrtice tratado como um ponto. O ensimo vrtice define o ensimo ponto.
N pontos so desenhados.
GL_LINES: Cada par de vrtices gera um segmento de linha independente. Vrtices 2n-1 e 2n
definem o segmento de linha n. N/2 linhas so desenhadas.
GL_TRIANGLES: Cada trio de vrtices gera um tringulo independente. Vrtices 3n-2, 3n-1 e
3n definem o tringulo n. N/3 tringulos so desenhados.
Obs.: Para definir o tamanho do ponto a ser desenhado, utilize a funo glPointSize(int
tamanho) e para escolher a espessura da reta, use glLineWidth(int tamanho). Esses dois
valores so dados em pixels.
2.1 - Colorao
Quando estamos trabalhando com a OpenGL desejvel atribuirmos diferentes cores
para os objetos que estamos desenhando. Para tal, temos a funo glColor3ub (vermelho,
verde, azul), como j observado anteriormente. Estes parmetros so valores inteiros que
podem variar de 0 a 255 e, de acordo com a combinao de valores, obteremos uma cor
diferente. Uma forma de se visualizar a combinao dos nmeros seria a de se usar a palheta
de cores disponveis no Windows e no Linux.
Alm de definir a cor, temos tambm que escolher os tipos de efeitos de preenchimento,
utilizando a funo glShadeModel(parmetro). Eles se referem ao modo de preenchimento do
desenho, com a cor que voc determinou. Temos basicamente dois tipos de preenchimento: o
flat e o smooth. O preenchimento flat ir colorir o objeto com a cor corrente, enquanto o
smooth ir fazer um interpolao (degrad) de cores que esto associadas a cada vrtice do
objeto.
Observe o cdigo abaixo:
void INIT(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_SMOOTH);
}
void DISPLAY(void)
{
glBegin(GL_QUADS);
glColor3ub(255, 0, 0);
glVertex3f(-100.0, -100.0 , 0.0);
glColor3ub(255, 255, 0);
glVertex3f(100.0, -100.0 , 0.0);
glColor3ub(0, 255, 0);
glVertex3f(100.0, 100.0 , 0.0);
glColor3ub(0, 0, 255);
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
Logo abaixo, segue uma tabela com algumas combinaes numricas para a obteno
de cores.
Por fim, temos a funo glScalef(fator x, fator y, fator z), que altera a escala dos
eixos conforme o fator multiplicativo fornecido. O resultado o de encolhimento ou de
alongamento das figuras no sentido do(s) eixo(s). Note que, se alguns dos parmetros for 0,
estaremos simplesmente eliminando essa coordenada.
Exerccios
Cubo:
glutWireCube (tamanho da aresta);
glutSolidCube (amanho da aresta);
Cone:
glutWireCone (raio, altura, nmero de planos, fatias horizontais);
glutSolidCone (raio, altura, nmero de planos, fatias horizontais);
Esfera:
glutWireSphere (raio, nmero de planos, fatias horizontais);
glutSolidSphere (raio,nmero de planos, fatias horizontais) ;
Toride (Rosquinha):
glutWireTorus (raio interno, raio externo, nmero de planos, fatias horizontais);
glutSolidTorus (raio interno, raio externo, nmero de planos, fatias horizontais);
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
O que a GLUT faz para gerar essas figuras , na verdade, desenhar uma srie de
planos, aproximando assim para o objeto escolhido. Isso feito a partir dos parmetros nmero
de planos e nmero de fatias; este ltimo divide a figura no determinado nmero de fatias. Para
cada fatia, haver uma quantidade de planos conforme o parmetro nmero de planos.
Sendo assim, se desejarmos, por exemplo, uma esfera bem redonda, iremos necessitar de
passar valores relativamente altos para os parmetros, nmero de planos e fatias horizontais.
Repare que, quanto maior o valor desses parmetros, maior ser o esforo computacional para
ger-los. Portanto, seja prudente. Repare que podemos usar as funes que desenham cones
para criar pirmides. Para isso, basta passarmos o valor trs para o parmetro nmero de
planos. Existem diversas funes para se desenhar outras primitivas como dodecaedros,
porm, elas no so to teis quanto as j apresentadas.
Exerccios
void INIT(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_FLAT);
}
void DISPLAY(void)
{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-800.0, 800.0, -800.0, 800.0, -800.0, 800.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
funodesenhacubocolorido();
glutSwapBuffers();
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
}
void main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(450, 450);
glutInitWindowPosition(50, 50);
glutCreateWindow("Aulas em OpenGL");
INIT();
glutMainLoop();
}
No cdigo acima, foram acrescentados trs novos elementos que permitem fazer a
remoo de superfcies escondidas. Em glutInitDisplayMode(parmetros), acrescentamos
um novo buffer GLUT_DEPTH, que o buffer de profundidade. Ele o principal responsvel
por viabilizar o efeito que desejamos. Alm desta modificao, inclumos tambm a
glEnable(GL_DEPTH_TEST), que habilita o teste de profundidade; e, em
glClear(parmetros), acrescentamos GL_DEPTH_BUFFER_BIT, que faz com que os pixels
do buffer de profundidade assumam a cor definida em glClearColor(parmetros).
Devemos observar que fundamental adicionar esses elementos ao cdigo-fonte
quando estamos trabalhando com uma cena em trs dimenses. Sem a diferenciao da
profundidade dos objetos, a cena ir perder, sem dvida alguma, a sua realidade.
void Inicio(void)
{
glClearColor(1.0,1.0,1.0,1.0);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_DEPTH_TEST);
}
O primeiro argumento de glBlendFunc se refere ao objeto da frente (tomando o
observador como referncia). O argumento GL_SRC_ALPHA significa que o objeto mais
prximo ser responsvel por uma frao igual ao quarto argumento do glColor no clculo total
das cores que sero exibidas na tela. Analogamente, o segundo argumento se refere ao objeto
mais longe e o clculo feito da mesma forma.
Vamos calcular a cor total usada para criar a cena em um ponto onde podemos ver uma
esfera, um octaedro e um prisma, ou seja, as 3 cores se combinam. Comearemos os clculos
de dentro pra fora. A esfera azul no interior totalmente opaca, no tem transparncia. Por
isso, 100% da sua cor ser levada em conta nos clculos abaixo. Como o octaedro tem
alpha=0.2, apenas 20% da sua cor utilizada nos clculos: 0.2 * (0,1,0) = (0,0.2,0). Os outros
80% so ditados pelo esfera no interior, ou seja, 0.8 * (0,0,1) = (0,0,0.8). Logo, a cor total
calculada, at agora, vale: (0,0.2,0) + (0,0,0.8) = (0,0.2,0.8). Como o paraleleppedo verde tem
alpha=0.2 tambm, apenas 20% da sua cor utilizada nos clculos: 0.2 * (0,1,0) = (0,0.2,0).
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
Novamente, 80% das cores dependem dos objetos em seu interior. Logo, a cor final calculada
vale: (0,0.2,0) + 0.8(0,0.2,0.8) = (0,0.36,0.64).
Este um exemplo simples de transparncia. So apenas 3 elementos compondo uma
cena esttica. Neste caso, importante desenhar SEMPRE os objetos opacos primeiro.
Tomando este cuidado, garantimos que nossa cena ter o resultado desejado.
Obs.: importante lembrar de ativar o clculo de transparncia, atravs de
glEnable(GL_BLEND).
Exerccios
medida em que nossas cenas vo ganhando mais e mais elementos, se torna rduo o
processo de determinarmos a posio de todos eles no espao. Mas isso s ocorre se no
utilizarmos uma importante ferramenta da OpenGL.
Para ficar mais claro, partiremos de um exemplo: suponha um prdio qualquer onde
existem vrios andares, salas, e dentro delas, mveis. Em vez de especificar as coordenadas
de uma cadeira qualquer do prdio em relao a uma origem absoluta, como a porta de entrada
do prdio, mais conveniente e sistemtico fornecer as coordenadas em relao ao cmodo
em que ela se encontra. Este, por sua vez, tem suas coordenadas em relao ao andar no qual
se encontra, cuja posio determinada usando a origem absoluta. este tipo de organizao
que utilizamos para facilitar o desenho de um sistema complexo.
Outra aplicao bastante interessante o modelamento de uma estrutura com alguns
eixos articulados, como um brao de rob. Olhando o programa exemplo dessa seo,
percebemos que essa hierarquia feita atravs da disposio correta das funes
glPushMatrix() e glPopMatrix(). A grosso modo, essas funes servem, respectivamente,
para salvar e carregar o estado atual da matriz de transformao. Logo abaixo, temos um
exemplo genrico de como trabalhamos com os pares de funes glPushMatrix() e
glPopMatrix():
void Display(void)
{
glRotatef(ngulo, 0.0, 0.0, 1.0);
glPushMatrix();
glTranslatef(deslocamento_x, deslocamento_y, 0.0);
...
desenhos-1
...
glPopMatrix();
...
desenhos-2
...
}
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
//Desenhando o Retngulo 3
glPushMatrix(); //Salvando estado atual de transformaes
glColor3ub(100,100,100);
glTranslatef(10, 0, 0);
glRotatef(rotacao_retangulo_3+45, 0, 0, 1);
Retangulo(10,4);
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
//Desenhando o Retngulo 4
glPushMatrix(); //Salvando estado atual de transformaes
glColor3ub(100,100,100);
glTranslatef(10, 0, 0);
glRotatef(rotacao_retangulo_4-45, 0, 0, 1);
Retangulo(10,4);
glPopMatrix();//Carregando estado de transformao do PushMatrix
correspondente(retngulo4)
glPopMatrix();//Carregando estado de transformao do PushMatrix correspondente(retngulo
2)
Essas funes, assim como o glBegin e glEnd, funcionam aos pares. Para evitar
erros, sempre tenha um PopMatrix para cada PushMatrix.
A hierarquia deste programa funciona da seguinte forma: rotacionando o retngulo 1
(alterando o valor do float rotacao_retangulo_1), todos os outros so rotacionados juntos, com o
eixo de rotao na origem dele. Rotacionando o retngulo 2, os de hierarquia maior so
rotacionados juntos e assim por diante. A cor do retngulo indica sua hierarquia (quanto maior,
mais escuro). Segue um pequeno esquema da hierarquia no programa exemplo.
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
GLfloat angulox=0.0;
void DISPLAY()
{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-80.0, 80.0, -80.0, 80.0, -80.0, 80.0)
glRotatef(angulox,1.0, 0.0, 0.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
....
}
void KEYBOARD(unsigned char tecla, int x, int y)
{
switch(tecla)
{
case 'x':
angulox=angulox+5.0;
if(angulox > 360.0)
angulox=angulox-360.0;
glutPostRedisplay();
break;
default;
break;
}
}
void main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize(450, 450);
glutInitWindowPosition(50, 50);
glutCreateWindow("Aula sobre OpenGL");
INIT();
glutKeyboardFunc(KEYBOARD);
glMainLoop();
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
}
Repare que dentro de "main" temos a funo "glutKeyboardFunc(nome da funo
com as condies de interao)". Esta funo responsvel por monitorar todo o teclado,
excetuando o teclado numrico e certas teclas especiais como as setas. Toda vez em que o
usurio pressiona uma tecla, a "glutKeyboardFunc" ir passar para a funo " KEYBOARD" trs
parmetros, dentre eles o "boto". Com esse parmetro, podemos ativar determinadas aes
sobre nossa cena. No nosso caso, estamos rotacionando nosso volume de visualizao atravs
do incremento de uma varivel global que est associada a um "glRotatef", operando sobre a
matriz de projeo. Enquanto a tecla x estiver pressionada, a varivel angulox ser
incrementada e conseqentemente o volume de visualizao ser rotacionado. Para que isso
possa ser visto na tela do computador imediatamente, necessrio que chamemos a funo
glutPostRedisplay(), ela responsvel por redesenhar a cena toda vez que x for
pressionado.
void DISPLAY()
{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-80.0, 80.0, -80.0, 80.0, -80.0, 80.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
....
....
}
void MOUSE(unsigned char tecla, int estado, int x, int y)
{
switch (tecla)
{
case GLUT_LEFT_BUTTON:
if (estato == GLUT_DOWN)
funo qualquer;
glutPostRedisplay();
break;
case GLUT_MIDDLE_BUTTON:
if (estado == GLUT_DOWN)
funo qualquer;
glutPostRedisplay();
break;
case GLUT_RIGTH_BUTTON:
if (estado == GLUT_UP)
funo qualquer;
glutPostRedisplay();
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
break;
default:
break;
}
}
void main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize(450, 450);
glutInitWindowPosition(50, 50);
glutCreateWindow("Aula sobre OpenGL");
INIT();
glutMouseFunc(MOUSE);
glMainLoop();
}
3.2 Animao
Um dos objetivos da computao grfica , sem dvida, gerar animaes e simulaes
que seriam muito difceis, ou at mesmo impossveis, na vida real. Com as duas ferramentas
apresentadas anteriormente, demos um grande passo para podermos criar animaes
controladas. Vejamos agora como poderamos criar uma cena com animao um pouco mais
automatizada.
A idia basicamente a mesma: ser necessrio escrevermos uma funo na qual ser
incrementada uma varivel qualquer, sendo que esta estar associada a uma transformao
geomtrica, ou fraes do RGB, etc. Vejamos um trecho ilustrativo de um cdigo fonte,
semelhante ao anterior.
void ANIME()
{
angulox=angulox+5.0;
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
default:
break;
}
Exerccio
1 Estude o mdulo de animao, ele semelhante ao cdigo exemplo desta seo, logo
aps execute o programa.
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
At = Al*Am
Dt = Dl*Dm
Et = [El*Em]^sh
At = (Al1+Al2...+Aln)*Am
Dt = (Dl1+Dl2...+Dln)*Dm
Et = [(El1+El2...+Eln)*Em]^sh
Aps definir todos os vetores, iremos associar cada propriedade com seu respectivo
valor.
No caso das propriedades do material, a linha de comando tem a forma:
gl + Material + {tipo de varvel} {forma vetorial}, e os argumentos so, respectivamente:
(face a ser renderizada, propriedade, *valores).
glBegin(GL_TRIANGLES);
glNormal3f(0,1,0);
glVertex3f(0,0,0);
glVertex3f(1,0,0);
glVertex3f(0,0,1);
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
glEnd();
Um tringulo foi desenhado no plano y=0, portanto, sua normal (0,1,0). Caso a normal
passada fosse no unitria, a luz teria um comportamento imprevisvel. Para evitar esse tipo de
erro, a funo glEnable tendo como argumento GL_NORMALIZE normaliza automaticamente
seu vetor. No necessrio especificar as normais das primitivas da GLUT e da GLU: elas j
esto devidamente calculadas.
possvel passar as propriedades do material de uma forma mais rpida e barata,
utilizando a funo glColor3f(). Para isso, temos que inserir a linha
glEnable(GL_COLOR_MATERIAL). Assim, quando escolhemos a cor do objeto, na verdade,
estamos definindo as propriedades difusa e ambiente de seu material. Se quisermos alterar
outras propriedades atravs do glColor, devemos colocar, antes do Enable, a funo
glColorMaterial(face do objeto, propriedade(s) da luz). Por exemplo, se colocarmos
glColorMaterial(GL_FRONT_AND_BACK, GL_SPECULAR), a propriedade a ser alterada
atravs do comando glColor3f() a especular, ao invs das definidas por default.
importante ressaltar que o plano (S,T) no est diretamente relacionado com as faces
do polgono ou prisma a ser desenhado, pois essas ltimas dependem de trs coordenadas
(x,y,z). Na verdade, o que o OpenGL faz uma correspondncia entre as coordenadas da
textura mapeada e as coordenadas da face, aplicando os dados de cor em pontos no espao
com coordenadas (x,y,z).
Para isso, basta fornecer a correspondncia entre os vrtices da imagem de textura e do
polgono; tudo o que for delimitado por esses vrtices ser mapeado no plano de textura e ter
uma imagem na face delimitada do polgono. Caso a face em questo corte
perpendicularmente um dos eixos coordenados, a figura geomtrica possui uma das
coordenadas da face constante. Logo, para descrever essa face (seu formato, dimenso, etc.)
precisamos conhecer as outras duas coordenadas dos vrtices e verificar a figura geomtrica
determinada no plano por esses vrtices. O polgono que delimita a textura mapeada deve
possuir a mesma forma da figura geomtrica da face, para que ocorra perfeita correspondncia
entre a imagem mapeada e seu local de aplicao. Do contrrio, seria como aplicar uma
imagem quadrada em um trapzio sem que haja deformao da imagem. Intuitivamente
percebe-se que isso impossvel!
Por exemplo, se queremos aplicar os tijolos acima em um retngulo, podemos fornecer a
seguinte correspondncia:
glTexCoord2f(0.0,0.0);glVertex3f(-40.0,-10.0,0.0);
glTexCoord2f(1.0,0.0);glVertex3f(40.0,-10.0,0.0);
glTexCoord2f(1.0,1.0);glVertex3f(40.0,10.0,0.0);
glTexCoord2f(0.0,1.0);glVertex3f(-40.0,10.0,0.0);
Suponha, inicialmente, que um dos dado de cor da textura (texel) utilize exatamente um
pixel na imagem desenhada. Sendo assim, imaginando a textura como formada por uma
seqncia de pontos de cor (texels) e a imagem desenhada no monitor como um conjunto de
pixels, nesse caso a correspondncia entre as dimenses da imagem de textura e da imagem
desenhada seria perfeita e no ocorreria deformao. Mas, e se queremos diminuir a imagem
desenhada, ou mesmo ampli-la? Veja pelo diagrama anterior que quando aumentamos uma
imagem, como se dispusssemos de uma lupa, uma pequena parte de um texel preencheria
totalmente um pixel, para que assim a imagem se magnifique. O contrrio vlido para a
minificao. O OpenGL realiza clculos para estimar qual seria o melhor dado de cor a ser
aplicado no pixel. Pode ser uma mdia ponderada dos texels que esto ocupando uma posio
de correspondncia mais prxima ao centro do pixel em questo (GL_LINEAR) ou
simplesmente o texel mais prximo do centro do pixel (GL_NEAREST). Dependendo da
situao, podemos escolher entre velocidade de processamento ou qualidade da imagem.
Para que a carga de uma imagem .raw genrica funcione, fornea corretamente as
dimenses da figura (largura e altura) na funo Carregador_de_RAW. No caso, os valores
para a figura tijolo.raw j esto ajustados. A dimenso profundidade, normalmente, assume o
valor trs e relevante apenas para a carga. Um valor menor do que trs deforma a figura.
Faa as seguintes alteraes no projeto:
Observe que a parede se ajusta. Quando utilizado um scale, por um fator maior do que 1,
na matriz de textura, a rea mapeada excede o quadrado unitrio. O que o OpenGL coloca fora
desse quadrado? Se as constantes GL_CLAMP esto acionadas para ambos os eixos S e T, a
ltima fileira de dados de cor, tanto horizontal quanto vertical da textura, se repete ao longo do
plano (S,T). Foi essa informao que mapeamos e enviamos ao polgono.
GLuint vetor_de_texturas[2] recebe dois inteiros que, cada um, identificam a imagem a
ser utilizada. A constante TOTAL_DE_TEXTURAS identifica o nmero de texturas
possveis de serem habilitadas.
Comparando com o programa anterior, a chamada para Carregador_de_RAW foi
generalizada, para que vrias imagens possam ser carregadas por essa funo. Um
inteiro adicional identifica a linha "ocupada" pela textura no vetor_de_texturas[].
A funo glGenTextures atribui textura um valor inteiro que a identifica. Ela recebe
como parmetros o nmero total de texturas a serem habilitadas e, alm disso, guarda
no vetor_de_texturas[] o inteiro correspondente quela imagem.
glBindTexture efetivamente cria a imagem de textura com os atributos determinados
(modo de aplicao, filtros, mipmaps, etc.).
Essa figura descreve a relao entre as coordenadas de textura (S,T) e os vrtices das
faces aproximadas do cilindro (x,y,z).
Por fim, destaca-se o uso da funo gluBuild2DMipmaps(), que racionaliza o custo
computacional ao utilizar um maior nmero de bytes para pontos da imagem mais prximos do
observador, diminuindo gradativamente o nmero de bytes associados com imagens reduzidas,
ou seja, mais distantes do observador. Os filtros de minificao associados ao mipmaps seriam:
GL_LINEAR_MIPMAP_LINEAR;
GL_LINEAR_MIPMAP_NEAREST;
GL_NEAREST_MIPMAP_NEAREST;
GL_NEAREST_MIPMAP_LINEAR
Esses filtros determinam o modo de transio entre regies da imagem que utilizam maiores e
menores valores de bytes de cor. A transio entre essas regies pode ser suavizada com a
chamada LINEAR ao final da constante, resultando em uma imagem "smooth".
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
Para transformar nossa antiga rvore seca numa rvore verdinha, cheia de folhas, basta
um processo bem simples. A adio de adereos pode ser feita apenas com a adio de uma
estrutura condicional que testa o tamanho do galho atual. Nesta rvore o tamanho do galho
atual comparado com o tamanho do galho menor multiplicado por dois. Quando o galho atual
j menor ou igual ao menor feita algumas transformaes para desalinhar as folhas e, em
seguida, chamada a funo que faz a folha. As folhas em desalinho conferem um aspecto
mais natural figura. A folha provm da funo Folha definida previamente atravs de um
conjunto de pontos dispostos num triagle_fan.
O mesmo processo poder ser feito para outros fractais comparando os valores que
determinam a condio de parada, ou algum outro parmetro do fractal que alterado de
acordo com o andamento das iteraes. Efeitos de mudana de cor, textura, etc, podem ser
obtidos desta maneira.
Atribuindo ento um valor para a varivel aleatria, comparamos seu valor com 0,1. Se a
varivel maior ento se faz a nova chamada da funo.
Essa mesma varivel poderia ser introduzida para termos uma variao aleatria do
tamanho do galho da nova chamada, da inclinao de cada galho, etc... possibilitando obter no
final um fractal totalmente aleatrio.
importante ressaltar que o OPEN_GL realiza os clculos de renderizao da cena toda
vez que h uma alterao de estado, e a funo glutDisplayFunc() chamada para redesenhar
a cena. Movimento da posio do observador, maximizao da janela, alterao no tamanho da
janela, pressionamento de teclas do mouse ou teclado quando usando as funes de interao,
caracterizam mudanas de estado. Quando os clculos so refeitos os valores da varivel
aleatria sero diferentes do anterior e uma figura diferente gerada a cada mudana de
estado. Para contornar esse problema utilizada a semente. A semente um valor inicial que a
varivel aleatria assume e a partir dela calcula os demais valores, assim a seqncia de
valores aleatrios sempre a mesma a partir de quando dada essa semente. Ento, para
evitar o problema proposto anteriormente, devemos atribuir uma semente antes da chamada da
funo que desenha o fractal utilizando valores aleatrios. Desta forma a figura desenhada
sempre a mesma no importando a mudana de estado. A figura ter uma relao
determinstica com a semente, para cada semente uma figura diferente. Experimente retirar a
semente e faa mudanas de estado, observe o resultado, divertido...
Apndices
I - A linguagem C/C++
Como j dito a biblioteca OpenGL, assim como suas auxiliares, so implementadas
utilizando a linguagem C. Sendo assim, muito conveniente que voc escreva o seu programa
utilizando C ou C++. O propsito deste apndice, o de fornecer apenas a sintaxe de algumas
estruturas lgicas bsicas destas linguagens.
Declarao de variveis
Estruturas condicionais
if(teste)
{
....
aes
.....
}
if(teste)
{
....
aes
.....
}
else if(teste)
{
....
aes
.....
}
else
{
....
aes
}
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
Estruturas de repetio
Enquanto:
Faa enquanto:
do
{
....
aes
.....
}while(condio de parada - teste)
Repetio composta:
cin>>nome_da_varivel;
cout<<sua frase<<nome_da_varivel;
Para mais informaes sobre a linguagem C/C++ consulte nosso site, l esto
disponveis diversos links.
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
Nesta seo apresentam-se algumas das funes OpenGL (incluindo GLUT) utilizadas
nos programas de exemplo:
glutInitWindowPosition(0, 0);
glutInitWindowSize(500, 500);
...
#define GLUT_RGB
#define GLUT_RGBA
#define GLUT_INDEX
#define GLUT_SINGLE
#define GLUT_DOUBLE
#define GLUT_DEPTH
void glutInitDisplayMode(unsigned int mode);
Indica o modo de apresentao a utilizar. RGA, RGBA, INDEX: modo de cor, SINGLE,
DOUBLE: utilizao de buffer para animao, DEPTH: utilizao de Z buffer.
void glutMainLoop(void);
Entra no ciclo principal de execuo da GLUT. A partir deste momento feita a interao com o
usurio e sero chamadas as funes de usurio respectivas.
glutMainLoop();
glutCreateWindow("Color Cube");
void glutSwapBuffers(void);
Troca o buffer utilizado (para animao).
glutSwapBuffers();
#define GLUT_BITMAP_9_BY_15
#define GLUT_BITMAP_8_BY_13
#define GLUT_BITMAP_TIMES_ROMAN_10
#define GLUT_BITMAP_TIMES_ROMAN_24
#define GLUT_BITMAP_HELVETICA_10
#define GLUT_BITMAP_HELVETICA_12
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
#define GLUT_BITMAP_HELVETICA_18
void glutBitmapCharacter(void *font, int character);
Permite desenhar texto com fonte de mapa de bits. A posio automaticamente atualizada.
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, 'A');
#define GL_COLOR_BUFFER_BIT
#define GL_DEPTH_BUFFER_BIT
#define GL_ACCUM_BUFFER_BIT
#define GL_STENCIL_BUFFER_BIT
void glClear (GLbitfield mask);
Limpa buffers.
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
void glFlush(void);
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
Obriga o OpenGL a completar todas as operaes pendentes. glFlush(...) deve ser chamada
quando necessrio garantir que a imagem est completamente definida na tela, por exemplo
antes de aguardar por entrada do usurio.
glFlush();
glPushMatrix();
glScalef(1.0,5.0,3.0);
gluWireCube(1.0);
glPopMatrix();
void glOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top,
GLdouble near, GLdouble far );
Define a rea de visualizao para uma projeo ortogonal. De notar que os parmetros near e
far so indicados relativamente ao usurio, ou seja near deve ser menor que far. Os
parmetros left, right, top e bottom devem ter em conta as dimenses atuais do viewport
utilizado para que as imagens no apaream distorcidas. Todos os objetos, ou sees dos
mesmos, fora do volume de visualizao indicado no so apresentadas na janela.
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= h)
glOrtho(-2.0, 2.0, -2.0 * (GLfloat) h / (GLfloat) w, 2.0 * (GLfloat) h / (GLfloat) w, -10.0, 10.0);
else
glOrtho(-2.0 * (GLfloat) w / (GLfloat) h, 2.0 * (GLfloat) w / (GLfloat) h, -2.0, 2.0, -10.0, 10.0);
glMatrixMode(GL_MODELVIEW);
void glFrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top,
GLdouble znear, GLdouble zfar );
Permite definir uma perspectiva. Os parmetros left, right, top, bottom e znear definem a rea
de visualizao mais prxima do observador, o parmetros zfar define o plano de corte mais
distante. De notar que tanto znear como zfar tem de ser maiores que zero. Da mesma forma
que glOrtho, estes parmetros so indicados relativamente ao observador.
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= h)
glFrustum(-2.0, 2.0, -2.0 * (GLfloat) h / (GLfloat) w, 2.0 * (GLfloat) h / (GLfloat) w, 10.0, 30.0);
else
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
glFrustum(-2.0 * (GLfloat) w / (GLfloat) h, 2.0 * (GLfloat) w / (GLfloat) h, -2.0, 2.0, 10.0, 30.0);
glTranslatef(0.0, 0.0, -20.0);
glMatrixMode(GL_MODELVIEW);
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= h)
gluPerspective(90.0 * (GLfloat) h / (GLfloat) w, (GLfloat) w / (GLfloat) h, 10.0, 30.0);
else
gluPerspective(90.0, (GLfloat) w / (GLfloat) h, 10.0, 30.0);
glTranslatef(0.0, 0.0, -20.0);
glMatrixMode(GL_MODELVIEW);
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION); >
glLoadIdentity();
if (w <= h)
gluPerspective(90.0 * (GLfloat) h / (GLfloat) w, (GLfloat) w / (GLfloat) h, 10.0, 30.0);
else
gluPerspective(90.0, (GLfloat) w / (GLfloat) h, 10.0, 30.0);
gluLookAt(0.0, 0.0, -20.0, 0.0, 6.0, -20.0, 0.0, 0.0, -1.0);
glTranslatef(0.0, 0.0, -20.0);
glMatrixMode(GL_MODELVIEW);
glScalef(2.0,1.0,1.0);
glTranslatef(1.5,2.0,0.0);
IV Seleo de Sites
Esta seo oferece uma seleo dos considerados melhores sites para se aprender
OpenGL. Os assuntos abordados vo desde um curso de C (necessrio para o entendimento
dos cdigos) at a criao de jogos em primeira pessoa. importante ressaltar a importncia
dessa parte da apostila para a continuidade dos estudos aps o curso.
01) Site oficial do OpenGL. L voc encontra diversos materiais para download,
alm das ltimas notcias sobre o programa.
http://www.opengl.org
Idioma: Ingls
Classificao: *****
02) Site do curso de C oferecido pela EE UFMG. Muito bom para se aprender a linguagem
utilizada em toda a apostila.
http://www.ead.eee.ufmg.br/cursos/C/
Idioma: Portugus
Classificao: *****
http://www.inf.pucrs.br/~manssour/OpenGL/index.html
Biblioteca: GLUT
Idioma: Portugus
Classificao: ****
http://dca.ufrn.br/~ambj/ele435/opengl/index.html
Biblioteca: GLUT
Idioma: Portugus
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
Classificao: ***
05) Site de outro professor da PUC RS. No possui um contedo muito abrangente, mas
os assuntos que so tratados so abordados de forma muito clara e objetiva. Alm disso,
oferece uma grande ajuda na hora de instalar as bibliotecas utilizadas.
http://www.inf.pucrs.br/~pinho/CG/Aulas/OpenGL/Transparencias/Transparencias.html
Biblioteca: GLUT
Idioma: Portugus
Classificao: ****
06) Mais um timo site para iniciantes. Trata o OpenGL de forma clara,
dando tpicos sobre os clculos envolvidos nas chamadas das funes.
A parte de projeo e luz muito bem explicada.
http://www.comp.ufla.br/~bruno/aulas/cg/monte-mor/44.htm
Biblioteca: GLUT
Idioma: Portugus
Classificao: *****
07) Este site d uma breve explicao sobre alguns assuntos, como projees e
transformaes geomtricas.
http://www.cesec.ufpr.br/~mcunha/opengl/opengl00.html
Biblioteca: GLAUX
Idioma: Portugus
Classificao: *
08) Este endereo nos fornece vrios tutoriais para iniciantes, alm do link para
baixar um excelente livro em formato .pdf que ensina, passo-a-passo a modelagem de um
ser humano caminhando.
http://www.dev-gallery.com/programming/
Biblioteca: GLUT
Idioma: Ingls
Classificao: *****
09) Site com 14 sees sobre OpenGL. Sua nfase luz, volume de visualizao e outros
recursos grficos. Infelizmente, utiliza o tk ao invs do GLUT, mas nada que atrapalhe a
didtica significantemente.
http://www.eecs.tulane.edu/www/Terry/OpenGL/Introduction.html
Biblioteca: tk
Idioma: Ingls
Classificao: **
http://nehe.gamedev.net/
Biblioteca: GLAUX
Idioma: Ingls
Classificao: *****
http://www.inf.ufsc.br/~awangenh/CG/apostilas/openGL/opengl3D.html
Biblioteca: GLUT/GLAUX
Idioma: Portugus/Ingls
Classificao: ***
http://www.unidev.com.br/
Biblioteca: GLUT
Idioma: Portugus
Classificao: *****
http://www.gametutorials.com/Tutorials/opengl/OpenGL_Pg1.htm
Biblioteca: sem biblioteca auxiliar para gerenciamento de janelas.
Idioma: Ingls
Classificao: *****
Downloads
14) Este endereo nos leva a uma pgina que permite o download de um
.zip. Este arquivo contm 7 executveis que ajudam na
vizualizao de algumas das propriedades seguintes: neblina, posio
e propriedades da luz, propriedade do material, projees,
transformaes, texturas e formas (primitivas OpenGL).
http://www.xmission.com/~nate/tutors.html
Idioma: Ingls
Classificao: *****
15) Um dos sites mais importantes, j que disponibiliza o RedBook tanto para download
Programa de Aprimoramento Discente em Modelagem Geomtrica - Curso de OpenGL
quanto para consulta online. Pena que ainda utiliza o GLAUX (adicionando o biblioteca
GLUT, retirando a GLAUX e alterando 3 linhas do main, concertamos este "problema").
http://fly.cc.fer.hr/~unreal/theredbook/
Biblioteca: GLAUX
Idioma: Ingls
Classificao: ****
Sites Tericos
16) Este site, essencialmente terico, explica atravs de equaes e exemplos vrios
dos recursos grficos possveis no OpenGL. Pena que no tem nenhum exemplo ou referncia
a ele. Ainda assim, este tutorial um recurso importante para improvisar o realismo
usando qualquer programa de computao grfica.
http://www.directnet.com.br/users/val/tutor/tutor.html
Idioma: Portugus
Classificao: ***
Consultas Rpidas
17) Oferece um guia para consultas rpidas das funes mais utilizadas
no OpenGL, GLUT e GLU.
http://www.dei.isep.ipp.pt/cg/opengl/
Biblioteca: GLUT
Idioma: Portugus
Classificao: ***
18) Outro guia para consultas rpidas. Este, ao contrrio do anterior, extremamente
completo, contendo mais de 100 funes do OpenGL (o que representa quase todas
elas) bem explicadas alm de vrios comandos Glu. No oferece material para GLUT.
http://www.deec.uc.pt/~peixoto/dcg/opengl/opengl.html
Biblioteca: sem GLUT
Idioma: Ingls
Classificao: ****