Escolar Documentos
Profissional Documentos
Cultura Documentos
REQUISITOS.................................................................................................................................................... 6
PARA A ESCOLA .............................................................................................................................................. 6
PARA O ALUNO................................................................................................................................................ 7
AULA 01 ............................................................................................................................................................ 8
PORQU QT ..................................................................................................................................................... 8
OS EXEMPLOS: CGMAZE ................................................................................................................................ 8
OS EXEMPLOS: NEHE ...................................................................................................................................... 9
COMPILAR UM PROJECTO QT .......................................................................................................................... 9
REVISES DE MATEMTICA: VECTORES ...................................................................................................... 10
REVISES DE MATEMTICA: PRODUTO DE MATRIZES ................................................................................. 11
REVISES DE MATEMTICA: TRIGONOMETRIA ............................................................................................ 12
EXERCCIOS .................................................................................................................................................. 12
AULA 02 .......................................................................................................................................................... 15
ECRS CRT .................................................................................................................................................. 15
CONCEITOS BSICOS OPENGL: SISTEMA DE COORDENADAS ........................................................................ 16
JANELAS E VIEWPORTS ................................................................................................................................... 16
PRIMITIVAS 2D ............................................................................................................................................. 17
ANTI-ALIASING E CLEARTYPE ........................................................................................................................ 19
EXERCCIO .................................................................................................................................................... 20
AULA 03 .......................................................................................................................................................... 21
3D ................................................................................................................................................................. 21
SISTEMA DE COORDENADAS 3D .................................................................................................................... 21
PRIMITIVAS 3D ............................................................................................................................................. 21
MATRIZ DE TRANSFORMAO ...................................................................................................................... 22
TRANSLAO DE COORDENADAS.................................................................................................................. 22
REDIMENSIONAMENTO DE COORDENADAS ................................................................................................... 23
ROTAO DE COORDENADAS........................................................................................................................ 23
COMPOSIO DE TRANSFORMAES ............................................................................................................ 26
USO DAS TRANSFORMAES EM OPENGL .................................................................................................... 27
TRANSFORMAES PARA COLOCAO DE CMARA NA CENA ...................................................................... 27
ANIMAO: DOUBLE-BUFFERING .................................................................................................................. 28
ANIMAO: TEMPORIZAO ........................................................................................................................ 29
EXERCCIOS .................................................................................................................................................. 30
AULA 04 .......................................................................................................................................................... 32
PROJECES ................................................................................................................................................. 32
PROJECES EM OPENGL ............................................................................................................................. 33
MATRIZES DE PROJECO ............................................................................................................................. 34
EXERCCIOS .................................................................................................................................................. 35
AULA 05 .......................................................................................................................................................... 37
EXERCCIO: DESENHAR A VISTA INTERIOR DO LABIRINTO ............................................................................ 37
AULA 06 .......................................................................................................................................................... 41
REPRESENTAO DE OBJECTOS SLIDOS ...................................................................................................... 41
CLCULO DE VISIBILIDADE ........................................................................................................................... 41
TRANSPARNCIA E OPACIDADE..................................................................................................................... 44
EXERCCIOS .................................................................................................................................................. 45
AULA 07 .......................................................................................................................................................... 46
O QUE A COR .............................................................................................................................................. 46
PERCEPO DE COR PELO OLHO HUMANO..................................................................................................... 47
GERAO DE COR ......................................................................................................................................... 47
COR EM OPENGL .......................................................................................................................................... 48
TEXTURAS .................................................................................................................................................... 49
EXERCCIOS .................................................................................................................................................. 51
AULA 08 .......................................................................................................................................................... 53
ILUMINAO ................................................................................................................................................. 53
ILUMINAO: MATERIAIS DOS OBJECTOS ..................................................................................................... 55
ILUMINAO: NORMAIS ............................................................................................................................... 57
EXERCCIOS .................................................................................................................................................. 58
AULA 09 .......................................................................................................................................................... 59
MODELOS 3D EM FICHEIROS ......................................................................................................................... 59
FSICA ........................................................................................................................................................... 60
DETECO DE MOVIMENTO HUMANO ........................................................................................................... 60
DESENHAR A VISTA INTERIOR DO LABIRINTO EM 3D .................................................................................... 60
EXERCCIOS .................................................................................................................................................. 62
AULA 10 .......................................................................................................................................................... 64
RAY TRACING ................................................................................................................................................. 64
FRACTAIS ...................................................................................................................................................... 65
SISTEMAS DE PARTCULAS ............................................................................................................................ 67
PROJECTO ..................................................................................................................................................... 69
EXERCCIOS .................................................................................................................................................. 69
BIBLIOGRAFIA ............................................................................................................................................ 70
Requisitos
Para a escola
Requisitos para as salas das aulas prticas de Computao Grfica
pg. 6
Para o aluno
Comparncia nas aulas. Este guio tem propositadamente omissos certos
elementos importantes para a compreenso total da matria (notas histricas,
relaes entre partes diferentes da matria, avisos sobre erros comuns, etc., ou
seja, elementos para uma nota 20), embora seja suficiente para passar com nota
bastante acima de 10.
Deves ter instalado o Qt SDK em computador prprio se quiseres acompanhar a
matria em casa. V a seco acima para requisitos e a primeira aula para
instrues de instalao. No no entanto de todo necessrio que tenhas estes
sistemas em casa para conseguires passar cadeira (podes us-los na escola).
Esta cadeira assume que j tens experincia no uso de computadores (no
necessariamente no Qt SDK) e em programao C ou C++.
pg. 7
Aula 01
Introduo e contextualizao:
O Qt e o seu SDK
Revises de Matemtica.
Hiperligaes.
Porqu Qt
As aulas prticas de Computao Grfica vo ser sobre programao com OpenGL
em ambiente grfico de sistemas operativos modernos com a framework Qt
(pronuncia-se cute). Existem duas razes para isto:
1. OpenGL uma das principais normas para desenho de grficos
tridimensionais (e tambm, em menor importncia, 2D), juntamente com
o Direct3D da Microsoft. Mas ao contrrio do segundo, OpenGL uma
norma aberta suportada universalmente. Podes ver mais informaes
(razoavelmente isentas) sobre a comparao entre ambos na Wikipedia (em
Ingls):
http://en.wikipedia.org/wiki/Comparison_of_OpenGL_and_Direct3D
Os exemplos: CGMaze
CGMaze uma aplicao desenvolvida especificamente para apoio a estas aulas.
Trata-se de um jogo de labirinto que permite ao jogador entrar no labirinto e
passear por ele com vista na 1 pessoa.
pg. 8
O cdigo-fonte do jogo -te dado, com excepo de alguns ficheiros que ters de
ser tu a completar e/ou acompanhar nas aulas. Estes ficheiros foram preparados
para esconderem os detalhes Qt do cdigo OpenGL em si, de forma a poderes
concentrar-te no que mais interessa cadeira.
Os exemplos: NeHe
Vamos tambm estar a usar alguns tutoriais de OpenGL do site Neon Helium
Productions (NeHe). Podes consult-los em: http://nehe.gamedev.net/
Estes exemplos esto preparados para Windows (e Visual Studio), mas foram
convertidos para a framework Qt no captulo 14 do Independent Qt Tutorial em
http://www.digitalfanatics.org/projects/qt_tutorial/.
O cdigo est disponvel para ser descarregado no site do professor, j com as
correces para a ltima verso do Qt que estamos a usar.
Compilar um projecto Qt
Arranca o Qt Creator que vais encontrar no teu menu Incio / Programas. Escolhe
do menu File, Open File or Project:
pg. 9
Agora, com o projecto aberto, carrega no boto Play do fundo do ecr para o
projecto ser compilado (built) e correr.
(x1,y1)
x
O vector a linha exemplificada acima, ou seja, a diferena entre os dois pontos.
Como uma diferena, a soma de um ponto com um vector d outro ponto. Por
exemplo, se somarmos ao ponto (x1,y1) acima o vector descrito no mesmo
diagrama, o resultado precisamente o ponto (x2,y2).
Da mesma forma posso ir somando vectores uns aos outros, o que o mesmo
que os ir desenhando em comboio, a cauda do seguinte com cabea do anterior.
O resultado o ponto na cabea do vector final. O vector resultante dessa soma
pg. 10
pg. 11
(x2,y2)
180
(x1,y1)
Exerccios
Qual o resultado e aspecto visual de:
1 0 0 x
0 1 0 y
0 0 1 z
1
0
0 0 d x x
1 0 d y y
0 1 d z z
0 0 1 1
Ou em Portugus, sen(), mas como a biblioteca matemtica do C (como na maior parte das
linguagens de programao) est em Ingls, a funo chama-se sin() (do Ingls sine).
pg. 12
s x
0
sy
sz
0 x
0 y
0 z
1 w
sin( 0 )
cos( 90 )
sin( 270 )
sin( 45 ) + cos( 45 )
cos( 180 )
Qual o tipo de dados (classe) que guarda a orientao que o jogador tem
no mapa? Se eu tiver uma varivel c que descreve uma tal orientao,
como que eu:
o Altero c para indicar que o jogador rodou para a direita
o Altero c para indicar que o jogador rodou para trs
o Converto c num nmero real (double) que tem essa orientao
mas em graus medidos no crculo trigonomtrico
pg. 13
A partir do ponto anterior, descobre onde que deves escrever cdigo para:
o Fazer a inicializao OpenGL da vista em 1 pessoa com OpenGL 2D
o Desenhar uma clula da grelha na vista do mapa nas coordenadas
(x,y)
o Desenhar a vista interior do labirinto a partir da posio (x,y) e
orientao especfica (em 2D e 3D)
Bom trabalho!
pg. 14
Aula 02
Hardware: Tipos de ecrs. CRT, LCD, LED. HD e Interlacing. Matriz de pixels,
cores (sub-pixels), varrimento, fotogramas. VGA, DVI, HDMI. Ecrs
estereoscpicos e 3D.
Iluso de animao. Fotogramas.
Ecrs CRT
Tubos de raios catdicos (Cathode-Ray Tube). Ilustrao*:
Onde:
1.
2.
3.
4.
5.
6.
Emissor de electres.
Feixes de electres.
Bobina de foco.
Bobinas de deflexo.
Conexo do nodo (plo positivo).
Tela para separao dos raios para o vermelho, verde e azul da imagem
mostrada.
pg. 15
x
As coordenadas dos pontos so nmeros reais (embora tambm possa usar
nmeros inteiros), to precisos quanto o programador precise (dentro da
capacidade de um float ou double). Caber ao OpenGL fazer a converso deste
mundo ideal para os pixels do ecr atravs de projeces (explicadas em aula
posterior).
Janelas e viewports
No vamos poder escrever em todo o ecr do nosso computador. Para alm de
isso interferir com a funcionalidade de outras aplicaes a correr ao mesmo
tempo no ecr, isso poderia ser at um problema de segurana.
Os sistemas operativos costumam separar visualmente cada aplicao em
rectngulos independentes. A terminologia do sistema operativo para este
rectngulo de janela.
pg. 16
Cada aplicao pode por sua vez separar a sua janela em vrias seces
rectangulares independentes (para desenhar botes, zonas de desenho, etc.). Cada
vez que um mtodo da aplicao tem uma dessas seces activa para l escrever,
chama a essa seco de viewport.
Viewport do OpenGL
dentro da janela do jogo.
Primitivas 2D
Tendo agora um sistema de coordenadas posso comear a desenhar figuras. Por
exemplo, desenho um quadrado entre as coordenadas (0,0) e (1,1) com:
glBegin( GL_QUADS
glVertex2f(
glVertex2f(
glVertex2f(
glVertex2f(
glEnd();
);
0,
0,
1,
1,
0
1
1
0
);
);
);
);
//
//
//
//
Canto
Canto
Canto
Canto
inferior
superior
superior
inferior
esquerdo
esquerdo
direito
direito
Ou seja, indico o tipo de figura que vou desenhar com glBegin(), indico a
posio de cada vrtice com glVertex2f() (ou suas variantes), e termino a
sequncia com glEnd().
pg. 17
glBegin() aceita vrios argumentos para vrios tipos de primitivas 2D, como
pontos:
Linhas e curvas:
E figuras preenchidas:
Existem algumas funes OpenGL utilitrias (que comeam com o prefixo glu)
que auxiliam na criao de curvas e discos, sem precisarmos de ter o CPU a
calcular senos e co-senos. No iremos dar essas funes, mas pesquisa por
gluBeginCurve(), glMap1f() e funes relacionadas.
pg. 18
Anti-aliasing e ClearType
Como os ecrs so construdos como uma matriz de pontos, linhas que no
sejam absolutamente horizontais ou verticais no ficam com aspecto perfeito e
tm de ser aproximadas. Se os pontos que compem o ecr no forem em
quantidade suficiente (para serem de tamanho muito pequeno) esta aproximao
perceptvel como defeito na qualidade visual da linha, j que esta ter um
aspecto de escada (aliasing).
Existem duas formas de resolver este problema*:
pg. 19
Exerccio
Compila e corre o exerccio NeHe ch2.
Bom trabalho!
pg. 20
Aula 03
Translaes, redimensionamentos, rotaes; composio de transformaes
(matriz).
Transformaes em sequncia: Conceitos de animao (double buffering,
fotogramas, fps, lapso entre fotogramas).
Lidar com temporizaes no Qt. Exemplos no CGMaze.
3D
3D a sigla de 3 Dimenses e refere-se a objectos que tm volume. Para alm
das duas dimenses expressas numa folha de papel (x e y, ou largura e altura)
temos tambm a profundidade (z), em 3D. O mundo nossa volta pode ser todo
descrito num sistema de coordenadas 3D.
Sistema de coordenadas 3D
Em OpenGL, o sistema de coordenadas tridimensional inclui as coordenadas x e y
j nossas conhecidas, e z, profundidade, que positiva para fora do ecr, na
direco do observador e negativa para dentro do ecr.
y
ecr
x
z
Primitivas 3D
Todas as primitivas 2D de OpenGL podem aceitar 3 coordenadas em vez de 2,
transformando-as em primitivas 3D. s trocar o 2 que faz parte do nome da
funo por 3 e acrescentar uma 3 coordenada (z) ao final.
pg. 21
Matriz de transformao
Todas as transformaes que eu posso aplicar a coordenadas/pontos 3D
(translao, redimensionamento, rotao), podem ser feitas multiplicando uma
matriz 44 com a transformao respectiva por um vector* com as coordenadas
tridimensionais, mais uma coordenada, w, que ter inicialmente o valor 1.
Exemplo:
1
0
0 0 0 x1 x2
1 0 0 y1 y2
=
0 1 0 z1 z2
0 0 1 w1 w2
Translao de coordenadas
Se eu precisar de fazer uma translao a um objecto (mover o objecto) composto
por vrios pontos com coordenadas x, y e z, uso a seguinte matriz de
transformao antes de definir os pontos:
1
0
0 0 d x
1 0 d y
0 1 d z
0 0 1
pg. 22
Redimensionamento de coordenadas
Se eu precisar de alterar as dimenses proporcionais (ou seja, ampliar ou reduzir)
um objecto composto por vrios pontos com coordenadas x, y e z, uso a seguinte
matriz de transformao antes de definir os pontos:
s x
0
0
sy
0
0
sz
0
0
0
4
3
2
1
1
0
0.5 0
0 0.5 0
0
0 0 .5
0
0
0
0
0
4
3
2
1
1
Resolvo este problema tendo os meus modelos dos objectos centrados na origem
das coordenadas. Mais sobre isto, abaixo.
Fao um redimensionamento em OpenGL com a funo
glScalef( sx, sy, sz );
Rotao de coordenadas
Existem trs matrizes diferentes para rotao de um objecto composto por vrios
pontos com coordenadas x, y e z, em torno de cada um dos eixos (x, y ou z). As
pg. 23
0
1
0 cos
x
0 sin x
0
0
0
sin x
cos x
0
0
0
0
cos y
0
sin y
0 sin y
1
0
0 cos y
0
0
0
0
cos z
sin
z
sin z
cos z
0
0
0 0
0 0
1 0
0 1
pg. 24
Se eu tiver um modelo de avio* visto de baixo e a voar para a direita (ou seja,
paralelo ao plano de z=0 e a voar na direco do eixo dos x), ento ele est
orientado nos eixos de inrcia e em Ingls z o yaw ou heading (guinada), x o
roll (rotao) e y o pitch (tambm conhecido como trim em submarinos, ou
arfagem em portugus).
Assim, se o vector for (1,0,0) por exemplo, a rotao faz-se em torno do eixo dos
x. A direco dos ngulos continua a determinar-se pela regra da mo direita.
pg. 25
Nota que todos estes eixos de rotao passam pela origem de coordenadas, e no
necessariamente pelo objecto/ponto em si. Se o objecto no estiver centrado na
origem, ele tambm vai mudar de posio, num crculo que passa pelo objecto e
perpendicular ao e centrado no eixo respectivo.
(x,y,z)
Resolvo este problema tendo os meus modelos dos objectos centrados na origem
das coordenadas. Mais sobre isto, abaixo.
A operao faz-se com a funo
glRotatef( angulo, x, y, z );
Composio de transformaes
Um conceito importante em programao OpenGL que existe sempre activa
uma matriz de transformao que aplicada a todas as coordenadas que so
enviadas para o sistema.
Esta uma nica matriz que aglomera todas as transformaes que foram
pedidas pela aplicao. Isto porque, se chamarmos M a uma matriz de
transformao e C ao vector de coordenadas, ento quando aplicamos duas
transformaes estamos a fazer:
M2(M1C)
Como a multiplicao de matrizes associativa,
M2(M1C) = (M2M1) C
Eu posso ento combinar ou compor todas as transformaes que preciso de fazer
numa s matriz e usar apenas essa com todos os vectores de coordenadas de que
precisar!
pg. 26
Esta tcnica tambm til quando precisamos de ter 2 ou mais objectos idnticos
em posies diferentes da nossa cena.
pg. 27
Assim, apesar da cmara estar no mesmo stio (origem das coordenadas), vemos
nossa frente os objectos que esto direita.
Existe uma funo auxiliar que nos ajuda a definir a posio da cmara,
criando na realidade as rotaes e translaes adequadas para fingir essa
colocao.
Essa funo a seguinte:
gluLookAt( ex, ey, ez, cx, cy, cz, ux, uy, uz );
Animao: double-buffering
Como j foi discutido, animar uma cena desenhar vrios fotogramas com
pequenas alteraes que indicam movimento ou outras alteraes.
Para simular movimento, podemos simplesmente redesenhar exactamente a
mesma cena, com os mesmos objectos, modificando apenas a translao dada a
um ou mais objectos.
Mas redesenhar uma cena pode causar problemas. Antes de comear a desenhar
devemos limpar o viewport, comeando depois a enviar polgonos para o OpenGL.
Por muito rpido que este desenho seja, pode existir um instante em que nos
apercebemos de ver um fotograma parcialmente desenhado. Conforme isto
acontece num e noutro fotograma, a imagem parece piscar (flicker).
Existem duas tecnologias que evitam este efeito. A primeira o double-buffering.
Se a placa grfica tiver memria suficiente e o suportar, ela tem duas zonas de
memria (buffers) para cada viewport, guardadas em memria. Uma a que est
neste momento a ser desenhada no ecr. A outra onde os comandos OpenGL
esto a desenhar os polgonos. Quando esse desenho termina, a placa grfica troca
os buffers instantaneamente, sem nunca ser visvel uma cena inacabada. So
normalmente os sistemas subjacentes que fazem essa troca automaticamente, o
que o caso do Qt.
Outra tecnologia a sincronizao da troca de buffers com o sinal vertical-retrace
do monitor. Isto garante que a troca no ocorre durante o desenho do viewport no
ecr, fazendo com que um dos fotogramas tenha visvel a metade superior do
buffer antigo e a metade inferior do novo buffer, efeito se ocorresse com frequncia
tornava-se visvel. Esta tecnologia est sempre activa em OpenGL.
Estas duas tecnologias garantem animao suave em OpenGL, mas a segunda
impe um limite na animao: a quantidade de fotogramas por segundo (fps).
Como a troca de buffer est sincronizada com o incio de um novo fotograma, no
conseguimos exibir fotogramas com mais frequncia do que aquela que o
monitor suporta (geralmente por volta de 50 a 60 fps).
pg. 28
Animao: temporizao
Precisamos ento de fazer duas coisas para fazer uma animao:
1. Uma forma de a cada d milissegundos* repetir nova cena, e
2. Uma forma de saber que alteraes fazer em cada nova cena.
O primeiro requisito tem de ser satisfeito pelo sistema que est a suportar a
aplicao. No faz parte da norma OpenGL lidar com temporizaes.
V nos exerccios abaixo como que o Qt resolve a questo de temporizaes, na
prtica.
O conceito em si semelhante em todos os sistemas: fazer com que uma funo
da minha aplicao seja chamada a cada d ms. Mas como escolher o d?
Depende do sistema e da suavidade pretendida para a animao. Em alguns
sistemas, o relgio que controla as vrias chamadas minha funo comea a
contar um novo perodo de d ms assim que chama a minha funo. Se a minha
funo ainda estiver a correr quando voltarem a passar d ms, ocorrem uma de
trs coisas:
1. Ele espera que a minha funo termine antes de a voltar a chamar;
2. Ele chama de imediato a minha funo;
3. Ele ignora esta oportunidade de chamar a minha funo.
Seja qual for o caso, ele continua imediatamente a contar novo perodo de d ms.
Repara que se estiveres a trabalhar num sistema que funcione como 1 ou 2, podes
sobrecarreg-lo se a tua funo no terminar antes de d ms. Cada nova chamada
tua funo mais lenta porque corre ao mesmo tempo que a anterior, e assim
por diante:
d ms
tempo
funo
funo
funo
funo
funo
funo
pg. 29
Exerccios
Imagina um quadrado desenhado em coordenadas 3D, mas no plano z=0, e com
os cantos (x,y,z):
(-1,1,0)
(1,1,0)
(1,-1,0)
(-1,-1,0)
Imagina que quero rodar o quadrado ao longo do eixo dos x, 90 (ou seja, se o
quadrado fosse o ecr do teu porttil, estou a pegar na parte de cima e a desloclo para baixo at ficar paralelo com a mesa: lembra-te no entanto que o eixo de
rotao do ecr diferente do deste quadrado). Quero tambm depois desloc-lo
para longe de mim (z negativo), por 1 unidade.
pg. 30
Faz com que as figuras rodem ambas em torno do eixo dos y central,
enquanto rodam nos seus prprios eixos. Repara: eu desenho sempre o
tringulo primeiro e depois o quadrado, pelo que quando eles se cruzam,
deve estar sempre o quadrado em cima (ou frente) do tringulo,
certo? Verificas isto? Que concluses tiras?
pg. 31
Aula 04
Projeces ortogonais e perspectivas. Relao de aspecto.
O jogo CGMaze: desenhar o mapa com operaes OpenGL 2D.
Projeces
Projeces so formas de representar uma cena 3D num plano 2D. Repara que o
ecr de um computador tem apenas duas dimenses (2D): altura e largura. Como
que crio ento a iluso de profundidade?
H vrias formas de o fazer. V por exemplo estes cubos:
O ecr ou folha de papel onde ests a ler isto plano (2D), mas no entanto estas
linhas oblquas do-te a iluso de um objecto tridimensional. A este tipo de
projeco chama-se perspectiva.
Ela imita a viso humana da realidade. Se, muito perto da cara, colocares o
polegar e indicador muito afastados, no vais conseguir ver a ponta desses dedos.
Mas se esticares o brao, no os consegues afastar o suficiente para os deixares de
ver.
olho
Isto acontece porque a lente esfrica dos nossos olhos apanha luz que se situa
dentro de um cone sua frente.
pg. 32
Por outro lado, se eu alinhasse a minha viso para estar exactamente de frente
para o cubo, tudo o que veria seria isto:
Projeces em OpenGL
Eu crio uma projeco de perspectiva em OpenGL em que o olho est na origem
das coordenadas a olhar na direco do eixo negativo dos z, com:
gluPerspective( cvy, aspecto, zperto, zdistante );
aspecto =
largura
altura
Ou ainda ortogrfica.
Experimenta olhar de cima para um copo que tenha os lados direitos. Irs conseguir ver o fundo
do copo completo, dentro do crculo que define a boca do copo.
Ou seja, elas definem os planos de corte perto e distante (near and far clipping planes): mais sobre
isto mais tarde.
pg. 33
y
cvy
olho
z
x
zperto
zdistante
(0,0)
viewport
y
(100,100)
No entanto nota que devo usar as funes OpenGL 2D (i.e., com z=0) nesta
projeco. Para poder usar outros valores de z, consulta a funo glOrtho() no
manual OpenGL.
Matrizes de projeco
Os clculos de projeco (em perspectiva ou ortogonal), podem ser feitos com
matrizes adequadas. De facto, as funes OpenGL explicadas nesta aula,
multiplicam a matriz de projeco actual pela matriz gerada pela funo.
Mas a matriz de transformao que estudmos na aula anterior aplicada
separadamente desta. Como indicamos ento que matriz queremos modificar?
pg. 34
Esta funo tambm aceita como argumento GL_TEXTURE para outra matriz.
Todas as operaes seguintes sobre matrizes (carregar identidade, transformaes
e projeces) ocorrem sobre a matriz seleccionada por esta funo.
Exerccios
Porque que nos exerccios da aula 2 foi necessrio adicionar uma linha
glTranslatef(0,0,-10)?
Porque que nos exerccios da aula anterior necessrio que o glTranslatef()
tenha uma translao z de -6.0?
Altera o exerccio da aula 2 (ch2) para passar a ter uma projeco ortogonal em
vez de perspectiva.
Abre o projecto CGMaze. Abre os ficheiros student_viewmap.h e
student_viewmap.cpp. Usando projeces ortogonais e OpenGL 2D, completa
esses ficheiros. Dicas:
Isso depende de que altura e largura queres dar ao teu quadrado. Determina isso arbitrariamente.
pg. 35
glColor3ub( VIEWMAP_COLOR_3UB_FLOOR );
glColor3ub( VIEWMAP_COLOR_3UB_PLAYER1 );
em
glClear( GL_COLOR_BUFFER_BIT );
pg. 36
Aula 05
O jogo CGMaze: desenhar a vista interior com operaes OpenGL 2D.
Agora desenho as paredes do corredor que est frente do jogador. Como fao
isso sem recorrer a OpenGL 3D?
Neste caso (labirinto) posso simplificar o processo. Repara como as paredes so
sempre desenhadas com duas linhas cruzadas em X e linhas verticais entre elas a
fazer de divisrias entre cada parede.
pg. 37
...
...
Isto significa que tenho de ir desenhando as paredes, das que esto mais perto do
jogador para as que esto mais longe, verificando sempre se encontro uma parede
de frente. Quando encontrar, desenho-a e paro o processo de desenho.
Por exemplo, imagina que quero desenhar esta vista do labirinto:
2.
pg. 38
3.
4.
5.
6.
7.
8.
9.
pg. 39
pg. 40
Aula 06
Representao de superfcies e objectos slidos (polygon meshes).
Clculo de visibilidade (superfcies escondidas).
Transparncia (canais alfa, blending e depth buffer).
Clculo de visibilidade
Existem duas situaes em que uma face ou superfcie pode no estar visvel:
1. Se est total ou parcialmente oculta por outra superfcie, ou
2. Se est de costas para o observador.
A primeira situao resolvida com recurso medio da distncia entre o
observador e a superfcie. Superfcies mais perto ocultam superfcies mais
distantes.
pg. 41
Repara como o cubo mais perto oculta parcialmente algumas faces do cubo mais
distante. Repara ainda como a face de cima do cubo de trs deixa de ter a forma
Cena tridimensional*.
O depth-buffer respectivo.
pg. 42
Estas tcnicas perdem no entanto tempo precioso quando acaba por desenhar
superfcies que esto totalmente ocultas.
Por fim, repara como nos cubos que esto desenhados acima metade das suas
faces esto totalmente ocultas. Essas so sempre tambm as faces que esto de
costas para o observador. A eliminao das faces de trs dos objectos (em Ingls,
back face culling), assim outra tcnica que pode poupar placa grfica at 50%
do tempo de desenho de um objecto.
Em OpenGL eu fao essa eliminao ao indicar os pontos de cada superfcie por
uma ordem especfica quando olho para ela pelo seu lado visvel (a frente). Se
quando projectada, esta superfcie tiver os seus pontos pela ordem oposta, ela est
de costas para o observador.
1
Para que o OpenGL elimine agora as faces dos polgonos com base na ordem pela
qual eu lhe dou os pontos, fao:
glCullFace( GL_BACK );
glEnable( GL_CULL_FACE );
pg. 43
Transparncia e opacidade
Transparncia (ou, inversamente, opacidade), uma caracterstica de superfcies
que se aplica em desenho 2D e 3D. gua, culos, copos, janelas e faris so
exemplos de alguns objectos que so parcialmente transparentes. Mar, culos
escuros e vidros fumados so exemplos de objectos com nveis maiores de
opacidade (i.e., menos transparentes).
Transparncia: 0%
Opacidade: 100%
Transparncia: 40%
Opacidade: 60%
Transparncia: 80%
Opacidade: 20%
e desactivo-a com:
glDisable( GL_BLEND );
pg. 44
Exerccios
Compila e corre o exerccio NeHe ch5. Este desenha dois objectos slidos
tridimensionais: uma pirmide de base quadrangular e um cubo.
Compila e corre o exerccio NeHe ch8. Quando correres este programa podes usar
as setas para acelerar o cubo nos seus eixos, PgUp e PgDown para
ampliar/reduzir, L para activar/desactivar a iluminao (lighting mais sobre
isto em aula posterior), B para activar/desactivar a transparncia (blending) e F
para iterar por 3 filtros (para qualidade da imagem mais sobre isto em aula
posterior).
Aproveita o tempo que sobrar nesta aula para completar o exerccio da aula
anterior.
pg. 45
Aula 07
Cor (interpretao da cor, modelos de cor, cones de cor nos olhos; emissores de
cor nos pixels).
Profundidade de cor: P/B, escala de cinzentos, palette ou RGB.
Tipos de ficheiros de imagens (GIF, TIFF, PNG, JPG); Compresso lossy vs. lossless.
Canais alfa.
Texturas.
O que a cor
Se estiveres fechado no teu quarto noite, sem fontes de luz, no vs nada. A
cor predominante o preto. Se apontares uma Webcam para o Sol (nunca faas
isso com os olhos, sem proteco), ela satura e mostra uma imagem branca.
Cor est ento relacionada com luz. Quando de um objecto no chega luz aos
nossos olhos, o objecto parece-nos preto. Se chega muita luz com muita
intensidade, ele parece-nos branco.
Mas para alm da intensidade da luz, ela tem outra propriedade que a sua
frequncia. A luz radiao electromagntica (o mesmo tipo de radiao usada
em rdio, WiFi, telefones celulares, televiso por antena, etc.) e feita de fotes,
partculas que vibram com uma rapidez (frequncia) varivel. Quando essa
frequncia estiver aproximadamente entre os 400THz* e os 700THz, essa luz
visvel e tem cores diferentes dependendo da frequncia.
Espectro de Luz
Se os nossos olhos virem um objecto que emite luz nas frequncias verde e
encarnada, esse objecto visto como tendo cor amarela (a combinao das duas).
A combinao de todas as cores visto como cor branca, e a sua ausncia como
cor negra.
Cada objecto reflecte (ou emite) para os nossos olhos uma ou mais destas
frequncias. A cor que vemos num objecto tem a ver com a combinao destas
frequncias.
*
Tera-Hertz. 1Hz um ciclo por segundo. 1T so 1000G (mil gigas), ou 1012 (um bilio). 1THz
so ento um bilio de ciclos por segundo. V na bibliografia, [SI].
pg. 46
Existe um quarto tipo de clulas que so os bastonetes, mas estes apenas esto
activos com luz de baixa intensidade. Como s existe um tipo destas clulas, o ser
humano v a preto-e-branco em situaes de pouca luz.
Gerao de cor
Thomas Young props em 1801 a sua teoria tricolor, ao observar que qualquer
cor podia ser criada usando apenas trs luzes de cores especficas. James Clerk
Maxwell e Hermann von Helmholtz mais tarde refinaram esta teoria.
Existem dois grandes modelos tricolores usados:
RGB, sigla das cores encarnado (Red), verde (Green) e azul-mar (Blue). Estas
so as chamadas cores aditivas, pois adicionam cor a um preto base. Como
tal, este o modelo usado em ecrs de televiso e computador de todos os
tipos (CRT, LCD, LED, etc.).
pg. 47
Cor em OpenGL
Em Computao Grfica interessa-nos obviamente o modelo RGB. J te foi
mostrado na aula 02 uma ampliao do ecr de um computador com os seus
subpixels (emissores de cada uma das cores RGB em cada pixel). Este ento o
modelo usado pelo OpenGL.
Escolho uma cor em OpenGL com uma das seguintes funes:
glColor3f( r, g, b );
onde r, g e b so floats entre 0.0 (essa cor est desligada) e 1.0 (essa cor est na
sua intensidade mxima), ou:
glColor3ub( r, g, b );
onde r, g, b e a so floats entre 0.0 e 1.0, especifica qual a cor e opacidade (alfa)
do viewport quando o quisermos apagar com glClear().
Como escolho os valores RGB para uma cor? Em praticamente qualquer aplicao
que suporte cor, podes escolher visualmente uma cor e ela d-te os valores RGB
(habitualmente em bytes sem sinal) para essa cor.
Por exemplo, na aplicao Paint dos acessrios do Windows posso editar as cores:
pg. 48
Como vs no canto inferior direito, a cor que escolhi tem os valores r=36,
g=236 e b=26 (bytes sem sinal), e poderia ser escolhida em OpenGL com:
glColor3ub( 36, 236, 26 );
Texturas
A forma mais simples que OpenGL usa para simular uma textura numa
superfcie simplesmente pintar essa superfcie (que geralmente um
quadriltero) com uma imagem.
O OpenGL precisa de receber a imagem num formato especial, pelo que precisa
sempre da ajuda do sistema onde est a correr. No Qt, abrimos essas imagens
com:
QImage i, igl;
if( !i.load("imagem.png") )
{
i = QImage( 16, 16, QImage::Format_RGB888 );
i.fill( QColor(Qt::green).rgb() );
}
igl = QGLWidget::convertToGLFormat( i );
As partes mais claras dependem da tua aplicao. O que estamos a fazer tentar
abrir um ficheiro de imagem. Se no o conseguirmos abrir, entramos no if() e
criamos uma imagem de 1616 pixels slida de cor verde (ou outra que prefiras),
de forma a assegurar que a aplicao ainda funciona mesmo que no tenha a
imagem disponvel.
Repetimos este processo para todas as imagens que precisarmos.
Criamos agora no OpenGL tantos identificadores de textura (um identificador
um nmero inteiro que o OpenGL te ir dar) quantos as texturas (imagens) que
vou usar (neste caso, 1):
GLuint texturas[1];
glGenTextures( 1, texturas );
Para cada textura (0 a primeira e nica neste caso), vou agora carregar e
configur-la no OpenGL. Comeo por escolher a textura que vou configurar:
glBindTexture( GL_TEXTURE_2D, texturas[0] );
pg. 49
glTexParameteri(
GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
GL_LINEAR );
Por fim, carrego a imagem para essa textura. Isto pode ser feito com:
glTexImage2D(
GL_TEXTURE_2D, 0, GL_RGB,
igl.width(), igl.height(), 0,
GL_RGBA, GL_UNSIGNED_BYTE, igl.bits() );
mip do Latim multum in parvo ou muito num espao pequeno. Isto garante uma maior
velocidade e qualidade das imagens quando exibidas numa superfcie pequena.
pg. 50
);
0);
0);
0);
0);
(1,1)
textura
(0,0)
Exerccios
Compila e corre o exerccio NeHe ch3.
Repara como o OpenGL cria transies de cores entre pontos que tenham
cores diferentes (o tringulo). Altera ento o exerccio para teres o
tringulo roxo e o quadrado com a metade superior azul-mar e a inferior
amarelo-alaranjado.
pg. 51
Faz com que duas das faces contguas do caixote passem a ter o aspecto de
uma paisagem. O cho de ambas as faces deve estar colado um com o
outro.
pg. 52
Aula 08
Iluminao (luz ambiente e focos, luz cromtica), sombreamento.
Iluminao
Vimos na aula anterior que a luz que incide sobre uma superfcie o que lhe d a
cor. E uma imagem onde no incida nenhuma luz est preta. Em OpenGL
podemos simular essa iluminao: isto dar mais realismo s superfcies.
pg. 53
Ambiente
+ Difusa
+ Especular
= Phong
Existe uma quantidade finita de fontes de iluminao (lights) que podemos criar
na nossa cena. O mnimo de fontes de iluminao suportadas de oito, mas o
valor difere de GPU para GPU. A quantidade suportada na placa grfica onde est
a ser compilado o programa dado por GL_MAX_LIGHTS.
As funes para configurar as fontes de iluminao so as seguintes:
glLightf (
glLightfv(
glLighti (
glLightiv(
fonte,
fonte,
fonte,
fonte,
parametro,
parametro,
parametro,
parametro,
float
float
int
int
valor
valores[]
valor
valores[]
);
);
);
);
pg. 54
pg. 55
Aqui, face identifica qual a face que estamos a configurar. Pode assumir os
valores GL_FRONT, GL_BACK ou GL_FRONT_AND_BACK. parametro identifica
qual o parmetro que estamos a configurar e valores sero os valores a atribuir
a esse parmetro.
parametro pode assumir um dos seguintes valores (entre outros):
GL_AMBIENT,
GL_DIFFUSE,
GL_AMBIENT_AND_DIFFUSE
GL_SPECULAR controla as respectivas propriedades deste material.
definida como um vector de 4 valores float RGBA, onde 1.0 representa
intensidade mxima e -1.0 a intensidade mnima. O componente alfa
ignorado em todas as propriedades excepto na respeitante luz difusa.
pg. 56
Iluminao: Normais
O ngulo que cada fonte de iluminao faz com cada superfcie determina a
quantidade de luz que ela reflecte e/ou a sua cor. Esse ngulo no calculado
automaticamente. Eu devo indicar um vector (chamado de vector normal) para
cada vrtice, que perpendicular face e aponta para fora do objecto. Se todos
os vrtices do objecto tiverem a mesma normal, s a precisamos de especificar ao
incio do glBegin().
Por exemplo, o cubo da aula anterior seria definido com os seguintes vectores:
Nota no entanto que o OpenGL assume trs coisas em relao aos vectores
normais indicados:
1. Tm origem na origem de coordenadas,
2. Esto de facto perpendiculares superfcie,
3. Tm norma ou dimenso de 1.
Se estas trs regras no forem perfeitamente cumpridas, a luz reflectida no ser
realista.
Defino o vector normal de uma superfcie usando:
glNormal3f( x, y, z );
Existem outras variantes da funo para aceitar outros tipos de dados, como
habitual em OpenGL.
Como o vector transformado pela matriz GL_MODELVIEW, como qualquer
outro vrtice na cena, ele pode deixar de ter norma 1. Isto s acontece se o
redimensionar, mas posso precisar de o fazer. Posso pedir ao OpenGL para
automaticamente normalizar os vectores normais com:
glEnable( GL_NORMALIZE );
pg. 57
Exerccios
Compila e corre o exerccio NeHe ch7. Quando correres este programa podes usar
as setas para acelerar o cubo nos seus eixos, PgUp e PgDown para
ampliar/reduzir, L para activar/desactivar a iluminao (lighting mais sobre
isto em aula posterior), B para activar/desactivar a transparncia (blending) e F
para iterar por 3 filtros (para qualidade da imagem mais sobre isto em aula
posterior).
Muda a iluminao difusa para passar a ser com uma luz encarnada.
Compila e corre o exerccio NeHe ch8. Ele tem disponveis as mesmas teclas de
controlo que o exerccio ch7.
Altera todas as normais para que o OpenGL julgue que as faces de frente
do cubo sejam as faces de dentro.
pg. 58
Aula 09
Modelos 3D em ficheiros.
Animao de objectos na cena: Fsica e deteco+gravao de movimento humano
(sistemas de aquisio de coordenadas para modelao 3D).
O jogo CGMaze: Modelao da vista interior 3D.
Modelos 3D em ficheiros
Quando passarmos para o prximo nvel e precisarmos de ter todo um modelo de
um mundo ambiente e objectos de cenrio, precisaremos de os ter gravados em
ficheiros para serem carregados por cdigo nosso para o sistema OpenGL.
O exerccio NeHe ch10 um exemplo desta tcnica.
Existem vrios programas de desenho de modelos 3D: 3ds Max, Maya, SoftImage
XSI, entre outros. Alguns esto especializados para um certo tipo de motor 3D
(i.e., cdigo de gerao OpenGL), como o UnrealEd*.
O problema que cada um tem o seu prprio formato de ficheiros, optimizado
para os seus motores 3D. Quando escolheres um deles, ters de ter informao do
seu formato para o conseguires ler e usar em chamadas OpenGL.
O exerccio NeHe ch10 usa um ficheiro com listas de 5 coordenadas para cada
vrtice de um tringulo. As primeiras 3 coordenadas so as x, y e z do vrtice. As
duas seguintes so as x e y da textura, nesse vrtice.
Este formato to vlido como qualquer outro. A questo quando os leres (e a
forma de ler depende do sistema que suporta o OpenGL e no do OpenGL em si), o
fazeres para um formato que te simplifica a vida mais tarde fornecer esses dados
ao OpenGL.
Repara nas variantes da funo glVertex() que tens disponveis:
glVertex2s( short
glVertex2i( int
glVertex2f( float
glVertex2d( double
glVertex3s( short
glVertex3i( int
glVertex3f( float
glVertex3d( double
glVertex2sv( short
*
x, short
x, int
x, float
x, double
x, short
x, int
x, float
x, double
v[2] );
y );
y );
y );
y );
y, short
y, int
y, float
y, double
z
z
z
z
);
);
);
);
V http://www.udk.com/.
pg. 59
glVertex2iv(
glVertex2fv(
glVertex2dv(
glVertex3sv(
glVertex3iv(
glVertex3fv(
glVertex3dv(
int
float
double
short
int
float
double
v[2]
v[2]
v[2]
v[3]
v[3]
v[3]
v[3]
);
);
);
);
);
);
);
Fsica
O movimento de objectos numa cena deve seguir as regras da Fsica, para ser
realista. As leis de Newton que envolvem foras, aco-reaco, velocidade
constante e aceleraes, atrito e outros factores devem ser consideradas.
Estes clculos no fazem parte do OpenGL em si, e normalmente so calculados
pelo CPU com programao especfica. Algumas placas grficas da marca NVIDIA
tm acelerao especfica para Fsica:
http://www.nvidia.com/object/physx_new.html
Outros fabricantes (NVIDIA e ATI) permitem que o programador use parte do
poder de computao do GPU para clculos arbitrrios o que deveria permitir que
esses clculos sejam usados para Fsica.
Para mais informaes, l:
http://en.wikipedia.org/wiki/Physics_engine
pg. 60
pg. 61
Depois podes tentar resolver da mesma forma que foi feito na aula 05 para a vista
interior em 2D. Fazes o mesmo ciclo que avana em frente at encontrar uma
parede de frente ou chegar a uma profundidade mxima. Mas vais reparar que
isso no resolve o problema dos corredores laterais conforme o jogador se vira.
Isso fica para tu resolveres.
Da em diante usa a tua criatividade para resolver os restantes problemas do
enunciado!
Exerccios
Compila e corre o exerccio NeHe ch10.
Altera o ficheiro do mapa (world.txt) para poderes navegar numa
representao aproximada de um dos quartos do Egmont H. Petersen's Kollegium
em Copenhaga, Dinamarca.
pg. 62
Ou do quarto duplo:
pg. 63
Aula 10
Tpicos avanados: Ray tracing, fractais, sistemas de partculas.
Ray Tracing
OpenGL e outras interfaces de 3D esto preparadas para as placas grficas
desenharem as superfcies (polgonos) que lhes so apresentadas. Embora
iluminao e tcnicas de sombreamento adicionem realismo s imagens, nunca
so completamente fiis realidade (especialmente em reflexes e refraces).
Ray Tracing consegue altssimos graus de realismo:
Esta tcnica traa os raios de luz de cada pixel da imagem gerada. Este rastreio
feito de forma inversa: o raio que chega a cada pixel de uma cmara fotogrfica
ou de filmar vem da luz reflectida pela cena. Em Ray Tracing o raio rastreado do
pixel em direco cena, at se encontrar uma fonte de iluminao. Em cada
superfcie, os dados de ngulo com a superfcie, cor, tipo de material, etc. so
2013 Pedro Freire // Computao Grfica
www.pedrofreire.com
pg. 64
levados em conta para determinar a nova direco (ou direces) do feixe de luz e
(no fim) a cor desse pixel*.
Cmara
Viewport
Fonte de
iluminao
Raios de luz
Raios reflectidos
Objecto
Sombra
Fractais
Fractais so figuras geomtricas que podem ser reduzidas a partes mais pequenas,
cada uma das quais uma cpia reduzida (de pelo menos parte) do todo.
O melhor explicar com exemplos. O floco de neve Koch comea com um
tringulo equiltero. Em cada iterao posterior ir ento substituir o 1/3
intermdio de cada face com um tringulo equiltero.
O resultado (nas primeiras 4 iteraes) o seguinte:
pg. 65
Este processo repetido at cada alterao imagem seja menos do que um pixel.
Isto significa que podemos continuar a fazer iteraes se o utilizador desejar
ampliar a imagem, revelando infinitamente mais detalhes sem perder resoluo.
Por exemplo, o conhecido fractal Mandelbrot pode ser repetidamente ampliado:
Como se pode ver neste exemplo, quando amplio o fractal (numa aplicao
especial), o fractal redesenhado com total detalhe para a ampliao pedida, sem
perder resoluo.
Claro que isto apenas possvel quando a ampliao executada em software
especfico de desenho de fractais: se eu colocar um fractal numa imagem JPG ou
PNG (ou outra), ela quando ampliada sofrer de todos os defeitos habituais de
uma ampliao digital (pixelizao).
Os fractais conseguem boas aproximaes de muitas formas da natureza: nuvens,
flocos de neve, cristais, cordilheiras montanhosas, relmpagos, redes de rios,
couves-flor e brcolos, redes de vasos sanguneos e pulmonares, e linhas
costeiras.
Brcolo romanesco*
pg. 66
Por exemplo, para criar uma montanha posso comear com um tringulo 3D.
Encontro os pontos centrais de cada aresta (lado) e fao um novo tringulo
intermdio, cortando efectivamente o tringulo original em 4 novos tringulos.
Os vrtices do novo tringulo so elevados ou baixados aleatoriamente dentro de
uma gama especificada. Em cada nova iterao essa gama reduzida a metade.
O resultado o seguinte (em 5 iteraes):
1
Sistemas de partculas
Sistemas de partculas so simulaes de Fsica (ver aula anterior) em que o
objecto ou fenmeno simulado composto de mltiplos componentes a que
chamamos de partculas.
pg. 67
pg. 68
Projecto
Exerccios e apoio ao projecto.
Exerccios
1. Adiciona texturas especiais para o cho que j foi percorrido pelo jogador.
Dica: V como no desenho do mapa descobrias quando um pedao de cho
j tinha sido percorrido pelo jogador.
2. Usa (altera) a funo MapCreate::features() para adicionar
aleatoriamente objectos a certas partes do cho e paredes. Usa depois
esses objectos para distinguir entre vrias texturas alternativas, de forma
a incluir coisas como alapes fechados, janelas e tochas na parede, etc..
Dica: o objecto no mais do que um nmero inteiro associado a uma
clula do mapa. Originalmente todos os objectos esto a zero,
significando sem objecto. Se c for do tipo Cell, altero/leio o objecto
dentro dele com c.object.
pg. 69
Bibliografia
[CGPP]
Foley, van Dam, Feiner, Hughes,
Computer Graphics: Principles and Practice
(2 edio), Addison Wesley.
Na Amazon do Reino Unido, em:
http://www.amazon.co.uk/Computer-Graphics-Principles-PracticeInternational/dp/0321210565/
[QT]
Qt, Nokia.
No site da Nokia em:
http://qt.nokia.com/
[NEHE]
Neon Helium Productions, GameDev.
No site da GameDev em:
http://nehe.gamedev.net/
[OGL21]
OpenGL 2.1 Reference Pages, Silicon Graphics.
No site do OpenGL em:
http://www.opengl.org/sdk/docs/man/xhtml/
[SI]
Systme International d'Units (Sistema Internacional de Unidades), BIPM.
No site do BIPM (Bureau International des Poids et Mesures) em:
http://www.bipm.org/en/CGPM/db/11/12/
http://pt.wikipedia.org/wiki/Sistema_Internacional_de_Unidades
http://en.wikipedia.org/wiki/International_System_of_Units
pg. 70