7 }
C´odigo 6.2.1: C´odigo de Invers˜ao de Tela
A Figura 6.1 ilustra a imagem de sa´ıda do ARToolKit antes e ap´os a inser¸c˜ao do c´odigo de invers˜ao da imagem.
Figura 6.1: Invers˜ao da tela do ARToolKit
Ainda neste contexto, h´a mais um m´etodo que foi alterado, o m´etodo keyEvent. Atrav´es da altera¸c˜ao deste m´etodo foi poss´ıvel realizar intera¸c˜ao com o usu´ario, atrav´es da ativa¸c˜ao de teclas do teclado (Descri¸c˜ao detalhada na se¸c˜ao 6.5.5).
6.3 Gera¸c˜ao dos Objetos Virtuais
Os objetos virtuais utilizados para aumentar a realidade atrav´es deste trabalho foram implementados com o uso das bibliotecas OpenGL. Estas modelagens compreendem essen-cialmente `a SP, pois, a OpenGL fornece uma estrutura vi´avel `a concep¸c˜ao de tais modelos (Se¸c˜ao 5.3.5).
Como visto no Cap´ıtulo 5, a OpenGL ´e uma poderosa ferramenta de modelagem 3D. Deste modo, ´e poss´ıvel modelar alguns cen´arios para possibilitar uma intera¸c˜ao entre os SP e outras modelagens. Esta modelagem ser´a descrita na Se¸c˜ao 6.5.2.
A Figura 6.2 ilustra a modelagem de uma cascata com 3 quedas d’´agua atrav´es do uso de SP e um est´adio de futebol, ambos modelados atrav´es da OpenGL.
O intuito deste trabalho n˜ao se resume `a modelagem de apenas um SP visando au-mentar a realidade, deste modo, para a gera¸c˜ao dos objetos virtuais foram criados alguns m´etodos, cada um com sua habilidade, para encapsular as caracter´ısticas comuns `a todos os SP, modificando as partes que forem necessariamente exigidas para cada aplica¸c˜ao.
Figura 6.2: Modelagens em OpenGL
A se¸c˜ao 4.4.2 descreve a simula¸c˜ao das part´ıculas, mostrando as a¸c˜oes necess´arias para que as part´ıculas atuem como um sistema ´unico modelando um objeto. Assim, de forma simplificada, as part´ıculas tˆem de ser geradas, ter seus atributos definidos, serem renderizadas, morrerem e serem substitu´ıdas por novas part´ıculas.
Deste modo os m´etodos apresentados nos trechos de c´odigo ao longo do cap´ıtulo s˜ao respons´aveis por manter esse ciclo de simula¸c˜ao das part´ıculas ativas.
Quando o sistema ´e inicializado, ´e necess´ario iniciar as part´ıculas, pois, ´e preciso existir um n´umero fixo de part´ıculas ativas no sistema (se¸c˜ao 5.3.5). Dentro do projeto principal do ARToolKit, existe um m´etodo respons´avel pela inicializa¸c˜ao de todos os parˆametros de v´ıdeo, orienta¸c˜ao, renderiza¸c˜ao, etc. Este ´e o m´etodo init, dentro dele ´e inserido o m´etodo inciaParticulas, mostrado pelo C´odigo 6.3.1.
1 void iniciaParticulas (void){
2 int n;
3 for(n = 0; n< MAXPARTICULAS; n++){ //Limita a inicializa¸c~ao de part´ıculas
4 conceberParticulas(n); //Concebe part´ıculas
5 }
6 }/*Fim iniciaParticulas*/
C´odigo 6.3.1: M´etodo Gen´erico iniciaParticulas
A partir do momento que o SP foi iniciado, ´e preciso conceber as part´ıculas do SP. Existem diversas formas de conceber as part´ıculas do sistema, mas ´e necess´ario observar a faixa de movimenta¸c˜ao (se¸c˜ao 4.4.1). A faixa de movimenta¸c˜ao limita o espa¸co que as part´ıculas devem percorrer desde a concep¸c˜ao at´e a morte. No momento que as part´ıculas s˜ao concebidas, se define a base da faixa de movimenta¸c˜ao e seus atributos.
Por exemplo, para se modelar um tornado, as part´ıculas devem ser concebidas a partir de um pequeno c´ırculo e depois subirem pela faixa de movimenta¸c˜ao, que ter´a sua base no c´ırculo. As part´ıculas devem ser pequenos pontos gradualmente transparantes para garantir o efeito Motion Blur (se¸c˜ao 4.5) e terem cor escura como poeira.
Como outro exemplo, para se modelar um gramado de futebol, as part´ıculas devem ser concebidas a partir de um quadrado que seria o pr´oprio campo e depois subirem at´e certa altura formando os chuma¸cos de grama. As part´ıculas devem ser pontos ligados um
ao outro, formando linhas e, de preferˆencia de cor verde sem transparˆencia.
Dessa forma o m´etodo conceberParticulas ´e respons´avel pela defini¸c˜ao da forma com que as part´ıculas do sistema ser˜ao concebidas, definindo a base da faixa de movimenta¸c˜ao, por onde as part´ıculas nascer˜ao em posi¸c˜oes aleat´orias dentro desta base, e seus atributos. Este procedimento ´e descrito no C´odigo 6.3.2.
1 void conceberParticulas (int m){
2 GLfloat alpha, beta; //Angulos para defini¸c~ao de circunfer^encia, cones, etc
3 GLfloat raio = num * randomico(); //Raio rand^omico dentro da faixa
4 alpha = num*randomico();
5 beta = num* randomico();
6
7 //Posi¸c~ao das part´ıculas nos eixos X,Y e Z
8 Particulas[m].posicao[0]= num;
9 Particulas[m].posicao[1]= num;
10 Particulas[m].posicao[2]= num;
11
12 //Velocidade de movimenta¸c~ao nos eixos X, Y e Z
13 Particulas[m].velocidade[0]= num;
14 Particulas[m].velocidade[1]= num;
15 Particulas[m].velocidade[2]= num;
16
17 //Acelera¸c~ao de movimenta¸c~ao nos eixos X, Y e Z
18 Particulas[m].aceleracao[0] = num;
19 Particulas[m].aceleracao[1] = num;
20 Particulas[m].aceleracao[2] = num;
21
22 //Defini¸c~ao da cor inicial, padr~ao RGB
23 Particulas[m].cor[0] = num*randomico();
24 Particulas[m].cor[1] = num*randomico();
25 Particulas[m].cor[2] = num*randomico();
26
27 Particulas[m].tempoVida = num*randomico(); //Tempo de vida ativa
28 Particulas[m].transparencia = num; //Transpar^encia
29 }
C´odigo 6.3.2: M´etodo Gen´erico conceberParticulas
Os valores (em todos os m´etodos) atribu´ıdos `a estrutura deste SP s˜ao completamente simb´olicos, usados apenas para demostrar a concep¸c˜ao das part´ıculas, atrav´es da defini¸c˜ao da base da faixa de movimenta¸c˜ao e de seus atributos, bem como influˆencias de for¸cas externas, renderiza¸c˜ao, morte das part´ıculas e atualiza¸c˜ao do sistema, por ´e usada a mesma vari´avel chamada “num”. Para verificar os c´odigos para funcionamento, consultar os Apˆendices.
Assim que s˜ao concebidas, as part´ıculas inciam sua movimenta¸c˜ao de acordo com a influˆencia de for¸cas externas como simula¸c˜ao da gravidade, vento, etc. Essas influˆencias s˜ao colocadas diretamente sobre cada eixo (X, Y e Z), interferindo na velocidade, ace-lera¸c˜ao, posi¸c˜ao e qualquer atributo sujeito `a altera¸c˜oes. O m´etodo desenhaParticula ´e respons´avel pela altera¸c˜ao e renderiza¸c˜ao das part´ıculas. Caracterizando as for¸cas exer-cidas sobre cada uma das part´ıculas do sistema. O m´etodo desenhaParticula ´e mostrado no C´odigo 6.3.3.
Dessa forma as part´ıculas s˜ao renderizadas de acordo com o comportamento imposto ao SP (Se¸c˜ao 4.3). Quando o tempo de vida das part´ıculas chega a zero, ´e hora dessas part´ıculas serem substitu´ıdas por outras. Esse fenˆomeno ´e conhecido como morte das part´ıculas.
necessita de um n´umero fixo de part´ıculas ativas. Essa parte de atualiza¸c˜ao do sistema ´
e extremamente necess´aria, pois, o sistema precisa manter a modelagem animada, geral-mente em constante movimento.
1 void desenhaParticulas(void){
2 int f;
3 for(f = 0; f<MAXPARTICULAS; f++){ //Altera¸c~ao de cada part´ıcula
4 //Defini¸c~ao cor padr~ao RGB e transpar^encia
5 glColor4f(Particulas[f].cor[0], Particulas[f].cor[1], Particulas[f].cor[2],Particulas[f].transparencia);
6 glPointSize(num); //Tamanho da part´ıcula como ponto
7 glPushMatrix();
8 glBegin(GL_POINTS);
9 //Desenho de cada ponto
10 glVertex3f(Particulas[f].posicao[0], Particulas[f].posicao[1], Particulas[f].posicao[2]);
11 glEnd(); 12 glPopMatrix(); 13 14 Particulas[f].posicao[0] += Particulas[f].velocidade[0]; 15 Particulas[f].posicao[1] += Particulas[f].velocidade[1]; 16 Particulas[f].posicao[2] += Particulas[f].velocidade[2]; 17 18 Particulas[f].velocidade[0] += Particulas[f].aceleracao[0]; 19 Particulas[f].velocidade[1] += Particulas[f].aceleracao[1]; 20 Particulas[f].velocidade[2] += Particulas[f].aceleracao[2]; 21 22
23 Particulas[f].tempoVida -= num; //Decremento do tempo de vida
24 Particulas[f].transparencia -= num; //Decremento da transpar^encia
25 extinguirParticulas(f);
26 }/*Fim do For*/
27 }
C´odigo 6.3.3: M´etodo Gen´erico desenhaParticulas
O m´etodo respons´avel pela morte das part´ıculas ´e o extinguirParticulas. Uma part´ıcula pode ser substitu´ıda n˜ao apenas porque seu tempo de vida acabou, mas tamb´em por que est´a para ultrapassar uma posi¸c˜ao que n˜ao ´e vi´avel e, dessa forma, a movimenta¸c˜ao da part´ıcula pode ser limitada de acordo com sua posi¸c˜ao, causando a morte da part´ıcula. O C´odigo 6.3.4 se refere ao m´etodo extinguirParticulas. Assim que uma part´ıcula ´e morta pelo m´etodo extinguirParticulas outra ´e imediatamente concebida pelo m´etodo conceberParticulas.
1 void extinguirParticulas (int g){
2 if(Particulas[g].tempoVida < num){
3 conceberParticulas(g);
4 }
5 if(Particulas[g].posicao[pos] < num){ //Posi¸c~ao em X pos=1, Y pos=2 e Z pos=3
6 conceberParticulas(g);
7 }
8 }/*Fim extinguirParticulas*/
C´odigo 6.3.4: M´etodo Gen´erico extinguirParticulas