Você está na página 1de 86

UNIVERSIDADE FEDERAL DE MATO GROSSO

COORDENAO DE ENSINO DE GRADUAO EM


CINCIA DA COMPUTAO

ESTUDO E DESENVOLVIMENTO DE UM SISTEMA DE PARTCULAS


APLICANDO A PROGRAMAO ORIENTADA A OBJETOS

RODRIGO VIEIRA CHAVES

CUIAB - MT
2009

UNIVERSIDADE FEDERAL DE MATO GROSSO


COORDENAO DE ENSINO DE GRADUAO EM
CINCIA DA COMPUTAO

ESTUDO E DESENVOLVIMENTO DE UM SISTEMA DE PARTCULAS


APLICANDO A PROGRAMAO ORIENTADA A OBJETOS

RODRIGO VIEIRA CHAVES

Orientador: Prof. Dr. Joo Paulo Igncio Ferreira Ribas


Co-Orientador: Prof. Dr. Arlenes Silvino da Silva

Monografia apresentada ao Curso de Cincia da


Computao da Universidade Federal de Mato
Grosso, para obteno do Ttulo de Bacharel em
Cincia da Computao.

CUIAB - MT
2009

UNIVERSIDADE FEDERAL DE MATO GROSSO


COORDENAO DE ENSINO DE GRADUAO EM
CINCIA DA COMPUTAO

CERTIFICADO DE APROVAO

Ttulo: Estudo e Desenvolvimento de um Sistema de Partculas aplicando a programao orientada a objetos


Autor: Rodrigo Vieira Chaves

Aprovada em ___/___/______

Prof. Dr. Joo Paulo Igncio Ferreira Ribas


Instituto de Computao - UFMT
(Orientador)

Prof. Dr. Arlenes Silvino da Silva


Instituto de Computao - UFMT
(Co-Orientador)

Prof. Msc. Luciana Corria Lima de Faria Borges


Instituto de Computao - UFMT

Prof. Msc. Maurcio Fernando Lima Pereira


Instituto de Computao - UFMT

DEDICATRIA
A Deus, pela oportunidade que me tem dado de viver a vida livremente.
minha famlia, por todo apoio dado no decorrer da minha existncia.

AGRADECIMENTOS
Ao Prof. Joo Paulo Ribas pela orientao que prestou na elaborao desse trabalho,
ao Prof. Arlenes pela correo e orientao nas partes em que exigido matemtica e ao Prof.
Valdenilson pela ajuda valiosa que me ofereceu sobre equaes diferenciais e o mtodo de
Runge-Kutta.
A todos os colegas que diretamente ou indiretamente me apoiaram.
meu pai que me sustentou todo o perodo em que estive na faculdade, sem o qual
essa monografia no viria a existir.

ndice de ilustraes
Figura 1: Sistema de partculas com um nascedouro em forma de esfera, as partculas nascem
aleatoriamente em posies que estejam dentro da esfera........................................................21
Figura 2: Efeitos de letras queimando (acima), e vortex (abaixo)............................................23
Figura 3: Efeito de gua utilizando um sistema de partculas...................................................23
Figura 4: Imagens do filme animado Particle Dreams, acima uma tempestade de neve e abaixo
uma cabea respirando..............................................................................................................23
Figura 5: Partculas orbitando em volta de um ncleo (Acima), exploso (meio) e uma
cachoeira (abaixo).....................................................................................................................23
Figura 6: Coordenadas cartesianas, representa um espao tridimensional...............................25
Figura 7: Uma partcula nas posies t = 0, t = 1/2 e t = 1.......................................................26
Figura 8: Mtodo de Euler, estima o valor de yn+1 em funo de yn......................................30
Figura 9: Mtodo de Runge-Kutta de 2 ordem, nota-se uma maior preciso comparada com o
mtodo de Euler........................................................................................................................31
Figura 10: Mtodo Runge-Kutta de 4 ordem...........................................................................32
Figura 11: Arquitetura do sistema de partculas implementado nesse trabalho........................38
Figura 12: Classe que representa uma partcula........................................................................40
Figura 13: Classe que representa um sistema de partculas......................................................43
Figura 14: Classe que representa um gerenciador de sistemas de partculas............................45
Figura 15: Relao entre as trs classes principais do sistema.................................................46
Figura 16: Funcionamento de um loop responsvel por manter um jogo ou uma animao
rodando......................................................................................................................................48
Figura 17: Loop atualizado, incluindo a atualizao do sistema de partculas implementado
nesse trabalho............................................................................................................................49
Figura 18: Partculas nascendo de um ponto no espao cartesiano..........................................51
Figura 19: Partculas nascendo de um plano no espao cartesiano...........................................52
Figura 20: Partculas nascendo de um disco no espao cartesiano...........................................53
Figura 21: Partculas nascendo de um cubo no espao cartesiano............................................54
Figura 22: As foras podem agir em cada eixo separadamente, sem depender um do outro....59
Figura 23: Classe que representa as equaes diferenciais ordinrias de primeira ordem.......64
Figura 24: Classe que representa o mtodo Runge-Kutta.........................................................64
Figura 25: Loop atualizado, incluindo a parte de movimentao das partculas......................65
Figura 26: Fora da gravidade atuando apenas do lado esquerdo da origem............................68
Figura 27: Efeito de motion blur em uma foto..........................................................................69
Figura 28: Sistema de partculas sem motion blur....................................................................70
Figura 29: Sistema de partculas com motion blur....................................................................70
Figura 30: Sistema de partculas renderizada utilizando texturas.............................................70
Figura 31: Sistema de partculas renderizada sem usar texturas...............................................70
Figura 32: Partculas renderizadas como bolhas de ar..............................................................71
Figura 33: Partculas representando plos................................................................................71
Figura 34: Sistema de partculas feito pelo autor, mostrando as partculas no espao 3D.......72
Figura 35: Partculas sendo influenciadas pela gravidade no eixo X........................................73
Figura 36: Partculas sendo atradas por uma fora oposta da gravidade no eixo Y.................74
Figura 37: As partculas podem ser de qualquer de cor............................................................74
Figura 38: Partculas nascendo dentro de um cubo...................................................................75
Figura 39: Partculas ao longo do lado negativo do eixo x, sendo influenciadas pela gravidade.
...................................................................................................................................................75
Figura 40: Foras disponveis no sistema.................................................................................76
Figura 41: Interface de configurao da gravidade...................................................................77

Figura 42: Interface de configurao da resistncia do vento...................................................77


Figura 43: Interface de configurao da lei de Hook no sistema..............................................78
Figura 44: Interface de configurao da gravidade local..........................................................78
Figura 45: Interface de configurao da velocidade inicial......................................................79
Figura 46: Interface de configurao do ngulo, massa e tempo de vida das partculas..........80
Figura 47: Interface para configurao da cor inicial das partculas........................................81
Figura 48: Interface para a configurao da cor final das partculas........................................81
Figura 49: Interface de configurao do tamanho das partculas..............................................81
Figura 50: Interface para ligar ou desligar o canal alpha..........................................................82
Figura 51: Interface para a configurao do nascedouro das partculas...................................82

ndice de Equaes
Mtodo de Euler........................................................................................................................30
Fator k1 do mtodo de euler melhorado...................................................................................31
Fator k2 do mtodo de euler melhorado...................................................................................31
Mtodo de Euler melhorado......................................................................................................31
Fator k1 do mtodo de Runge-Kutta de 4 ordem.....................................................................32
Fator k2 do mtodo de Runge-Kutta de 4 ordem.....................................................................32
Fator k3 do mtodo de Runge-Kutta de 4 ordem.....................................................................32
Fator k4 do mtodo de Runge-Kutta de 4 ordem.....................................................................32
Mtodo de Runge-Kutta de 4 ordem........................................................................................32
O eixo x dado como um nmero aleatrio entre um valor inicial e um final.........................53
O eixo z dado como um nmero aleatrio entre um valor inicial e um final.........................53
Valor a ser usado para a obteno da raiz quadrada de um nmero aleatrio...........................54
O eixo x do nascedouro em forma de disco..............................................................................54
O eixo z do nascedouro em forma de disco..............................................................................54
O eixo x do nascedouro em forma de cubo dado como um nmero aleatrio entre um valor
inicial e um final.......................................................................................................................55
O eixo y do nascedouro em forma de cubo dado como um nmero aleatrio entre um valor
inicial e um final.......................................................................................................................55
O eixo z do nascedouro em forma de cubo dado como um nmero aleatrio entre um valor
inicial e um final.......................................................................................................................55
Segunda lei de Newton.............................................................................................................59
Segunda lei de Newton sobre o eixo x......................................................................................60
Segunda lei de Newton sobre o eixo y......................................................................................60
Segunda lei de Newton sobre o eixo z......................................................................................60
Segunda lei de newton no eixo x modificado...........................................................................60
Segunda lei de newton no eixo y modificado...........................................................................60
Segunda lei de newton no eixo z modificado...........................................................................60
Acelerao como a derivativa da velocidade em relao ao tempo..........................................61
Acelerao como a derivativa da velocidade no eixo x em relao ao tempo..........................61
Acelerao como a derivativa da velocidade no eixo y em relao ao tempo..........................61
Acelerao como a derivativa da velocidade no eixo z em relao ao tempo..........................61
Velocidade como a derivativa da posio em relao ao tempo...............................................61
Velocidade no eixo x como a derivativa da posio em x em relao ao tempo......................61
Velocidade no eixo y como a derivativa da posio em y em relao ao tempo......................61
Velocidade no eixo z como a derivativa da posio em z em relao ao tempo.......................61
Acelerao como a derivativa da velocidade pelo tempo.........................................................63
Velocidade como a derivativa da posio pelo tempo..............................................................63
Acelerao como uma derivativa vezes a derivativa da posio pelo tempo...........................63
Acelerao como a derivativa de segundo grau da posio pelo tempo...................................63
Equao da lei de Hook............................................................................................................63
Equao da lei de Hook modificado de acordo com a segunda lei de Newton........................63
Derivativa da velocidade como sendo a lei de Hook divido pela massa..................................63
Derivativa da posio em x como sendo a velocidade..............................................................63
Lei da gravitao universal.......................................................................................................67
Frmula da resistncia do vento................................................................................................68
Lei de Hook...............................................................................................................................68
A fora da lei de Hook no segundo objeto influenciado...........................................................68

Sumrio
RESUMO..................................................................................................................................11
1 INTRODUO.....................................................................................................................12
1.1 Apresentao..................................................................................................................12
1.2 Objetivos........................................................................................................................14
1.2.1 Objetivo Geral........................................................................................................14
1.2.2 Objetivos especficos..............................................................................................14
1.3 Justificativa.....................................................................................................................15
1.4 Metodologia....................................................................................................................15
1.5 Cronograma Proposto.....................................................................................................17
1.6 Cronograma Executado..................................................................................................18
2 FUNDAMENTAO TERICA.........................................................................................19
2.1 Introduo ao Sistema de Partculas...............................................................................19
2.1.1 Modelo bsico de um sistema de partculas...........................................................20
2.1.1.1 Gerao de partculas......................................................................................21
2.1.1.2 Atributos das partculas...................................................................................21
2.1.1.3 Dinmica das partculas..................................................................................23
2.1.1.4 Extino de partculas.....................................................................................23
2.1.1.5 Renderizao de partculas.............................................................................23
2.1.1.6 Hierarquia de partculas..................................................................................23
2.1.2 Exemplos de animaes geradas por sistemas de partculas..................................24
2.2 Mecnica Clssica..........................................................................................................25
2.2.1 Sistema de coordenadas Cartesianas......................................................................25
2.2.2 Vetores....................................................................................................................26
2.2.3 Massa......................................................................................................................26
2.2.4 Segunda Lei de Newton..........................................................................................27
2.2.5 Velocidade...............................................................................................................27
2.2.6 Acelerao..............................................................................................................28
2.2.7 Fora.......................................................................................................................28
2.3 Resolvendo problemas fsicos por meio de Mtodos Numricos..................................29
2.3.1 Soluo numrica de Equaes Diferenciais Ordinrias........................................29
2.3.1.2 Mtodos de Runge-Kutta................................................................................30
2.4 Programao Orientada a Objetos..................................................................................34
2.4.1 O que Programao Orientada a Objetos.............................................................35
2.4.2 Caractersticas da Programao Orientada a Objeto..............................................35
2.4.2.1 Encapsulamento..............................................................................................35
2.4.2.2 Abstrao de dados.........................................................................................36
2.4.2.3 Polimorfismo...................................................................................................36
2.4.2.4 Herana...........................................................................................................37
3 MODELAGEM E IMPLEMENTAO...............................................................................38
3.1 Arquitetura e modelagem de um Sistema de Partculas.................................................38
3.1.1 Criando as estruturas de dados de um sistema de partculas..................................39
3.1.1.1 Partcula..........................................................................................................39
3.1.1.2 Sistema de partculas.......................................................................................41
3.1.1.3 Gerenciador de Sistemas de partculas...........................................................44
3.2 Execuo do sistema de partculas.................................................................................48
3.2.1 Gerao das partculas............................................................................................50
3.2.1.1 Criando partculas dentro de nascedouros......................................................51
3.2.1.1.1 Primeiro nascedouro: Ponto....................................................................52

3.2.1.1.2 Segundo nascedouro: Plano....................................................................53


3.2.1.1.3 Terceiro nascedouro: Disco.....................................................................54
3.2.1.1.4 Quarta frma: Cubo.................................................................................55
3.2.1.2 Calculando valores iniciais usando processos estocsticos............................56
3.2.1.2.1 Utilizando processos estocsticos para controlar a quantidade de
partculas geradas no sistema.................................................................................56
3.2.1.2.2 Utilizando processos estocsticos para calcular valores iniciais para os
atributos das partculas...........................................................................................58
3.2.2 Movimento das partculas.......................................................................................59
3.2.2.1 Definindo a relao entre posio, velocidade, acelerao e fora.................59
3.2.2.2 Preparando as equaes diferenciais para o mtodo de Runge-Kutta............62
3.2.2.3 Modelando as classes EDO e Runge-Kutta....................................................64
3.2.2.4 As foras que agem no sistema.......................................................................66
3.2.2.4.1 Gravidade................................................................................................67
3.2.2.4.2 Resistncia do ar......................................................................................68
3.2.2.4.3 Lei de Hook.............................................................................................68
3.2.2.4.4 Gravidade Local......................................................................................69
3.3 Renderizao do sistema de partculas...........................................................................70
3.3.1 Renderizando as partculas como Pontos...............................................................70
3.3.2 Renderizando as partculas como Linhas...............................................................70
3.3.3 Renderizando as partculas como Texturas.............................................................71
3.3.4 Renderizando as partculas de maneira diferente...................................................72
4 Resultados..............................................................................................................................73
4.1 Mostrando o software em geral......................................................................................73
4.2 Explicando a interface do software................................................................................77
4.2.1 Alterando as foras do sistema...............................................................................77
4.2.1.1 Configurando a gravidade...............................................................................78
4.2.1.2 Configurando a resistncia do vento...............................................................78
4.2.1.3 Configurando a lei de Hook............................................................................79
4.2.1.4 Configurando a gravidade local......................................................................79
4.2.2 Alterando as propriedades fsicas das partculas....................................................80
4.2.2.1 Configurando a velocidade inicial..................................................................80
4.2.2.2 Configurando o ngulo inicial, massa e tempo de vida das partculas...........81
4.2.3 Alterando a aparncia das partculas.......................................................................81
4.2.3.1 Alterando a cor inicial e cor final das partculas.............................................81
4.2.3.2 Alterando o tamanho e adicionando transparncia s partculas....................82
4.2.4 Definindo nascedouros para o sistema...................................................................83
5 CONCLUSO.......................................................................................................................84
6 REFERNCIAS BIBLIOGRFICAS...................................................................................85

11
RESUMO
O presente trabalho visa apresentar um modelo e implementao de um sistema de
partculas utilizando fundamentos tericos nos artigos que falam sobre o tema, o objetivo
modelar e animar objetos no-determinsticos, nas quais as tcnicas clssicas da computao
grfica no conseguem atingir resultados satisfatrios.
O sistema de partculas foi introduzido por William Reeves em 1983 quando estava
com a responsabilidade de produzir efeitos especiais no filme Star Trekk 2: A fria de Khan, o
resultado foi um artigo cientfico explicando como que funciona esse efeito e a partir de
ento, muitos outros cientistas comearam a estender o sistema para produzir outros efeitos
interessantes e mais complexos.
Com levantamento bibliogrfico sobre as reas que so usadas para produzir um
sistema de partculas, como fsica, processos estocsticos e mtodos numricos, esse trabalho
produz uma monografia explicativa sobre o tema e que aborde todos os aspectos sobre a
construo de um sistema de partculas bsico utilizando a programao orientada a objeto.
O resultado um software que anima diversos efeitos abstratos na tela, juntamente
com uma interface que permite alterar o comportamento da animao, produzindo cada vez
mais efeitos.
Palavras-chave: sistema de partculas, computao grfica, mtodos numricos, fsica

12

1 INTRODUO
1.1 Apresentao
O homem sempre buscou registrar e expressar suas aes e arte por meio de desenhos,
como possvel observar por meio de figuras achadas em cavernas e das animaes feitas
com papel e lpis. Hoje no diferente, mas em vez de carvo, giz ou papel usa-se o
computador para desenhar figuras e gerar animaes que cada vez mais se parecem com o
mundo real.
Shirley(2005) diz que a computao grfica a rea da Cincia da Computao que
descreve o uso de computadores para criar e manipular imagens e tambm responsvel pelo
progresso da animao criada por computadores. Uma animao simplesmente um conjunto
de figuras que so passadas rapidamente de forma consecutiva.
No decorrer da evoluo da computao grfica e da animao por computador, houve
um certo tempo em que a necessidade era mostrar imagens mais parecidas com o mundo real,
objetos que no possuam um forma fsica definida no eram facilmente gerados no
computador usando as tcnicas daquele tempo, que consistia em modelar objetos usando
primitivas como polgonos em geral.
Fenmenos e elementos da natureza como chuva, furaces, fogo, galxias, gua,
gases, nuvens, flora em geral e efeitos como exploses no eram possveis de se representar
usando as tcnicas clssicas da Computao Grfica, pois esses elementos no possuem uma
superfcie slida e tambm no so estticos e suas formas mudam com o tempo, por esse
motivo, so chamados de objetos com forma no-determinstica, ou seja, so objetos que no
possuem uma forma definida no tempo, segundo Reeves(1983).
Uma das tcnicas que apareceu para simular esses efeitos o sistema de partculas
introduzido por William Reeves em seu artigo pela SIGGRAPH1 83, na qual consiste em
vrias primitivas ( representadas por pontos no espao tridimensional ) sendo manipuladas e
1 Conferncia internacional anual realizada por entusiastas da computao grfica.

13
renderizadas individualmente. Um sistema de partculas difere em trs aspectos em relao
modelagem tradicional na computao grfica: Primeiro, o objeto representado atravs de
partculas (pontos) e no atravs de polgonos ou superfcies, os pontos que apresentam o
volume e a forma do objeto num dado instante. Segundo: Um sistema de partculas no uma
entidade esttica, ela se move e muda de forma com o passar do tempo. Novas partculas
nascem e partculas velhas morrem. Terceiro: O objeto representado por esse sistema no
determinstico, ou seja, no possui uma forma ou superfcie definida e, com o passar do
tempo, essa forma muda.
O presente trabalho visa demonstrar o desenvolvimento de um sistemas de partculas
utilizando o paradigma de programao orientada a objeto (POO).

14

1.2 Objetivos
1.2.1 Objetivo Geral
A fim de contribuir para a rea de Computao Grfica, no que concerne a rea de
animao utilizando sistemas de partculas, este trabalho tem como objetivo implementar um
sistema de partculas bsico utilizando todos os conceitos do paradigma de programao
orientada a objeto.

1.2.2 Objetivos especficos


Para alcanar o objetivo citado anteriormente, estudos sero feitos sobre o sistema de
partculas e sobre as reas que suportam esse sistema, dentre as quais citamos: Mecnica
Clssica e Mtodos Numricos. Os seguintes passos sero seguidos:

Estudar a Mecnica Clssica Newtoniana e aplicar esses conceitos na implementao


de um sistema de partculas.

Estudar o mtodo numrico de Runge-Kutta de 4 ordem utilizado na resoluo de


equaes diferenciais ordinrias e aplicar esse mtodo para promover a movimentao
das partculas.

Estudar o Sistema de partculas proposto por William Reeves.

Estudar os conceitos do paradigma de programao orientada a objeto e suas


aplicaes no desenvolvimento de um sistema de partculas.

Implementar o sistema de partculas proposto por William Reeves utilizando conceitos


do paradigma de programao orientada a objeto e conhecimentos da Mecnica
Newtoniana e mtodos numricos.

15

1.3 Justificativa
O sistema de partculas proposto por William Reeves, trouxe uma enorme ampliao
nas aplicaes da Computao Grfica sendo que, antes disso no era possvel ou era muito
difcil modelar e animar elementos da natureza e objetos no-determinsticos. Na literatura
difcil retirar informaes suficientes para implementar um sistema de partculas, pelo fato
dessas informaes estarem separadas, sendo que em artigos de Computao Grfica
consultados, no mostrado em profundidade a fsica utilizada no sistema, e os livros de
fsica no mostram a parte de renderizao e efeitos especiais.
Neste trabalho procura-se organizar o contudo necessrio para a implementao de
um sistema de partculas, enfatizando a parte terica necessria para a compreenso dos
conceitos fsicos envolvidos, a parte grfica e a implementao, de modo que o leitor possa ter
uma compreenso global do problema.

1.4 Metodologia
O presente trabalho ser feito atravs dos seguintes passos:

Levantamento bibliogrfico e implementao dos tpicos da Mecnica Clssica


Newtoniana que apresentem uma aplicao no desenvolvimento de um sistema de
partculas.

Levantamento bibliogrfico e implementao do mtodo de Runge-Kutta de 4 ordem,


que um tpico de Mtodos Numricos que visa a resoluo de equaes diferenciais
ordinrias.

Levantamento bibliogrfico sobre o Sistema de partculas proposto por William


Reeves (1983) e suas aplicaes.

Implementar um sistema de partculas utilizando os tpicos da Mecnica Clssica


Newtoniana e o mtodo de Runge-Kutta de 4 ordem. Tudo isso por meio do
paradigma de programao orientada a objeto.

16

As tecnologias usadas sero: A linguagem de programao Java, e a biblioteca JOGL,


que a ligao do OpenGL com o Java.
Ou seja, a metodologia usada consiste em levantamentos bibliogrficos a respeito dos

assuntos j citados e implementaes dos tpicos desses assuntos que forem relevantes para a
implementao de um sistema de partculas segundo o paradigma de programao orientada a
objeto.

17

1.5 Cronograma Proposto


O presente trabalho foi desenvolvido tendo em mente o cronograma abaixo, que foi
elaborado com base nos objetivos especficos e na metodologia adotada com propsito de
alcanar o objetivo geral proposto.
Meses/Semanas
Etapas

Agosto
1

Setembro
3

Outubro
3

Novembro
3

Dezembro
3

Etapa 1
Etapa 2
Etapa 3
Etapa 4
Etapa 5
Etapa 6

Etapa 1 Estudo bibliogrfico sobre Sistemas de Partculas


Um estudo foi feito sobre o sistema de partculas em si, para obter uma viso geral e
responder perguntas como: o que um sistema de partculas? Como funciona? Etc.
Etapa 2 Estudo bibliogrfico aprofundado da mecnica clssica newtoniana
Esse estudo visa obter uma viso geral da fsica por trs do sistema de partculas.
Etapa 3 Estudo bibliogrfico sobre Mtodos Computacionais
Visa obter conhecimento sobre o mtodo numrico de Runge-Kutta de 4 ordem.
Etapa 4 Estudo da implementao de um sistema de partculas utilizando o paradigma
de Programao Orientada a Objetos
Visa demonstrar a modelagem do sistema atravs do conceito de programao
orientada a objeto e a implementao do sistema, dando mais ateno aos detalhes e
utilizando todos os conceitos vistos at ento.
Etapa 5 Demonstrao dos resultados
Mostra os resultados obtidos do sistema implementado.
Etapa 6 Apresentao para a banca examinadora
Apresentao do trabalho e do sistema implementado banca examinadora.

18

1.6 Cronograma Executado


O presente trabalho foi desenvolvido de acordo com o cronograma abaixo.
Meses/Semanas
Etapas

Agosto
1

Setembro
3

Outubro
3

Novembro
3

Dezembro
3

Etapa 1
Etapa 2
Etapa 3
Etapa 4
Etapa 5
Etapa 6

Etapa 1 Estudo bibliogrfico sobre Sistemas de Partculas


Um estudo foi feito sobre o sistema de partculas em si, para obter uma viso geral e
responder perguntas como: o que um sistema de partculas? Como funciona? Etc.
Etapa 2 Estudo bibliogrfico aprofundado da mecnica clssica newtoniana
Esse estudo visa obter uma viso geral da fsica por trs do sistema de partculas.
Etapa 3 Estudo bibliogrfico sobre Mtodos Computacionais
Visa obter conhecimento sobre o mtodo numrico de Runge-Kutta de 4 ordem.
Etapa 4 Estudo da implementao de um sistema de partculas utilizando o paradigma
de Programao Orientada a Objetos
Visa demonstrar a modelagem do sistema atravs do conceito de programao
orientada a objeto e a implementao do sistema, dando mais ateno aos detalhes e
utilizando todos os conceitos vistos at ento.
Etapa 5 Demonstrao dos resultados
Mostra os resultados obtidos do sistema implementado.
Etapa 6 Apresentao a banca examinadora
Apresentao do trabalho e do sistema implementado banca examinadora.

19

2 FUNDAMENTAO TERICA
2.1 Introduo ao Sistema de Partculas
Segundo Reeves(1983), fenmenos como nuvens, gua, fumaa e fogo tem provado
ser difcil de modelar e animar com as tcnicas tradicionais de sntese de imagens da
computao grfica.
Objetos como esses citados no possuem uma forma definida, tal como um carro ou
uma mesa, em vez disso suas formas so complexas, mudam com o tempo e so
completamente irregulares. Assim, William Reeves props uma tcnica para a modelagem de
objetos no-determinsticos, na qual ele chamou de Sistema de partculas.
A apresentao do mtodo proposto por Reeves se diferencia das tcnicas tradicionais
de modelagem em trs pontos:
1) Um objeto no representado por polgonos ou por qualquer forma que defina sua
superfcie, mas polgonos primitivos ( pontos e linhas ) definem seu volume.
2) Um sistema de partculas no uma entidade esttica, as partculas se movimentam
com o passar do tempo. Novas partculas nascem e velhas partculas morrem.
3) Um objeto representado por um sistema de partculas no determinstico, j que sua
forma no completamente especificada, no entanto, mtodos estocsticos ( que
utilizam aleatoriedade ) so usados para criar e mudar forma e aparncia do objeto.
Algumas das vantagens que William Reeves fala que o sistema de partculas traz,
que as partculas so primitivas simples de renderizar, por isso, muitas partculas podem ser
renderizadas na tela, dando assim um maior realismo na modelagem do objeto nodeterminstico.
Outra vantagem que o sistema de partculas se auto-ajusta atravs de nmeros
aleatrios, ou seja, as partculas se comportam de acordo com um algoritmo pr-estabelecido
que atualizado atravs da aleatoriedade, o que faz com que o sistema no precise de controle
humano durante a sua execuo. E tambm porque esse sistema modela objetos que esto
'vivos', o que extremamente difcil de se conseguir com as tcnicas convencionais de
modelagem e animao.

20

2.1.1 Modelo bsico de um sistema de partculas


Em seu artigo, Reeves segue dizendo que as partculas so geradas no sistema, so
movidas, transformadas e mortas dentro do sistema. Para que a animao ocorra, os
seguintes passos so executados:
1. Novas partculas so geradas dentro do sistema.
2. Os atributos individuais de cada nova partcula so inicializados.
3. Qualquer partcula que j tenha ultrapassado seu tempo de vida so excludos do
sistema
4. As partculas existentes so movidas e transformadas de acordo com suas
especificaes. Por exemplo, se a partcula tem um movimento circulatrio, assim ela
se mover.
5. Uma imagem, ou primitiva que representa uma partcula, renderizado na tela.
Qualquer modelo matemtico pode ser usado para definir o comportamento e a
aparncia das partculas dentro do sistema. Por exemplo, o movimento das partculas poderia
ser implementado usando um mtodo de resoluo de equaes diferenciais ordinrias ( que
o caso desse trabalho ) na qual, a cada atualizao do sistema, as equaes dariam um novo
valor posio das partculas.
Assim como a aparncia tambm pode ser modelada de vrias formas, embora a forma
mais simples seja o uso de pontos ou linhas, cada partcula pode ser representada como uma
imagem ou um objeto poligonal.

21
2.1.1.1 Gerao de partculas

Segundo Reeves(1983), partculas so geradas por meio do controle de processos


estocsticos. Um processo determina o nmero de partculas que estaro entrando no sistema
a cada intervalo de tempo, ou seja, a cada frame da animao. O nmero de partculas define a
densidade do objeto que est sendo modelado. A gerao de partculas a cada frame definida
atravs da frmula:

nParticulas = nPartDesejadas + rand()*variaoParticulas

Onde 'rand()' gera um nmero pseudo-aleatrio entre -1.0 e 1.0, 'nPartDesejadas' o


nmero de partculas que o usurio quer que o sistema gere e 'variaoPartculas' a variao
que o nmero de partculas vai possuir, ou seja, se o usurio deseja que o sistema gere 50
partculas a cada frame, com uma variao de 50, o nmero de partculas que o sistema gerar
ser:

nParticulas = 50 + rand()*50
Supondo que rand() retorne 0.5, nParticulas ser 50 + 0.5*50 = 75. O sistema ir gerar

75 novas partculas nesse frame da animao, o que influencia fortemente na densidade do


objeto que esta sendo representado.

2.1.1.2 Atributos das partculas

Para cada nova partcula gerada, o sistema de partculas deve determinar valores para
cada um dos seguintes atributos:
1. Posio inicial
2. Velocidade inicial ( velocidade e direo )
3. Tamanho inicial
4. Cor inicial
5. Transparncia inicial
6. Forma ( geralmente ponto ou linha )
7. Tempo de vida

22
Um sistema de partculas tem sua posio no espao tridimensional que define sua
origem e dois ngulos de rotao sobre o sistema de coordenada na origem do sistema de
partculas. Um sistema de partculas tambm possui um nascedouro, que uma regio onde as
partculas so aleatoriamente colocadas para nascer, desde que a posio inicial delas seja
dentro dos limites do nascedouro. Dentre esses nascedouros pode-se citar uma esfera, um
cubo, um crculo, um plano ou um simples ponto.

Figura 1: Sistema de partculas com um nascedouro em forma de esfera,


as partculas nascem aleatoriamente em posies que estejam dentro da
esfera.

23
2.1.1.3 Dinmica das partculas

Partculas se movem no espao tridimensional, assim como mudam suas cores,


transparncias e formas. Para mover uma partcula de um frame para o prximo, basta
adicionar o vetor de velocidades para o vetor de posio de cada partcula. Para aumentar a
complexidade, pode-se adicionar leis da fsica, para que as partculas se comportem como no
mundo real, o que o presente trabalho traz como proposta de implementao. As cores, formas
e transparncias das partculas podem ser controlados por processos estocsticos, tal como a
gerao de partculas feita.
2.1.1.4 Extino de partculas

Quando gerada, dada para uma partcula um tempo de vida baseada no nmero de
frames na qual essa partcula ir agir, depois de passado esse tempo a partcula deletada do
sistema, outros mecanismos permitem extinguir a partcula quando ela no contribui mais
para a imagem, isso acontece quando ela fica transparente ou quando sua cor se torna igual ao
da cor de fundo, ou quando ela sai dos limites do monitor do computador.
2.1.1.5 Renderizao de partculas

Quando a posio das partculas e seus atributos estiverem atualizados, basta desenhar
a imagem ou primitiva que represente a partcula no monitor do computador. Quando
partculas se encontram, a coliso pode ou no ser detectada. Sombras podem ou no ser
necessrias, j que partculas podem ser implementadas para emitir luz. A cena em que o
sistema de partculas se encontra pode ou no interagir com o sistema.
2.1.1.6 Hierarquia de partculas

O sistema de partculas proposto por Reeves possui um mecanismo que controla a


formao e o controle das partculas. Vrios sistemas de partculas podem ser colocadas, cada
uma com um movimento e comportamento diferente, todos eles controlados por um sistema
'pai', por exemplo, um objeto no-determinstico complexo como uma nuvem pode ser
representado por vrios sistemas, cada um cuidando de um aspecto da nuvem.
No alto da hierarquia, o sistema pai pode inclusive cuidar dos efeitos da gravidade ou
vento, mandando esse efeito para todos os sistemas que esto sobre seu domnio.

24

2.1.2 Exemplos de animaes geradas por sistemas de partculas


Segundo Sims(1990), o filme animado Particle Dreams foi criado inteiramente usando
sistemas de partculas. Dentre os efeitos apresentados no filme, pode-se citar fogos orbitais,
tempestades de neve, cachoeiras,etc. Ser mostrado abaixo figuras extradas de seu artigo para
SIGGRAPH 90, o que tornou possvel fazer com sistemas de partculas na computao
grfica.

Figura 2: Efeitos de
letras queimando
(acima), e vortex
(abaixo).

Figura 3: Efeito de gua utilizando


um sistema de partculas.

Figura 4: Imagens do
filme animado Particle
Dreams, acima uma
tempestade de neve e
abaixo uma cabea
respirando.

Figura 5: Partculas orbitando em volta de um ncleo


(Acima), exploso (meio) e uma cachoeira (abaixo).

25

2.2 Mecnica Clssica


Um sistema de partculas pode ser regido pelas leis fsicas da Mecnica clssica
desenvolvido por Sir Isaac Newton. Segundo Bourg(2002), Newton formulou as famosas Leis
do Movimento, que so ditadas a seguir:
1. Um corpo tende a permanecer em movimento em uma linha reta com uma velocidade
constante, at que uma fora externa venha agir sobre ele. Esse o conceito de inrcia.
2. A acelerao de um corpo proporcional da fora resultante que age no corpo, e essa
acelerao na mesma direo que a fora resultante.
3. Para toda fora agindo sobre um corpo, h uma fora de igual intensidade em sentido
contrrio fora que est agindo no corpo.
O sistema de partculas proposto por Reeves, pode ser regido por essas leis, mais
precisamente pelas duas primeiras. Pode-se citar como exemplo a simulao de exploses e
balstica que utilizam largamente esses conceitos. As prximas sees tratam de algumas
partes da Mecnica Clssica que so usadas diretamente para a fsica de partculas neste
trabalho.

2.2.1 Sistema de coordenadas Cartesianas


O sistema de coordenadas cartesianas uma abstrao do espao, onde objetos podem
ser representados como pontos ao longo de trs eixos geralmente nominados como x, y e z.
Sabendo a distncia desse ponto de origem ( x = 0, y = 0, z = 0 ), pode-se obter as
coordenadas do ponto, revelando assim sua exata posio. Partculas so representadas como
pontos no espao tridimensional e cada partcula possui uma posio em cada eixo do sistema
de coordenadas, ou seja, possui um valor x, y e z. A figura 6 mostra exemplos de desenhos
representando um sistema de coordenadas cartesianas.

26

Figura 6: Coordenadas cartesianas, representa um espao tridimensional.

2.2.2 Vetores
Quando algum fala que um cesto de mas contm 5 mas, o nmero 5 est se
referindo a quantidade de mas na cesta, esse valor algo que por si s j possui um
significado completo. Mas quando algum fala que um objeto est a 100 km/h, pode-se inferir
apenas a intensidade da velocidade, mas, em que direo e em qual sentido o objeto est se
movendo? O valor no caso da cesta de mas chamado de grandeza escalar, enquanto que o
valor da velocidade do objeto chamado de grandeza vetorial, sendo representado por um
vetor, isso porque um vetor demonstra tanto a intensidade, direo e sentido.
Segundo Millington(2007), um vetor representa uma mudana na posio de um
ponto. Partculas so pontos que se movem constantemente no espao tridimensional, por
isso, a representao da velocidade, acelerao e das foras que agem nas partculas sero
representadas como vetores, pelo simples fato de que todos esses fatores possurem uma
intensidade, uma direo e um sentido.

2.2.3 Massa
A massa de um corpo geralmente interpretado como a quantidade de matria que o
corpo possui. No caso de fsica focada em computao e mais especificamente em um sistema
de partculas, a massa pode ser interpretada como a quantidade de resistncia que a partcula
ir ter contra uma alterao de sua posio.

27

2.2.4 Segunda Lei de Newton


A massa desempenha um papel muito importante na segunda lei de Newton como se
pode ver pela frmula: F = ma, sendo 'm' a quantidade massa que a partcula possui e 'a' a
acelerao da partcula, F seria a fora resultante que age na partcula.
Manipulando a equao, para que fique assim: a = F/m, percebe-se que a massa da
partcula oferece resistncia a movimentao ou a fora aplicada sobre ela, a fora resultante
ser reduzida proporcionalmente a massa.
Quanto maior a massa de uma partcula, mais difcil ser de mudar a posio dela,
assim como, quanto menor a massa, mais fcil ser de movimentar a partcula. Num sistema
de partculas, geralmente calcula-se todas as foras primeiro e depois pega esse resultado e
divide-se pela massa, gerando ento a acelerao da partcula num dado instante.

2.2.5 Velocidade
Como dito anteriormente, a velocidade representada por um vetor porque possui uma
intensidade, direo e um sentido. Por definio, velocidade significa a distncia percorrida
num dado intervalo de tempo. Por exemplo, uma partcula no espao em uma determinada
hora ( supondo t = 0 ) est numa posio x, passado dois segundos, a posio da partcula
mudou para x + 2, ou seja, a partcula andou 1 posio para cada segundo passado, ento diz
que a partcula teve uma velocidade de 1 p/s ( posio por segundo ). Em termos de fsica
focada em computao e mais precisamente em sistemas de partculas, pode-se dizer que a
velocidade ser o tanto de posio que a partcula ir andar a cada passagem de tempo, ou
seja, quanto maior for a velocidade, mais distante a partcula ir se deslocar a cada acrscimo
de tempo.

Figura 7: Uma partcula nas posies t = 0, t =


1/2 e t = 1.

28

2.2.6 Acelerao
Acelerao a taxa com que a velocidade de uma partcula aumentada. Por exemplo,
como citado anteriormente na frmula da segunda lei de Newton, a acelerao pode ser obtida
atravs da razo da fora resultante com a massa, depois de calculado a acelerao, ela
somada com a velocidade, fazendo com que a partcula fique mais rpida.

2.2.7 Fora
Certos fenmenos fsicos so chamados de foras, sendo que uma fora toda 'energia'
que, segundo Millington(2007), faz com que a acelerao ou movimento de um objeto mude.
Ao arrastar uma caixa, percebe-se que deve fazer fora para empurr-la, isso acontece
porque uma fora chamada atrito ( da caixa com o cho ) est dificultando o processo, ou seja,
o atrito uma fora que est mudando a acelerao da caixa ( nesse caso, retardando o
aumento da acelerao ). No caso de um sistema de partculas, toda fora far alguma
mudana de movimento em cada partcula, desde de que a massa da partcula no seja muito
grande, caso contrrio, a partcula mal se mover.
Como exemplos de foras podemos citar o vento, gravidade, presso, etc. A acelerao
de uma partcula determinada pela soma de todas as foras dividido pela massa, sendo
assim, os passos para se realizar a movimentao das partculas ficaria o seguinte:
1. Calcula-se as propriedades da partcula como massa, posio inicial, velocidade, etc.
2. Identifica e calcula todas as foras atuantes no sistema.
3. Pegue a soma de todas as foras.
4. Calcula a acelerao atravs da segunda lei de Newton manipulada: a = F/m.
5. Atualiza a posio, velocidade da partcula utilizando mtodos de resoluo de
equaes diferenciais ordinrias.

29

2.3 Resolvendo problemas fsicos por meio de Mtodos Numricos


Muitos problemas fsicos so modelados por meio de equaes diferenciais ordinrias,
em funo de suas caractersticas, a resoluo desses modelos exigem tcnicas numricas. No
caso da Mecnica Clssica que foi exposta anteriormente, as equaes diferenciais ordinrias
como a de acelerao (supondo que a mesma no seja constante ) no podem ser resolvidos
com a preciso que necessria numa animao de um sistema de partculas sem tais mtodos
numricos.
Segundo Trefethen(2008), quando cientistas e engenheiros precisam de respostas
numricas para problemas matemticos, eles se voltam para os computadores. Mtodos
numricos o estudo de algoritmos para a soluo de problemas da matemtica contnua.
Muitas pessoas imaginam que cientistas e matemticos criam uma frmula, e ento,
inserindo nmeros nessas frmulas os computadores calculam os resultados necessrios. Na
realidade no bem assim. Em muitos casos a computao no pode ser feita com frmulas,
porque a maioria dos problemas matemticos no podem ser resolvidas com uma seqncia
finita de operaes elementares. O que acontece que algoritmos rapidamente convergem
para aproximaes das respostas com uma preciso de 3, 10 dgitos, etc. Para uma aplicao
cientfica de um fenmeno fsico, essas aproximaes so uma resposta to boa quanto a
resposta exata.

2.3.1 Soluo numrica de Equaes Diferenciais Ordinrias


A resoluo de equaes diferenciais ordinrias atravs de mtodos numricos consiste
em calcular aproximaes dos resultados dessas equaes, por meio de algoritmos que quando
executados, oferecem um valor prximo do valor exato da equao. No caso da equao da
segunda lei de Newton, cada vez que o sistema de partculas atualizasse seus movimentos, um
algoritmo de resoluo de equaes diferenciais calcularia um valor aproximado e atualizaria
a posio da partcula.
Nos problemas de valor inicial como o caso das equaes da Mecnica Clssica
usadas no presente trabalho, existem muitos mtodos para resolver tais equaes, cada um

30
com seus pontos fracos e fortes. Dentre eles podemos citar o mtodo de Euler, os mtodos de
Runge-Kutta que consistem numa srie de mtodos, extrapolao de Richardson e mtodos
multi-passo. No contexto desse trabalho optou-se pelo mtodo de Runge-Kutta de 4 ordem
em funo de sua preciso.

2.3.1.2 Mtodos de Runge-Kutta

Segundo Press(2007), os mtodos de Runge-Kutta propagam a soluo sobre um


intervalo combinando a informao provida de muitos passos do estilo do mtodo de Euler
(cada um com avaliao do lado direito da funo), e ento usando a informao obtida para
conseguir uma correspondncia a uma srie de Taylor.
O mtodo de Runge-Kutta de 4 ordem uma evoluo de seu antecessor, o mtodo de
Euler para resoluo de equaes diferenciais ordinrias, que nada menos que o mtodo de
Runge-Kutta de 1 ordem, na qual a equao :
y n1= y n h x n , y n

(1)

O mtodo de Euler no usado na prtica pelo fato de ser pouco preciso e instvel, ou
seja, dependendo do valor que ele processa, os resultados podem variar muito do resultado
esperado e assim oferecendo valores imprecisos, na prtica, isso significaria que as partculas
no iriam se comportar como no mundo real e poderiam inclusive demonstrar um
comportamento bem longe do esperado, a seguir ser mostrado como se chega ao mtodo de
Runge-Kutta de 4 ordem atravs do mtodo de Euler.
Na equao anterior, o termo esquerda da igualdade significa o prximo valor de y,
na prtica isso significaria a prxima posio da partcula. A prxima posio obtida
pegando a posio inicial ( yn ) e somando com a multiplicao de um intervalo de tempo ( h )
com a equao diferencial ordinria que esta sendo resolvida ( como exemplo podemos citar a
segunda lei de Newton F = ma, na sua forma a = F/m ou dv/dt = F/m ).
Como dito anteriormente, o mtodo de Euler no muito preciso, por isso, segundo
Press(2007), essa equao pode ser melhorada adicionando um passo intermedirio,
melhorando a preciso do mtodo. A figura 8 mostra o que o mtodo de Euler faz para chegar

31
ao resultado. O passo 2 conseguido simplesmente com o passo 1 mais o intervalo de tempo
requerido junto com a funo.

Figura 8: Mtodo de Euler, estima o valor de yn+1 em funo de yn.


A preciso do mtodo de Euler no das melhores, j a equao 4 abaixo, que
representa o mtodo de Euler melhorado ou mtodo de Runge-Kutta de 2 ordem, adiciona um
passo intermedirio entre os passos 1 e 2 da figura 8, o que faz a preciso do algoritmo
melhorar.
k 1=h x n , y n

(2)

k
h
k 2 =h x n , y n 1
2
2

(3)

y n1= y n k 2

(4)

A figura 9 mostra a melhora do algoritmo de 2 ordem em relao ao de 1 ordem


( Mtodo de Euler ). Os passos 2 e 4 so os passos intermedirios acrescidos na equao, o
que causa um aumento na preciso do resultado acrescido com um aumento no intervalo de
processamento do algoritmo.

32

Figura 9: Mtodo de Runge-Kutta de 2 ordem, nota-se uma maior


preciso comparada com o mtodo de Euler.
Mas no para por ai, a idia bsica do mtodo de Runge-Kutta ir adicionando passos
intermedirios, aumentando assim a sua preciso. Um algoritmo clssico usado por cientistas
o mtodo de Runge-Kutta de 4 ordem que mostrado a seguir, que obtido do mtodo de
2 ordem mostrado anteriormente. Esse mtodo simplesmente aumenta o nmero de passos
intermedirios aumentando assim a sua preciso num timo nvel e mantendo um tempo de
processamento no muito longo, se tornando adequado para o uso de um animao de um
sistema de partculas.
k 1=h x n , y n

(5)

k
h
k 2 =h x n , y n 1
2
2

(6)

k
h
k 3=h x n , y n 2
2
2

(7)

k 4 =h x n h , y nk 3

(8)

h
y n1= y n k 12k 22k 3k 4
6

(9)

O prximo valor de y ( posio de uma partcula no nosso caso ) dado pelo valor
atual mais os passos intermedirios multiplicados por pesos. A figura 10 demonstra o que esse
mtodo faz.

33

Figura 10: Mtodo Runge-Kutta de 4 ordem.


Para muitos cientistas, o mtodo de Runge-Kutta de 4 ordem no somente a
primeira palavra em algoritmos para soluo de equaes diferenciais ordinrias mas tambm
a ltima palavra. No presente trabalho, esse mtodo foi escolhido para resolver as equaes
presentes na fsica clssica, pelo fato de esse mtodo ser eficiente e rpido em seu
processamento.
Atravs da Mecnica Clssica e o mtodo Runge-Kutta de 4 ordem para resolver as
equaes da fsica, um sistema de partculas atinge um comportamento realista em seus
movimentos, com isso a simulao de efeitos de exploses por exemplo, iro se parecer como
no mundo real, levando a computao grfica ao nvel de simulao fiel ao realismo e no
uma simples rea que simplesmente faz desenhos no computador.

34

2.4 Programao Orientada a Objetos


Dentro da computao existem vrios paradigmas, (tambm chamados de filosofias)
de programao. O jeito que se programa determinado software pode mostrar como ser sua
manuteno no futuro, sua performance e sua legibilidade. Quando se fala de um sistema de
partculas, esta se falando de um sistema de computao que simula na tela de um computador
objetos que no possuem forma fsica permanente, isso quer dizer que a tcnica de Reeves
tambm um software e deve ser programado.
Antes de falar sobre o paradigma de programao orientado a objeto, ser apresentado
uma reviso superficial sobre o que um sistema de partculas na prtica. Nesse sistema, cada
partcula possui seus atributos e comportamentos prprios e so independentes uns dos outros,
cada elemento possui posio, acelerao, velocidade, cor, tempo de vida, forma ( geralmente
representado por um ponto ), etc. Os atributos podem ser vrios. O sistema como um todo ir
atualizar cada partcula usando as foras que atuam no ambiente, ou seja, no software ir
existir um componente que ir controlar a atualizao das partculas e calcular as foras, esse
componente pode ser chamado de Controlador de partculas por exemplo e tambm
possuir atributos prprios.
Percebe-se que um sistema de partculas possui muitos objetos em cena, a saber, o
controlador e muitas partculas. A cena pode muito bem aumentar, fazendo mais controladores
por exemplo que controlem cada tipo de sistema de partcula: um controlador para o sistema
que simula um furaco, outro que controle o sistema de exploso, outro para simulao de
neve, chuva, etc. E ainda fazer um controlador mestre que controle todos esses sistemas.
Dessa maneira, o paradigma mais apropriado, ou o mais intuitivo para se implementar
a tcnica de Reeves seria a Programao Orientada a Objeto, ou seja, cada componente do
sistema, assim como cada partcula seriam objetos e cada um desses objetos possuiria
atributos e comportamentos prprios. Sendo assim, essa filosofia de programao a
escolhida nesse trabalho para implementar um sistema de partculas.

35

2.4.1 O que Programao Orientada a Objetos


Segundo Pokkunuri(1989), uma metodologia de programao que enfatiza o uso de
objetos, seus atributos, comportamentos e relacionamento com outros objetos. Nesse
paradigma de programao, um objeto um elemento primitivo, cada objeto combina dados
e procedimentos, sendo estes ltimos chamados de mtodos que dizem qual o
comportamento do objeto e o que ele pode fazer. Cada objeto pode ser visto como um tipo de
dado abstrato, que definido pelo usurio.
Geralmente se implementa frmas de objetos ( chamados de classes, na maioria das
linguagens de programao orientados a objeto ) que seria como um objeto genrico, do qual
serve de padro para todos os outros objetos. Quando uma classe est pronta, ela pode ser
instanciada para que se forme os objetos, cada objeto possui uma rea de memria reservada
para ele.

2.4.2 Caractersticas da Programao Orientada a Objeto


2.4.2.1 Encapsulamento

Cada objeto uma entidade autnoma e integral. Ele precisa de recursos para
manifestar seus estados e comportamentos. Pode ser visto como uma entidade encapsulada e
protegida, seus dados so privados ( ou no ) e so escondidos de outros objetos. Sua
interao com outros objetos se d por meio de mensagens que so mandadas e respondidas e
cada objeto tem uma viso limitada de outro objeto.
Em um sistema de partculas, cada partcula seria um objeto autnomo e independente,
assim como os controladores delas. Cada partcula possui os seus atributos apenas para si
mesmas e podem ser atualizadas de maneira diferente, j que so independentes uma das
outras. A relao entre os controladores e as partculas se daria por meio de mensagens que
um passa para o outro.

36
2.4.2.2 Abstrao de dados

Segundo Pokkunuri(1989), abstrao de dados o princpio de que programas no


deveriam se preocupar em saber o detalhes da implementao ou representao interna.
Em POO ( Programao Orientada a Objetos ), cada objeto pode ser chamado para o
envio de qualquer informao ou servio por meio de mensagens. Aquele que pede o servio
no est preocupado em como a informao/servio processada e enviada, mas sim com o
que ele pede e o que recebe. Como exemplo, num sistema de partculas um objeto controlador
pode solicitar a uma partcula uma informao sobre a fora que est atuando nela naquele
momento, o objeto partcula simplesmente envia a informao para o controlador, este no
sabe como a partcula processa essa informao, ele simplesmente a recebe. A vantagem que a
abstrao de dados traz que o programador no precisa ficar se preocupando com detalhes
de implementao e assim ele pode programar a lgica do sistema mais rapidamente.
2.4.2.3 Polimorfismo

Nas linguagens de programao convencionais, os operadores, funes etc. so


vinculadas para suas respectivas operaes em tempo de compilao ( vinculao esttica ),
sendo assim, eles possuem um nome e um operador, como exemplo podemos citar uma
funo 'print', essa funo nica no sistema e imprime na tela apena uma mensagem.
Em POO, a vinculao do operador feita em tempo de execuo ( vinculao
dinmica ), a mensagem/operador 'print' para um objeto mandado para o 'print' especfico do
objeto, que decidido em tempo de execuo e no em tempo de compilao. A funo 'print'
em cada objeto pode ter comportamentos diferentes, mesmo que o objeto chamador mande
uma nica mensagem, o objeto que a receber ir se comportar de acordo com a sua definio
da funo. A mensagem 'print' recebe respostas diferentes, o que chamado de polimorfismo.
A aplicao do polimorfismo se torna clara num sistema de partculas. Podemos ter um
sistema que simula vrios efeitos, ao atualizar o sistema como um todo, o objeto controlador
pode mandar uma nica mensagem para todas as partculas do sistema, como exemplo
'atualizar posio', ento cada partcula ir se comportar da maneira que foi programada.

37
2.4.2.4 Herana

Em linguagens de programao convencionais, funes como 'print' devem ser


sobrescritos quando se deseja alterar algo deles ou quando novos atributos so adicionados no
programa. Em POO isso pode ser melhorado pela Herana, que o fato de uma classe poder
ser escrita uma vez e em seguida ser escrito classes que herdam os atributos e
comportamentos da primeira. Por exemplo, se quisermos implementar uma classe Gato e
Cachorro, podemos antes implementar uma classe Animal contendo todos os atributos
comuns que gato e cachorro possuem, assim nas classes Gato e Cachorro apenas se
implementaria atributos e comportamentos especficos de cada um deles. Isso torna o cdigo
fonte do programa reusvel e com isso desperdiado menos cdigo.
Se alguma mudana feito na classe principal ( classe pai ou super classe ), todas as
classes que herdam dela sofrero as mudanas, ou seja, assim como foi dito por Valade(2008),
as classes filhas herdam todos os atributos do pai. Em um sistema de partculas isso pode ser
muito bem explorado, como exemplo podemos fazer uma classe 'partcula genrica' que
possui todos os atributos comuns s partculas ( posio, velocidade, etc. ) e depois fazer
classes especficas que herdam esses atributos e implementar os comportamentos especficos
de cada partcula ( partculas de exploso se comportaro de uma forma, de neve de outra
forma, etc ).

38

3 MODELAGEM E IMPLEMENTAO
3.1 Arquitetura e modelagem de um Sistema de Partculas
Deixando a teoria e passando para a prtica, o primeiro assunto que ir ser tratado na
implementao de um sistema de partculas nesse trabalho ser a sua arquitetura e
modelagem, ou seja, como os elementos iro estar dispostos no sistema como um todo e como
ir ser a estrutura de cada um deles.
Primeiramente deve-se pensar o que se espera de um sistema de partculas, ou seja,
quais os efeitos que ele deve animar e tambm quais efeitos podem ser possveis de serem
feitos. Por exemplo, pode-se citar o efeito de fumaa que, quando um carro passa, a fumaa
influenciada pelo vento causado pelo carro ou ento, uma chuva caindo e logo em seguida um
efeito de nevasca aparece, por causa da variao da temperatura. Pode-se imaginar tambm o
efeito de fogo, cachoeira para simulao de fenmenos da natureza, e no caso de jogos
eletrnicos e filmes, efeitos abstratos de magia, sangue, fluidos viscosos em geral, esses so
alguns dos efeitos que o sistema de partculas desse trabalho deve ser capaz gerar por meio de
futuras extenses.
Efeitos que no so implementados, podero ser adicionados sem muito esforo
futuramente, o que indica que a arquitetura do sistema deve ser extensvel. Outra
caracterstica notvel que o sistema possui vrios efeitos diferentes, que por sua vez possui
parmetros diferentes e comportamentos diferentes, por exemplo: O efeito de neve possui
partculas de cores diferentes, uma dinmica diferente e tempo de vida diferente do que um
efeito de fogo, onde as partculas pertencentes a esse efeito geralmente tero uma cor
avermelhada ou amarelada, assim como a dinmica do fogo ser diferente da dinmica da
neve. Ou seja, cada sistema ter parmetros e dinmicas diferentes um do outro.
Outro fator a ser considerado que numa animao poder existir mais de um sistema
de partculas executando, como exemplo pode-se citar a chuva, que num dado instante
apenas uma gota caindo, que quando atinge o cho se transforma numa pequena exploso
(gua batendo no cho), que pode ser um outro sistema de partculas, observado isso, a
arquitetura deve considerar a execuo e criao de vrios sistemas de partculas, tudo em
tempo real. Dado essas observaes, pode-se modelar o sistema de acordo com a figura 11:

39

Figura 11: Arquitetura do sistema de partculas implementado nesse


trabalho.
Dada essa arquitetura, o presente trabalho ir agora observar cada estrutura em
detalhe, por comear pela estrutura mais simples at a mais complexa, nessa ordem: a
partcula, o sistema de partculas e por ltimo o gerenciador de sistemas de partculas que se
encontra no topo da hierarquia.

3.1.1 Criando as estruturas de dados de um sistema de partculas


3.1.1.1 Partcula

A partcula o elemento fundamental porm simples, de um sistema de partculas,


Lander(1998) mostra alguns atributos que uma partcula pode ter:

Posio atual

Posio anterior

Velocidade inicial

Acelerao

Tamanho inicial

Cor inicial

Cor final

Transparncia inicial (Valor alpha)

Tempo de vida

40
Primeiramente, deve-se saber a posio de uma partcula no espao, ou seja, a posio
nos eixos x, y e z das coordenadas cartesianas, caso haja desejo de produzir efeitos com a
partcula, tem-se a posio anterior que torna possvel esse efeito. A posio dividida em x,
y e z, portanto um vetor aqui se faz presente.
Tem os atributos de velocidade e acelerao que diz respeito a movimentao das
partculas, a velocidade indica a quantidade de movimento da partcula enquanto a acelerao
indica a taxa de aumento da velocidade, ou seja, a velocidade adiciona a posio e a
acelerao adiciona a velocidade, adiante nesse trabalho ser mostrado como a posio,
velocidade e a acelerao se interagem entre si para que a movimentao da partcula se torne
realista, segundo o padro da fsica clssica. A velocidade e a acelerao so divididas em
trs: x, y e z.
O tamanho do ponto (ou espessura da linha) que ir representar a partcula, pode
tambm dizer o tamanho da textura utilizada para representar a partcula. A cor inicial e final
indicam quais so as cores que a partcula dever possuir.
A partcula pode, em teoria, possuir qualquer forma, sempre lembrando que quanto
mais complexa for essa forma, mais difcil ser de renderizar as milhares de partculas na tela.
O tempo de vida indica quantos quadros da animao a partcula estar visvel, aps
esse perodo de tempo, a partcula ser reiniciada ou removida do sistema. Esse mecanismo de
vida e morte pode ser implementada de acordo com a transparncia da partcula, quando
estiver totalmente transparente, ela pode ter seu tempo de vida esgotado e ento excluda do
sistema.
Na programao orientada a objeto, define-se tambm o comportamento do objeto,
que representada por mtodos (funes na programao estruturada). Dentre os
comportamentos bsicos que uma partcula pode possuir, pode-se citar: A movimentao e a
renderizao. Uma partcula se movimenta de acordo com a fsica implementada, ou seja,
uma fsica que simula a chuva para partculas que simulam uma chuva, e ento renderizada
de acordo com a sua forma e cor na posio desejada.
Mas existe um problema: Caso a rea de criao das partculas seja restrita e tambm
se houver uma rea de coliso, como as partculas iro saber, se essas informaes esto na
classe 'Sistema de partculas'? E as foras que atuam sobre as partculas, cujo valor tambm se
encontram na classe de hierarquia superior? Por isso, os mtodos que implementaro o

41
movimento das partculas e tambm a renderizao se encontraro na classe de hierarquia
superior seguinte.
Dado todas essas definies, tem-se ento o objeto 'Partcula', que em programao
orientada a objeto define-se por classe 'Partcula', para a representao de vrios objetos com
atributos de valores diferentes. A figura 12 mostra uma classe 'Partcula' utilizando a
linguagem UML, utilizada para modelagem de softwares:

Figura 12: Classe que


representa uma partcula.
A classe mais simples da arquitetura proposta nesse trabalho est definida, o presente
trabalho ento ir continuar com a modelagem do sistema, mostrando agora a classe 'Sistema
de partculas' que ir atualizar e renderizar todas as partculas em seu domnio assim como
oferecer as foras que agem no sistema.
3.1.1.2 Sistema de partculas

A prxima classe na modelagem do sistema de partculas ser aquela que controlar as


partculas em si. O nome dessa classe foi dada assim porque ela mesma j um sistema de
partculas por si, ou seja, partculas que se movimentam e so renderizadas com aparncia de
fumaa por exemplo, so um sistema de partculas, outro que simula neve tambm um
sistema de partculas.
Essa classe ser responsvel pela criao, inicializao, atualizao e renderizao das
partculas e tambm a mais complexa de todo o sistema, porque ela quem faz praticamente
todo o trabalho, mais adiante ser explicado em detalhes como que todas essas atividades so
executadas, por ora, apenas ser mostrado a classe e sua estrutura.

42
Dentre os atributos dessa classe cita-se:

Lista ligada ou um array para guardar as partculas

Vetor contendo as componentes de fora nos eixos x, y e z

Textura que pode ser usada para dar aparncia s partculas

Nmero de partculas vivas no sistema

rea ou espao de criao das partculas

Variveis que guardam as variaes dos atributos das partculas

Nmero de identificao
A lista ligada necessria para guardar todas as partculas do sistema, um array (ou

vetor) pode ser usado, mas Lander(1998) diz que uma lista ligada faz com que fique muito
mais fcil de excluir e incluir partculas, alm de otimizar muito o processo de atualizao, j
que muitas partculas podem estar morrendo e nascendo o tempo todo.
O vetor 3D contendo as foras em x, y e z responsvel por guardar o valor da fora
que ser exercida nas partculas, essa fora pode ser a gravidade, resistncia do vento ou
qualquer outro fator fsico que o desenvolvedor decidir implementar. Essas foras possuem
cada uma, frmulas prprias para que consiga seus valores num dado tempo. Na seo 3.3 ir
ser explicado em detalhes essa parte.
A textura pode ser usada para dar aparncia s partculas, por exemplo, pode ser usado
uma textura de fumaa para as partculas, assim todas elas tero a mesma aparncia e assim
daro um efeito mais realista.
O nmero de partculas vivas diz se o sistema ainda est executando ou no, quando
esse nmero for zero, o sistema estar dizendo que ele j fez o seu trabalho e que pode ser
excludo.
O atributo que diz respeito a rea ou espao de criao de partculas, responsvel
por colocar todas as partculas em um determinado lugar, e esse lugar pode ser um objeto de
qualquer forma, desde de um ponto at um cubo, esfera ou outro objeto.
As variveis que guardam as variaes dos atributos que so responsveis pela
aleatoriedade da aparncia das partculas, que feita por processos estocsticos, explicadas na

43
seo 3.2.1.2.
O ltimo atributo apenas um nmero inteiro para a posterior remoo do sistema que
se encontra no gerenciador (mostrado mais a frente), assim, quando o usurio quiser que um
determinado sistema seja removido de cena, basta indicar esse nmero para o gerenciador, e
ento o mesmo ir remov-lo.
Aps determinar os atributos, os mtodos devem agora ser definidos, e dentre os
principais mtodos podemos citar:

Criar partculas dentro da rea de criao definida

Inicializar os atributos de todas as partculas criadas com valores definidos


estocasticamente e/ou aleatrios

Calcular as foras que agem nas partculas.

Atualizar o movimento das partculas e verificar se excederam seus tempos de vida

Renderizar as partculas

Retornar o nmero de identificao


O primeiro mtodo diz respeito s posies em que as partculas nascero, se a rea foi

definido como um quadrado, logo as partculas nascero dentro do quadrado em posies


aleatrias, se o objeto que for usado como rea de criao for uma esfera, as partculas
nascero em posies aleatrias dentro da esfera. Teoricamente pode ser usado qualquer
objeto 2D ou 3D para definir a rea de criao de partculas.
O segundo mtodo o que inicializa os atributos das partculas como posio,
velocidade, etc. Os valores so calculados usando processos estocsticos. Alguns atributos
podem ser definidos com valores comuns (no aleatrios). Cada sistema de partcula deve
definir todos esses critrios.
O terceiro mtodo calcula as foras que agiro nas partculas, foras essas
provenientes da fsica clssica newtoniana como gravidade, resistncia do ar, e qualquer outra
que o programador definir, segundo as frmulas de cada uma.
O quarto e quinto mtodo so responsveis, respectivamente, por atualizar a dinmica
das partculas, seus tempos de vida e renderiz-las na tela, lembrando que quanto mais

44
partculas existir no sistema, mais demorado ser para que esses mtodos executem as suas
tarefas.
O sexto e ltimo mtodo retorna o nmero de identificao passado por parmetro na
criao do sistema de partculas.
Na linguagem de modelagem UML a classe 'Sistema de Partculas' fica assim:

Figura 13: Classe que representa um sistema de


partculas.
Percebe-se que essa classe abstrata, ou seja, o programador dever, por meio de
herana, implementar uma verso da classe de acordo com cada sistema de partculas, se o
sistema for a simulao de chuva, logo ele dever o implementar cada mtodo de modo que as
partculas se comportem como chuva.
A classe mais complexa da hierarquia est definida, seu funcionamento, assim como
de todo o sistema ser explicado na seo 3.2.
3.1.1.3 Gerenciador de Sistemas de partculas

No topo da hierarquia se encontra a classe 'Gerenciador de Sistemas de Partculas', ela


responsvel por atualizar todos os sistemas que esto nela, alm de receber novos sistemas e
excluir as que possuem apenas partculas mortas. Novos sistemas de partculas podem ser
includos, mesmo aps todo o sistema estar implementado e funcionando.
A atividade de excluso do gerenciador consiste em examinar e excluir os sistemas de
partculas automaticamente em vez de deixar isso para o usurio, e isso ocorre quando um
sistema de partculas morre (todas as suas partculas excedem seus tempo de vida). O

45
gerenciador verificaria esse acontecimento e ento retiraria da memria o sistema morto.
Definido a misso da classe, abaixo mostrado o nico atributo da classe 'Gerenciador
de Sistemas de Partculas':

Lista ligada ou um array para guardar os sistemas de partculas


Como essa classe apenas ser uma classe gerenciadora, o nico atributo de que ela

precisa uma lista que contenha todos os sistemas de partculas que o usurio precisa para a
sua cena. Os mtodos so os seguintes:

Adicionar um sistema de partculas

Remover um sistema de partculas

Atualizar os sistemas de partculas

Renderizar os sistemas de partculas

Encerrar gerenciador de sistemas de partculas

Verificar a existncia de um sistema de partculas


O primeiro mtodo adiciona um sistema ao gerenciador, essa adio pode ser por meio

de parmetro, como por exemplo:


'gerenciador.adicionaSistemaParticula(new SistemaFumaa())'
Depois disso, o sistema de partculas que simula fumaa (caso do exemplo) estar
guardado na lista e ser atualizado quando for chamado o mtodo de atualizao do
gerenciador. Pode-se notar que um sistema pode ser adicionado a qualquer momento, mesmo
que o gerenciador esteja atualizando os sistemas j presentes na lista, isso permite que vrios
efeitos sejam adicionados em cena em tempo real, tornando toda a cena mais realista.
O segundo mtodo segue o mesmo padro que o segundo, mas apenas remove um
sistema de acordo com a sua chave de identificao (passado por parmetro na criao de um
Sistema de partculas). A remoo pode acontecer em tempo real tambm.
O terceiro e quarto mtodo atualiza os sistemas de partculas (chamando o mtodo de
atualizao de cada um) e os renderiza (chamando o mtodo de renderizao de cada um)
respectivamente. Note uma importante importante caracterstica da programao orientada a
objeto sendo usada aqui, que o polimorfismo, isso acontece porque cada sistema de

46
partculas possui comportamento prprio que so implementados por meio de subclasses da
classe 'Sistema de Partculas', no entanto, o gerenciador apenas ir chamar o mtodo 'atualizar'
e ento cada sistema ir se comportar da maneira que foi programada.
O quinto mtodo encerra todos os sistemas de partculas que porventura estejam ativos
no gerenciador liberando a memria usada por eles.
E o ltimo verifica se um determinado sistema de partculas ainda est ativo dentro do
sistema.
A classe 'Gerenciador de Sistemas de Partculas' fica definida assim na linguagem
UML:

Figura 14: Classe que representa um gerenciador de sistemas de


partculas.

Todo o sistema ir funcionar tomando em considerao a modelagem da figura 15 (Os


atributos e mtodos foram suprimidos para manter a simplicidade):

47

Figura 15: Relao entre as trs


classes principais do sistema.
A figura 15 indica que: Um gerenciador possui nenhum ou muitos Sistemas de
Partculas e que este possui nenhuma ou muitas partculas. Esse modelo representa fielmente
a abordagem desse trabalho em relao ao funcionamento de todo o sistema, porque oferece
uma caracterstica orientada a objeto, flexvel e facilmente extensvel, embora o autor no
garante que essa modelagem seja a melhor ou nica.
Com as trs classes definidas e tambm as suas relaes, tem-se ento o Sistema de
partculas (agora considerando o sistema como um todo) modelado, agora falta explicar como
ser o funcionamento do sistema e como as trs classes conversam entre si, assim como ser
explicado a implementao dos mtodos mais importantes do sistema, que possuem influncia
definitiva.

48

3.2 Execuo do sistema de partculas


A prxima etapa no entendimento e implementao do Sistema de partculas a sua
execuo, com mais detalhes. Na fundamentao terica desse trabalho (seo 2), foi descrito
com poucas palavras como que as partculas so geradas e inicializadas, tambm foi explicado
como que o sistema inteiro funciona, por isso, o presente ttulo ir apenas se aprofundar no
que j foi descrito.
Antes de explicar em detalhes o funcionamento, deve-se saber em que contexto da
computao grfica um Sistema de Partculas se encontra, e esse contexto se chama animao.
Parent(2002) diz que a animao fazer mover, algo que por si mesmo no se move,
como um boneco de madeira ou um desenho num papel e tambm diz que todo objeto grfico
representado no computador que possua variveis pode ser animado.
A estrutura usada para animao lembra muito aquela usada por

animaes

tradicionais, que consistiam em sequncias de papis. Outro contexto a ser visto que um
Sistema de partculas no s uma animao, mas tambm uma animao onde a interao
com o usurio faz com que este mude o jeito que a animao executa, isso se deve ao fato de
que o usurio deseja mudar as regras de criao ou movimento das partculas a qualquer
momento, por isso, deve-se pensar que um Sistema de Partculas no s uma animao onde
no h interao com o usurio (como num filme animado por exemplo), o usurio influencia
diretamente o decorrer da animao.
Dalmau(2004) mostra o mecanismo de um loop usado frequentemente em jogos, que
se encaixa perfeitamente no sistema que esse trabalho est implementado. A figura 16 mostra
como funciona esse loop:

49

Figura 16: Funcionamento de um loop responsvel


por manter um jogo ou uma animao rodando.

O loop sempre ir passar pela parte de atualizao da lgica do programa e sua


renderizao, depois de passado esses passos, o programa dorme um pouco para que outros
programas (ou partes de programas) possam rodar (como exemplo, a interface, caso existir).
O Sistema de partculas desse trabalho ir seguir esse esquema: Primeiro ele
atualizado e depois renderizado.
Toda a lgica do sistema feita na parte de atualizao enquanto s a parte de
renderizao feita depois. A figura 17 mostra a figura 16 de forma atualizada:

50

Figura 17: Loop atualizado, incluindo a atualizao do sistema de


partculas implementado nesse trabalho.
Essa seo ir explicar cada uma das principais partes que devem ser atualizadas no
sistema.

3.2.1 Gerao das partculas


Em primeiro lugar, deve-se definir como ser a criao de todo o sistema e tambm a
inicializao dos atributos das partculas, e tudo isso comea com a instanciao das classes
que pertencem estrutura do sistema citados nesse trabalho, isso deve acontecer antes e
durante o loop citado anteriormente.
Dentre as classes que devem ser instanciadas antes do loop comear cita-se:
'Gerenciador de Sistema de Partculas'. As classes que devem ser instanciadas durante o loop
cita-se: No mnimo uma classe 'Sistema de Partculas'.
As partculas em si sero geradas e inicializadas pela classe diretamente acima destas
na hierarquia, j que esta ltima contm todos os parmetros necessrios para a inicializao.
J de conhecimento do leitor que a classe 'Partcula' no possui mtodos, isso quer
dizer que a classe 'Sistema de Partculas' far todo o trabalho, cabendo 'Partcula' apenas

51
guardar os valores de seus atributos para que sejam usados pela classe superior a eles. Sendo
assim, nessa seo ser explicado como que a classe superior classe 'Partcula' executa as
suas duas primeiras atividades (ou mtodos) citadas na seo 3.1.1.2, que so referentes
criao e inicializao das partculas.
3.2.1.1 Criando partculas dentro de nascedouros

Quando uma classe 'Sistema de Partculas' inicializada, ela deve comear a criar
partculas para comear a executar a animao na tela, para isso ela faz duas coisas: Instancia
vrias vezes a classe 'Partcula' e calcula valores iniciais para os atributos das partculas.
Essas so as duas atividades que a classe Sistema de Partculas faz quando cria uma
partcula, e nesse trabalho seguido o modelo que Reeves(1983) descreve em seu artigo:
1. As partculas so inicializadas dentro de um nascedouro.
2. Valores iniciais so calculados por meio de processos estocsticos.
A presente seo ir explicar como fazer as partculas nascerem dentro dos
nascedouros, enquanto a prxima seo ir explicar os processos estocsticos.
Por nascedouro, entende-se como a rea dentro das coordenadas cartesianas em que
uma partcula pode nascer. Um nascedouro pode, teoricamente, possuir qualquer forma, pode
ser um cubo, um crculo ou at um ponto. Reeves(1983) diz que um sistema de partculas
possui uma rea de nascimento que define uma regio a respeito de sua origem onde novas
partculas so aleatoriamente colocadas, e ele tambm diz que reas de nascimento mais
complicadas e baseadas nas leis da natureza ou em atratores caticos no tem sido
implementados, apenas imaginados.
Ou seja, no trabalho que ele estava fazendo (o filme: Star Trekk 2), Reeves diz que
outras formas de gerao (nascedouros) foram imaginadas mas no implementadas, isso
indica que o programador do sistema pode implementar qualquer nascedouro que lhe convier,
sendo assim, nesse trabalho esta implementado os seguintes nascedouros:

Ponto: A posio inicial de todas as partculas a mesma, todas elas nascem de um


ponto no espao.

52

Plano: As partculas nascem aleatoriamente em qualquer ponto dentro de um plano em


x e z.

Disco: As partculas nascem aleatoriamente em qualquer ponto dentro de um disco em


x e z.

Cubo: As partculas nascem aleatoriamente em qualquer ponto dentro de um cubo nas


coordenadas x, y e z.
A seguir ser mostrado como gerar valores para as posies das partculas para que os

mesmos estejam dentro do nascedouro citado.


3.2.1.1.1 Primeiro nascedouro: Ponto

O primeiro nascedouro o mais simples, todas as partculas que forem sendo criadas
no sistema, iro ter suas posies iniciais com o mesmo valor que o ponto de gerao, a
visualizao desse tipo de nascimento ficaria o seguinte:

Figura 18: Partculas nascendo de um ponto no espao


cartesiano.

53
3.2.1.1.2 Segundo nascedouro: Plano

No plano, a posio inicial das partculas calculado seguindo valores aleatoriamente


gerados, desde de que estejam dentro do plano. A funo 'NumAleatorio' retorna um nmero
aleatrio dentro dos limites passados como parmetros. A frmula usada no presente trabalho
visa alcanar esse resultado, que a que se segue:
x= NumAleatorio x inicial do plano , x final do plano

(10)

z =NumAleatorio z inicial do plano , z final do plano

(11)

O resultado so valores de x e z que respeitam os limites do plano, assim as partculas


seguiro a regra de nascerem dentro rea especificada. Alguns efeitos podem ser criados como
por exemplo a chuva, colocando o nascedouro em forma de plano numa coordenada y
positiva (acima da origem) e a cmera olhando para a origem, e fazendo partculas azuis
carem devido ao efeito da gravidade. A figura a seguir mostra como ficaria o nascimento das
partculas dentro de um plano.

Figura 19: Partculas nascendo de um plano no espao


cartesiano.

54
3.2.1.1.3 Terceiro nascedouro: Disco

O disco segue o mesmo padro que o plano (todas as partculas nascem em pontos que
estejam dentro do disco), mas a frmula usada diferente, segundo o site da Wolfram
MathWorld, para gerar pontos aleatoriamente distribudos dentro de um disco, sendo 'r' o raio
do disco, '' um ngulo aleatrio entre 0 e 2, usa-se:

dist = NumAleatorio0, r

(12)

x=distcos

(13)

z =distsin

(14)

Vrios efeitos podem surgir usando o disco como nascedouro, dentre eles podemos
citar a de uma fonte em forma de crculo por exemplo, em que as partculas de gua so
expelidas para fora. Cheque a figura a seguir para visualizar as partculas nascendo dentro de
um disco.

Figura 20: Partculas nascendo de um disco no espao cartesiano.

55
3.2.1.1.4 Quarta frma: Cubo

Para que as partculas nasam dentro de um cubo, basta acrescentar a coordenada z na


frmula do plano, ficando assim:
x= NumAleatorio x inicial do plano , x final do plano

(15)

y=NumAleatorio y inicial do plano , y final do plano

(16)

z =NumAleatorio z inicial do plano , z final do plano

(17)

Assim, as partculas nascero dentro de pontos aleatrios dentro do cubo. A figura a


seguir mostra como que fica no momento do nascimento das partculas:

Figura 21: Partculas nascendo de um cubo no espao cartesiano.


Depois de definir quais sero os nascedouros das partculas, deve ser definido agora
como que os atributos das partculas (em exceo a posio delas) devem ser inicializados.

56
3.2.1.2 Calculando valores iniciais usando processos estocsticos

Aps ter definido como que a criao e a inicializao das posies das partculas ser
feito, passa-se ento para os prximos atributos das partculas que ainda no foram
inicializadas. E a maneira com que isso feito pode variar muito dependendo do programador
e seus objetivos. No caso desse trabalho, o objetivo nesse caso implementar o clculo dos
valores dos atributos das partculas seguindo a maneira com que Reeves(1983) implementou
no seu artigo, por isso, ser usado processos estocsticos para atribuir os valores iniciais.
Lemons(2002) diz que uma varivel aleatria quando ela, em determinadas
condies, exibe valores diferentes e que a evoluo no tempo dessa varivel chamada de
processo estocstico.
Reeves(1983) usa esses processos para dar aleatoriedade para as partculas, para que
no fique muito esttico a animao, e que esses processos podem ser usados em qualquer
atributo que desejar, assim como os mesmos podem ser usados para permitir um certo
controle na animao. O controle se d atravs da manipulao das variveis dos processos
estocsticos, ou seja, por meio da manipulao das variveis do processo, pode-se controlar os
valores dos atributos das partculas que so regidos por esses processos. Sendo assim, as
prximas sees explicaro como funciona esses processos para o controle da quantidade de
partculas geradas no sistema, e como aplic-los aos atributos das partculas como cor,
transparncia, etc.
3.2.1.2.1 Utilizando processos estocsticos para controlar a quantidade de
partculas geradas no sistema

O primeiro processo estocstico que esse trabalho ir tratar, embora no se aplique


diretamente a nenhum atributo especfico de um partcula, ser a de quantidades de partculas
geradas por frame.
Quando o usurio diz que deseja um sistema de partculas que contenha 1000
partculas, todas elas sero geradas frame por frame, e para isso, o usurio dir tambm o
nmero de segundos para que o sistema gere todas as partculas dentro desse intervalo de
tempo.

57
Por exemplo: O usurio diz que quer um sistema com 10.000 partculas e que todas
elas estejam na tela em 5 segundos aproximadamente, supondo que o programa rode em 60
frames por segundo, a cada frame o sistema deve gerar no mnimo 33 partculas, mas como o
processo estocstico possui um elemento aleatrio em seu meio, a requisio do usurio no
ser executado de forma exata e esse efeito, justamente o que d vida ao Sistema de
Partculas, deixando-o imprevisvel. O usurio ento pode variar os parmetros do processo
para criar outros efeitos.
O processo estocstico usado por Reeves(1983) tem o seguinte aspecto:

Numero de Particulas = minParticulas + varParticulas * NumAleatorio(-1,1);


Onde 'Numero de Partculas' o nmero de partculas geradas na tela em um

determinado frame, 'minParticulas' o mnimo de partculas que devem ser geradas,


'varParticulas' a variao do nmero de partculas e NumAleatorio(-1,1) uma funo que
retorna um nmero real aleatrio entre -1 e 1.
Fazendo 'varParticulas' como 5 e supondo que 'NumAleatorio(-1,1)' retornou -0.5, o
nmero de partculas gerados num certo frame ser de:
Numero de Particulas = 33 + 5 * (-0.5);
Numero de Particulas = 30
Nota-se que o nmero 30,5 proveniente do resultado foi truncado, j que no existe
uma meia partcula, com isso o frame ter 30 novas partculas, o prximo frame calcular
de novo esse processo, gerando outras partculas, isso se repete at que o limite seja atingido,
mesmo que esse isso no acontea em exatamente 5 segundos, conferindo mais
imprevisibilidade ao sistema.
Um outro processo estocstico proposto por Reeves(1983), mostrado abaixo, faz com
que o nmero de partculas geradas seja controlada pela rea da tela em que o Sistema de
partculas est, por exemplo: Um sistema que ocupa apenas 4 pixels, no precisa gerar
100.000 partculas.

Numero de Particulas = (minParticulas + varParticulas * NumAleatorio(-1,1)) *


reaTela;

58
3.2.1.2.2 Utilizando processos estocsticos para calcular valores iniciais para
os atributos das partculas

Qualquer atributo da classe 'Partcula' pode ser iniciado utilizando-se processos


estocsticos, e isso acontece de maneira bem simples, basta ter duas variveis para cada
atributo: O atributo em si, como exemplo a cor, e a variao desse atributo, como exemplo a
taxa de variao de cor. Essas duas variveis j esto disponveis na classe 'Sistema de
Partculas' e agora hora de us-las.
Primeiramente ser definido o atributo 'velocidade', a partir da os outros seguem o
mesmo padro, com exceo da cor delta, que ser a variao das cores da partcula. A
velocidade ser definida com o seguinte processo estocstico:

Velocidade inicial = minVelocidade + TaxaVarVelocidadeInicial * NumAleatorio(1,1);


Sendo 'minVelocidade' o valor que o desenvolvedor quer que a partcula tenha e

'TaxaVarVelocidadeInicial' o valor da variao para mais ou para menos da velocidade. O


usurio pode manipular as duas variveis citadas para controlar o valor da velocidade inicial e
a aleatoriedade da velocidade de cada partcula criada no sistema.
Os outros atributos sero calculados da mesma maneira:

Tamanho inicial = minTamanho + TaxaVarTamanho * NumAleatorio(-1,1);

Cor inicial = minCorInicial + TaxaVarCorInicial * NumAleatorio(-1,1);

Cor final = minCorFinal + TaxaVarCorFinal * NumAleatorio(-1,1);

Transp. inicial = minTransp. + TaxaVarTransparenciaInicial * NumAleatorio(-1,1);

Tempo de vida = minTempoVida + TaxaVarTempoVida * NumAleatorio(-1,1);


A nica exceo ser 'Cor delta' que dita a variao da partcula que vai da cor inicial

at a cor final. Lander(1998) define a cor delta da seguinte maneira:

Cor delta = (Cor final Cor inicial) / Tempo de Vida;


Isso significa que a cor da partcula ir variar da cor inicial at a cor final de acordo

com o seu tempo de vida.

59
Todas essas atividades aqui descritas podem ser implementadas na classe 'Sistema de
Partculas' com os mtodos criaParticula() e inicializaParticula(), usando os atributos da classe
'Partcula' para guardar os valores gerados.
Depois de definido a maneira como as partculas sero criadas e inicializadas, agora
deve-se passar para o prximo passo da atualizao de um sistema de partculas: A
movimentao das partculas e suas regras.

3.2.2 Movimento das partculas


O prximo passo da atualizao do sistema de partculas a parte que diz o
movimento das partculas no espao cartesiano. Reeves(1983) diz que qualquer modelo que a
cincia oferece pode ser usado como regra para a dinmica das partculas, sendo assim, o
presente trabalho ir usar parte da Mecnica Clssica Newtoniana para a execuo do
movimento das partculas.
Os atributos da classe 'Partcula' como posio, velocidade e acelerao so os
responsveis pela dinmica da partcula, so eles que iro guardar os valores para posterior
uso da animao da partcula na tela de forma realista, mas qual a relao entre eles para que
a fsica acontea?
3.2.2.1 Definindo a relao entre posio, velocidade, acelerao e fora

A segunda lei de Newton, introduzido na seo 2.2.4 desse trabalho, define que a soma
das foras externas a um objeto se d pela seguinte frmula:
F =ma

(18)

Onde 'm' a massa do objeto e 'a' a sua acelerao. A fora e a acelerao so


grandezas vetoriais, e como se est tratando de pontos no espao 3D, aconselhvel, segundo
Palmer(2005), dividir frmula acima em trs. Uma para cada eixo do sistema de coordenadas
e trat-las individualmente, isso simplifica os clculos que o sistema ir calcular, sendo que
uma fora que age apenas em uma direo no afetar as outras direes. A segunda lei de
Newton fica da seguinte forma para cada direo no espao:

60
F x =ma x

(19)

F y =ma y

(20)

F z =ma z

(21)

Num sistema de partculas, a fora calculada por meio de uma equao


implementada pelo programador (retirada da Mecnica Newtoniana), sendo que essas
equaes iro retornar um valor e a partir da, a acelerao pode ser calculada. Na prtica, as
equaes acima so mudadas para a seguinte forma:
a x=

Fx
m

(22)

a y=

Fy
m

(23)

a z=

Fz
m

(24)

A figura 22 mostra as foras que agem em separado em cada eixo do sistema de


coordenadas.

Figura 22: As foras podem agir em cada eixo separadamente, sem depender
um do outro.
Essas equaes apenas tornam a acelerao a incgnita da segunda lei de Newton, j
que no sistema a fora calculada por equaes j conhecidas, nas quais esse trabalho ir
apresentar as que foram usadas para a implementao do sistema de partculas proposto.
Conhecendo pois, a acelerao da partcula num dado instante, a velocidade pode ser

61
calculada. Como a acelerao a taxa de variao da velocidade segundo o tempo, a equao
que representa essa mudana expressa por meio da derivativa da velocidade em relao ao
tempo:
dv
dt

a=

(25)

E assim como a fora e a acelerao, a velocidade tambm uma grandeza vetorial,


logo ela pode ser representada por trs equaes diferenciais separadas, uma para cada eixo
do sistema de coordenadas:
a x=

dv x
dt

(26)

a y=

dv y
dt

(27)

a z=

dv z
dt

(28)

As ltimas variveis que devem ser achadas, depois de ter achado as velocidades em
cada eixo, so as posies x, y e z da partcula. Sabe-se que a velocidade taxa de variao da
posio segundo o tempo, logo permitido representar a velocidade como sendo a derivativa
da posio em relao ao tempo, sendo 's' a localizao da partcula no espao:

v=

ds
dt

(29)

Como o espao divido em trs eixos, pode-se representar a equao diferencial


acima em trs, uma para cada eixo do espao:

v x=

dx
dt

(30)

v y=

dy
dt

(31)

v z=

dz
dt

(32)

62
Basicamente, as relaes entre posio, velocidade, fora e acelerao so essas,
calculada uma delas, a fora em primeiro lugar, torna possvel saber o valor das outras e no
fim, renderizar as partculas na posio certa num determinado tempo na animao, e esses
clculos acontecem para cada eixo no sistema de coordenadas, ou seja, em cada eixo
calculado as foras, velocidades, aceleraes e as posies, tudo isso para simplificao do
sistema.
Mas ainda falta saber como resolver essas equaes diferenciais e como fazer a
ligao entre elas, e isso acontece por meio de um resolvedor de equaes diferenciais
ordinrias chamado Runge-Kutta, escolhido pelo autor por causa de sua performance e
preciso.
3.2.2.2 Preparando as equaes diferenciais para o mtodo de Runge-Kutta

Percebe-se

nitidamente

que

equaes

diferenciais

ordinrias

so

usadas

frequentemente para o clculo dos atributos responsveis pela movimentao das partculas,
Palmer(2005) diz que quando essas equaes so simples, deve-se apenas integr-las para
chegar numa soluo do tipo forma fechada, nas quais so muitas vezes so simples
equaes algbricas e esse tipo soluo , muitas vezes, fcil de se achar se a fora que atua
no sistema constante, caso contrrio, uma soluo do tipo forma fechada no possvel e
a equao diferencial deve ser resolvida numericamente.
No presente trabalho, as foras que podem atuar no sistema so muitas e vo depender
muita exclusivamente da criatividade e vontade do programador de implementar mais foras,
por esse motivo, ser usado o mtodo de Runge-Kutta para resolver todas as equaes
diferenciais ordinrias independentemente se h uma soluo algbrica para elas ou no.
O mtodo de Runge-Kutta foi feito para achar aproximaes numricas para equaes
diferenciais ordinrias de primeira ordem, para isso, deve-se fazer com que todas as equaes
passadas para o mtodo sejam dessa ordem. Uma equao diferencial ordinria considerada
de primeira ordem quando ela possui uma varivel dependente e o grau da maior derivada 1.
Percebe-se que a acelerao a derivada de grau 2 da posio, como se v na
demonstrao abaixo:

63
a=

dv
dt

(33)

v=

ds
dt

(34)

a=

d ds

dt dt

(35)

a=

d 2s
dt 2

(36)

Logo:

Ou seja, a acelerao a segunda derivada (derivada da derivada) da posio em


relao ao tempo e essa uma equao diferencial ordinria de segunda ordem. Para que o
mtodo de Runge-Kutta possa resolv-la, ela deve ser expandida para uma srie de equaes
de primeira ordem, e isso feito fazendo uma substituio por variveis. Veja um exemplo.
Veja a equao que diz como calcular a fora exercida sobe uma mola, sendo 'm' a
massa da partcula, '' o coeficiente de amortecimento, 'k' o coeficiente de elasticidade e 'x' a
posio de uma partcula no eixo das abscissas:
d 2x
dx
m 2 kx=0
dt
dt

(37)

Seguindo a lei de Newton e sabendo que dx/dt a acelerao do objeto, a equao 37


fica assim:
2

d x
dx
= kx
2
dt
dt

(38)

Usando a equao 30, a equao 38 se transforma em duas equaes diferenciais


ordinrias de primeira ordem, que o desejado para ser resolvido pelo mtodo de RungeKutta:
dv x v x kx
=
dt
m

(39)

dx
=v x
dt

(40)

64
Assim, a classe Runge-Kutta dever resolver essas duas equaes simultaneamente
para que o resultado seja conhecido. O esquema a seguir mostra o que deve ser feito quando
uma nova fora for colocada no sistema:
1. Defina qual fora ser implementada no sistema e conhea a sua equao, exemplo:
gravidade, resistncia do vento, lei de Hook (fsica de molas), etc.
2. Calcule todas as foras j presentes e some-as, obtendo um valor que represente todas
foras somadas.
3. Aplique a segunda lei de Newton, obtendo a acelerao e passe para o mtodo de
Runge-Kutta fazer os clculos em cada iterao utilizando o tempo, devolvendo os
resultados para a classe responsvel, para que a mesma faa uso desses resultados.
3.2.2.3 Modelando as classes EDO e Runge-Kutta

Percebe-se que h trs grandes passos a serem feitos para modelar um efeito fsico:
1. Preparar as equaes responsveis por oferecer o valor da fora e somar todas elas.
2. Preparar as equaes diferenciais ordinrias para que todas fiquem de primeira ordem.
3. Passar as equaes para o mtodo de Runge-Kutta, que devolver resultados a cada
iterao da animao, ou seja, em cada frame.
Sendo assim, percebe-se uma grande necessidade de haver uma classe para as
equaes diferenciais e uma classe para o mtodo de Runge-Kutta, e que a classe para as
equaes deve, no representar uma equao apenas, mas vrias delas.
Sendo assim, a classe 'EDO' (Equaes diferenciais ordinrias) dever representar
todas as equaes utilizadas no sistema e a classe Runge-Kutta dever conter apenas o mtodo
que ir receber um objeto 'EDO' como parmetro e o intervalo de tempo da animao que se
passou, e tambm devolver os resultados.
A classe 'EDO' possuir os seguintes atributos:

Um vetor para todas as variveis dependentes das EDO's que iro ser calculadas.

Uma varivel representando o intervalo de tempo passado (A varivel independente).

65
E os seguintes mtodos:

retornaValorEDOs()
A classe 'EDO' ser abstrata, assim como o seu nico mtodo, ou seja, para que uma

equao diferencial seja implementada, uma subclasse dever ser feita, implementando o
mtodo retornaValorEDOs(). O nico mtodo da classe 'EDO' retorna o lado direito das
equaes diferenciais para que o mtodo Runge-Kutta possa fazer seus clculos. Em UML a
classe ficaria assim:

Figura 23: Classe que


representa as equaes
diferenciais ordinrias de
primeira ordem.
A classe Runge-Kutta ser apenas uma classe com um mtodo esttico (diz-se de um
atributo ou mtodo esttico quando no precisa de uma instncia das suas classes para que
possam ser acessados) que faz o clculo das EDO's. Sendo assim, a classe Runge-Kutta ficaria
assim:

Figura 24: Classe que representa o mtodo RungeKutta.

Depois de modelado as duas classes que iro ser responsveis pela dinmica das
partculas, devemos mostrar agora como que ficaria na prtica, a execuo do sistema agora
que foi definido como ser feito a movimentao das partculas. A figura 25 mostra a
atualizao do sistema, incluindo a parte de movimento das partculas:

66

Figura 25: Loop atualizado, incluindo a parte de


movimentao das partculas.
Depois de definido a parte de movimento, ainda falta uma coisa para finalizar a
modelagem da dinmica das partculas: Como so calculadas as foras.
3.2.2.4 As foras que agem no sistema

As foras esto presentes no nosso dia-a-dia e Newton percebia isso, tanto que ele at
estudou muitas delas e fez equaes que as representassem. Hoje essas equaes podem ser
usadas para fazer simulaes em computadores, imitando os movimentos dos objetos no
mundo real. Esse trabalho trata de objetos chamados partculas e que tambm sofrem a
influncia das foras da natureza como a gravidade, por isso, ser mostrado agora quais so as

67
foras que foram implementadas no sistema de partculas proposto pelo autor e tambm ser
dado alguns exemplos de outras foras que podem ser implementadas futuramente.
Witkin(2001), em sua implementao de um sistema de partculas dividiu as foras em
trs grupos:

Foras unrias: Foras que agem em cada partcula independentemente. (Gravidade)

Foras n-rias: Foras que agem em n partculas ao mesmo tempo. (Lei de Hook)

Foras de alcance espacial: Foras que agem num determinado pedao do espao,
apenas as partculas que passam por ali que sofrem o efeito dessa fora. (Atrao
magntica)
Nesse trabalho foram implementados algumas foras dentre esses trs grupos, dentre

elas cita-se: gravidade, resistncia do ar, lei de Hook e gravidade local (a fora da gravidade
que influenciam as partculas somente se elas estiverem em algum local). Ser mostrado agora
quais foram as frmulas usadas para cada uma delas. Depois disso, a parte de movimentao
das partculas estar terminado e ser passado para a parte de renderizao das partculas, que
ser o ltimo tpico do trabalho sendo que logo aps ser mostrado os resultados e a
concluso.
3.2.2.4.1 Gravidade

A gravidade implementada nesse trabalho utiliza a seguinte frmula, sendo G a


constante gravitacional universal que igual a 6,67.10-11, 'm1' e 'm2' as massas dos dois objetos
que esto sendo atrados pela fora gravitacional e 'd' que representa a distncia dos centros
dos objetos:

F=

G m 1 m2
d2

(41)

Com essa frmula, possvel fazer simulaes com o sistema de partculas utilizando
a gravidade de qualquer planeta ou corpo astral cuja massa seja conhecida pela cincia,
produzindo efeitos bem interessantes.

68
3.2.2.4.2 Resistncia do ar

A resistncia do ar uma fora que resiste ao movimento das partculas, assim como
uma fora que atua em qualquer tipo de fluido, embora se esteja tratando do ar aqui. A
frmula usada a seguinte: Sendo 'k' uma constante definida pelo usurio e 'v' a velocidade da
partcula:
F =kv

(42)

A constante k ser inicialmente definido como 0,9 nesse trabalho. O sistema pode
muito bem variar essa constante para simular o movimento das partculas em outros fluidos e
ambientes.
3.2.2.4.3 Lei de Hook

A lei de Hook diz como funciona o movimento harmnico simples, comportamento


esse muito observado nas molas. No sistema de partculas esse pode ser um comportamento
bem interessante se as partculas forem acopladas como pares. A frmula usada a seguinte,
sendo '' o coeficiente de amortecimento, 'k' o coeficiente de elasticidade, 'v' a velocidade da
partcula e 's' a posio atual da partcula em algum eixo (s pode ser x, y ou z):
F a=v ks

(43)

F b=F a

(44)

'Fa' e 'Fb' indicam as foras sobre duas partculas, sendo que a fora que atua na
segunda partcula o oposto que atua na primeira, com esse tipo de fora agindo observa-se
um efeito bem interessante sobre as partculas, e mais: com esse efeito, possvel modelar
vrios objetos (como cubos e esferas) colocando vrias molas conectando todas as partculas,
fazendo com que esses objetos sejam deformveis.

69
3.2.2.4.4 Gravidade Local

A frmula usada a mesma do da gravidade, mas as partculas recebero a influncia


dessa gravidade extra apenas se entrarem numa regio especfica do espao, definido pelo
usurio. Como exemplo podemos dizer que se as partculas estiverem no lado esquerdo do
espao (x < 0), elas sofrero uma fora da gravidade no eixo z (elas sero sugadas para o
fundo do espao), esse um dos efeitos que pode ser feito e isso tambm pode ser
implementado colocando vrias regies do espao com vrias foras diferentes, o que torna o
sistema de partculas mais interessante e imprevisvel.

Figura 26: Fora da gravidade atuando apenas do lado


esquerdo da origem.

70

3.3 Renderizao do sistema de partculas


A ltima parte que falta para completar a modelagem e implementao de um sistema
de partculas a definio de como renderizar as partculas, e isso pode ser simples ou
complicado, dependendo do desejo do programador. As partculas, teoricamente podem ser
renderizadas de qualquer forma, embora um sistema como esse exija muito processamento,
geralmente as partculas so renderizadas em formas de primitivas grficas simples como
pontos ou linhas, mas h outras formas de fazer isso, que no exija muito processamento na
hora da renderizao. Nas prximas sees sero mostrados algumas das aparncias que as
partculas podem ter.

3.3.1 Renderizando as partculas como Pontos


As partculas podem ser renderizadas como simples pontos, e esses pontos podem ter
at 1 pixel de tamanho ou at serem gigantescos, desde de que o computador seja potente o
suficiente para renderizar todas essas partculas gigantes. A vantagem de se renderizar as
partculas como sendo pontos que fica bem fcil o computador desenhar na tela muitas
partculas, mas muitas mesmo, fazendo um sistema de partculas conter at centenas de
milhares de partculas, mas tudo vai depender exclusivamente da potncia do processador do
computador.

3.3.2 Renderizando as partculas como Linhas


Renderizando as partculas como linhas, observa-se um efeito muito interessante, que
o motion blur, que um efeito observado nas cmeras fotogrficas quando um objeto passa
muito rpido ou quando a cmera movida de um lado para o outro, deixando um borro na
foto, como na figura 271:

Figura 27: Efeito de


motion blur em uma foto.
1 http://www.daniel-xavier.com/wp-content/uploads/2009/03/motion-blur-photos-11.jpg

71
Para fazer com que o sistema de partculas tenha esse efeito, as partculas devem ser
esticadas e borradas, dando a impresso que elas esto em alta velocidade e quando se
quer fazer um efeito esse, renderizar as partculas como linhas algo quase obrigatrio. Veja
nas figuras 281 e 292 como fica um sistema de partculas com e sem efeito de motion blur:

Figura 28: Sistema de


partculas sem motion
blur.

Figura 29: Sistema de


partculas com motion
blur.

3.3.3 Renderizando as partculas como Texturas

Figura 30: Sistema de partculas


renderizada utilizando texturas.

Figura 31: Sistema de partculas


renderizada sem usar texturas.

Outra maneira de alterar as aparncias das partculas usar texturas para representar as
partculas. Texturas so imagens que podem ser acopladas em objetos tridimensionais ou
bidimensionais, As figuras 303 e 314 mostram a diferena entre usar texturas para renderizar as
1
2
3
4

http://ccl.northwestern.edu/netlogo/models/ParticleSystemWaterfall
http://www.rogue-development.com/blog2/2008/02/pulse-particles-bitmapdata/
http://people.csail.mit.edu/acornejo/images/particle.png
http://images.digitalmedianet.com/2004/Week_18/61cryrjp/story/16a.jpg

72
partculas e no usar. Vrios efeitos interessantes podem sair da, sendo que a maioria dos
sistemas de partculas profissionais usam to somente texturas para a renderizao das
partculas.

3.3.4 Renderizando as partculas de maneira diferente


No aconselhvel utilizar objetos mais complexos do que os citados anteriormente
para representar as partculas, devido a carga de processamento que o computador ter de
aguentar, mas caso a curiosidade e a necessidade seja maior, outros meios podem ser usados,
como os exemplos abaixo:

Renderizar as partculas como objetos inteiros, como cubos, esferas, casas, cabeas,
etc.

Renderizar as partculas como texturas animadas ou objetos animados.

Renderizar vrias partculas ao redor de cada partcula.

As figuras 321 e 332 abaixo so bons exemplos do que se pode fazer renderizando as partculas
de outro modo:

Figura 32: Partculas


renderizadas como bolhas de
ar.

Figura 33: Partculas


representando plos.

Com todas as etapas da modelagem e implementao concludas, basta agora observar


os resultados conseguidos, que so mostrados na prxima seo.

1 http://www.borisfx.com/images/fx/particleSystem.jpg
2 http://www.blendermagz.com/2009/05/06/blender-3d-tutorial-fur-particles/

73

4 Resultados
4.1 Mostrando o software em geral
O resultado um software feito em Java e JOGL (Java OpenGL, uma biblioteca que
faz a ligao do java com o openGL). As animaes so feitas utilizando a fsica mostrada
aqui e a renderizao feita com openGL. As figuras a seguir mostram o software executando
alguns de seus efeitos:

Figura 34: Sistema de partculas feito pelo autor, mostrando as partculas no


espao 3D.

Na figura 34, tem-se as partculas saindo do centro das coordenadas cartesianas, o


efeito aqui descrito semelhante ao de uma exploso, as linhas coloridas indicam o sistema
de coordenadas cartesianas sendo que a linha vermelha representa o eixo x, a linha verde o
eixo y e o eixo z representado pela linha azul. O usurio pode se movimentar sobre o
ambiente utilizando as teclas A, S, D e W do teclado e o mouse. Usa-se as teclas para
movimentar a cmera pelo espao e o mouse para girar a cmera, isso oferece ao usurio
diferentes perspectivas do que est acontecendo na cena.
A interface se encontra logo abaixo da janela de animao, ali o usurio poder mudar
a aparncia, as foras e tudo que influencia a animao, mais adiante ser explicado cada

74
componente da interface e o que cada um faz.
A figura 35 abaixo mostra as partculas sendo influenciadas pela gravidade no eixo x,
e tambm percebe-se que elas esto com cores diferentes, algumas so amarelas e outras so
verdes, enquanto aquelas na ponta so pretas, isso ocorre porque as partculas pretas so as
partculas antigas enquanto as novas j esto nascendo com as cores definidas pelo usurio na
interface, o usurio diz para as novas partculas nascerem mesclando verde e amarelo.

Figura 35: Partculas sendo influenciadas pela gravidade no eixo X.

A figura 36 mostra as partculas nascendo ao longo da linha vermelha e ento


executando um movimento retilneo para cima no eixo y, ou seja, o usurio definiu o
nascedouro das partculas como sendo um plano, nesse caso, um plano que no possui valor
no eixo z, por isso ele se torna uma linha, ento o sistema simplesmente gera valores
aleatrios entre o x inicial e o x final que o usurio definiu, fazendo com que as partculas
nasam ao longo do eixo x.

75

Figura 36: Partculas sendo atradas por uma fora oposta da


gravidade no eixo Y.

A figura 37 mostra as partculas tendo como nascedouro um disco de raio 121, a seguir
aplicado as foras da lei de Hook nos trs eixos, o resultado uma exploso em forma de
disco, se fosse possvel ver animao, o leitor veria as partculas sendo expelidas e atradas
pelo centro, indo at uma distncia e depois retornando.

Figura 37: As partculas explodindo em forma de disco.

76
A figura 38 mostra as partculas nascendo dentro de um cubo, e as partculas comeam
sem uma velocidade inicial, ou seja, elas nascem paradas e no em movimento, permitindo
visualizar a verdadeira forma do nascedouro.

Figura 38: Partculas nascendo dentro de um cubo.


E por fim, tem-se a figura 39 que mostra as partculas sendo influenciadas pela
gravidade local, percebe-se que apenas as partculas que esto do lado negativo do eixo x
esto sendo movidas.

Figura 39: Partculas ao longo do lado negativo do eixo x, sendo


influenciadas pela gravidade.

77

4.2 Explicando a interface do software


A interface do software o que faz todas as modificaes necessrias para a alterao
do comportamento das partculas na janela de animao, para isso, essa seo ir explicar
cada pedao da interface, para que o usurio tenha noo do que est fazendo.

4.2.1 Alterando as foras do sistema


A figura 40 mostra as foras disponveis no software, quando o usurio quiser ativar
uma fora, basta selecionar a caixa de seleo correspondente fora desejada, caso quiser
desativ-la, basta selecionar de novo.

Figura 40: Foras disponveis no


sistema.

Essa parte da interface se encontra na primeira aba principal disponvel embaixo da


janela de animao. O usurio pode ativar todas as foras para ver qual ser o resultado, assim
como ele pode desativar todas elas, cada vez que o usurio ativa uma dessas foras, no lado
direito dessa janela ir aparecer os componentes responsveis pela configurao da fora, as
prximas sees iro explicar sobre cada um deles.

78
4.2.1.1 Configurando a gravidade

Figura 41: Interface de configurao da gravidade.


A figura 41 mostra a interface de configurao da gravidade, quando o usurio ativa a
caixa de seleo da gravidade, como na figura 40, a aba 'Gravidade' na janela Quantidade das
foras ser ativada. Cada deslizador responsvel pela quantidade de gravidade em cada eixo
dos sistema cartesiano, o deslizador X interfere na gravidade ao longo do eixo x e assim por
diante, percebe-se que se o usurio quiser uma gravidade positiva ao longo do eixo z basta
deslizar a seta do deslizador Z para a direita. Os rtulos ao lado diro qual quantidade de
gravidade atual no momento.
4.2.1.2 Configurando a resistncia do vento

J na aba 'Resist. Vento', o usurio poder configurar quanto de resistncia o ambiente


ir fornecer, nota-se que no h valores negativos, j que no existe resistncia negativa. O
mecanismo funciona da mesma maneira que a da gravidade, basta mover os deslizadores e os
rtulos a direta iro dizer qual o valor atual.

Figura 42: Interface de configurao da resistncia do vento

79
4.2.1.3 Configurando a lei de Hook

Na interface para a configurao das foras da lei de Hook, o usurio poder desativar
a fora em cada eixo se quiser e ativ-las quando quiser, os dois deslizadores permitem
configurar as duas constantes que influenciam no valor da fora da lei de Hook: '', que est
representado como 'Mu' e simboliza o coeficiente de amortecimento e 'K' que simboliza o
coeficiente de elasticidade. O usurio poder variar esses valores para ver qual a reao das
partculas. Quando no quiser que a lei de Hook atue em um determinado eixo, basta desativla na caixa de seleo correspondente.

Figura 43: Interface de configurao da lei de Hook no sistema.

4.2.1.4 Configurando a gravidade local

E por fim pode-se configurar a gravidade local, a nica diferena entre a interface da
gravidade local e da gravidade que o usurio deve escolher onde a gravidade local ir atuar,
se no eixo x do lado negativo ou positivo, se no eixo y negativo ou positivo ou se no eixo z
positivo ou negativo, ou em todos eles, o usurio que decide, basta clicar nos botes do lado
direito dos deslizadores, o resto o mesmo mecanismo que a configurao da gravidade.

Figura 44: Interface de configurao da gravidade local.

80

4.2.2 Alterando as propriedades fsicas das partculas


O sistema permite tambm alterar as propriedades das partculas como velocidade
inicial, massa, ngulo e tempo de vida, isso faz com que as partculas mudem seu
comportamento na tela, basta que o usurio combine cada mudana com as foras para
observar mais efeitos.
4.2.2.1 Configurando a velocidade inicial

O software produzido pelo autor permite que seja alterado as velocidades iniciais das
partculas que nascem no sistema, a figura 45 ilustra essa parte da interface, assim como a
parte das foras, basta apenas deslizar as setas do primeiro deslizador para a esquerda, caso
queira valor negativo, ou para a direita, caso queira valor positivo. O porqu de haver dois
deslizadores para cada atributo se deve ao fato de que o software segue os processos
estocsticos descritos nesse trabalho, o primeiro deslizador o valor mnimo que o atributo
deve possuir enquanto o segundo deslizador a taxa de variao desse valor, para lembrar,
isso se deve ao fato da seguinte frmula:

valorAtributo = minAtributo + taxVarAtributo*numAleatorio(-1, 1)


Como foi dito, o primeiro deslizador o valor de minAtributo e o segundo deslizador

o valor de taxVarAtributo, assim, como nesse caso agora, a velocidade num dado eixo ser o
resultado da frmula acima, e esses valores sero indicados pelo usurio ao mover as setas
dos deslizadores. Assim o usurio poder configurar cada velocidade em cada eixo, quanto
mais ele puxar o segundo deslizador de cada velocidade, mais aleatrio ser a velocidade das
partculas naquele eixo, caso queira uma velocidade fixa, basta zerar o segundo deslizador e
mexer apenas no primeiro.

Figura 45: Interface de configurao da velocidade inicial.

81
4.2.2.2 Configurando o ngulo inicial, massa e tempo de vida das partculas

Na outra aba, onde est escrito Outras propriedades fsicas, se encontra o ngulo
inicial, a massa e o tempo de vida das partculas, sendo que aqui no h nada de novo a ser
explicado, porque essa parte da interface segue o mesmo padro que a velocidade inicial:
Todos esses atributos usam processos estocsticos para definir seus valores, por isso que h
dois deslizadores para cada um. O tempo de vida das partculas contado em frames, logo
quando o usurio coloca a seta em 3000, ele est querendo dizer que as partculas que
nascerem tero 3000 frames de vida, passado esse tempo as partculas renascero.

Figura 46: Interface de configurao do ngulo, massa e tempo de vida das partculas

4.2.3 Alterando a aparncia das partculas


O software tambm permite alterar a cor inicial, final, colocar transparncia nas
partculas e alterar tambm o tamanho delas. Todos esses atributos seguem a frmula de
processos estocsticos, por isso todas as interfaces aqui apresentam dois deslizadores.
4.2.3.1 Alterando a cor inicial e cor final das partculas

A cor inicial e final das partculas pode ser mudada na aba Aparncia das partculas
e logo em seguida na aba Cor inicial ou Cor final. O software segue o padro RGB (Red,
Green, Blue), que consiste em formar todas as cores a partir do vermelho, verde e azul. O
usurio poder configurar a quantidade dessas cores para conseguir a cor que quiser, todas as
partculas que estiverem nascendo estaro com a cor inicial e quando perto de sua morte,
estaro com a cor final estabelecida. As figuras 47 e 48 mostra as partes da interface que
cuidam disso.

82

Figura 47: Interface para configurao da cor inicial das partculas.

Figura 48: Interface para a configurao da cor final das partculas.

4.2.3.2 Alterando o tamanho e adicionando transparncia s partculas

Nas abas Tamanho e Alpha o usurio pode configurar o tamanho das partculas e
colocar transparncia nelas, o tamanho aqui se refere ao tamanho do ponto que representa as
partculas e o canal alpha pode ser ligado ou desligado, caso ligado as partculas iro ficando
transparentes com o passar do tempo. As figuras 49 e 50 mostram a interface responsvel por
essa parte.

Figura 49: Interface de configurao do tamanho das partculas.

83

Figura 50: Interface para ligar ou desligar o canal alpha.

4.2.4 Definindo nascedouros para o sistema


E por fim, a ltima aba principal do software cuida dos nascedouros do sistema de
partculas, ali o usurio poder configurar qual ser e como ser o novo nascedouro das
partculas, como na figura 51:

Figura 51: Interface para a configurao do nascedouro das partculas.

Em Ponto o usurio poder configurar as coordenadas do novo ponto de nascimento


das partculas indicando qual x, y e z deve estar o ponto, depois de definido o usurio dever
apertar o boto Criar nascedouro: Ponto e ento todas as partculas que esto nascendo
iro emergir daquele ponto.
Em Plano, Disco e Cubo o mesmo processo, s que em disco o usurio apenas
define qual o raio, e o disco ser criado na origem. Para visualizar se as partculas esto
mesmo nascendo seguindo essas formas, basta tirar toda fora e velocidade das partculas, pra
ver como elas nascem, como ficaro paradas, o usurio poder ver as partculas nascendo na
forma proposta.

84

5 CONCLUSO
O nmero de efeitos que possvel conseguir com um sistema de partculas muito
grande, pois o presente trabalho mostrou apenas o bsico que se pode fazer com um sistema
desse, muitos cientistas e pesquisadores da rea de computao grfica estenderam o sistema,
tornando possvel outros efeitos que William Reeves no previu em seu artigo.
Dentre esses trabalhos, pode-se citar Bell(2005) que usou sistemas de partculas para
animar materiais granulares como areia, Venetillo(2007) implementou um sistema de
partculas completamente na GPU (unidade de processamento grfico, a placa de vdeo)
tornando possvel a coliso entre as partculas.
Esse sistema possui uma dificuldade mdia de implementao, esforo requerido,
mas o resultado realmente compensa todo o trabalho. Caso haja expanses, o sistema pode ser
includo em outros sistemas grficos a fim de contribuir para a cena.
Futuramente, o autor pretende estender o sistema para que suporte coliso com objetos
na cena, como exemplo, colocando uma esfera no meio da cena enquanto as partculas
colidem contra ela, o uso de outras aparncias para as partculas como o uso de polgonos
inteiros representando cada partcula e usar processamento paralelo para a renderizao de
muitas partculas.
O sistema pode ser estendido, o que seria uma limitao nesse caso o tempo para
fazer tudo isso, porque requereria muito esforo para implementar.

85

6 REFERNCIAS BIBLIOGRFICAS
BELL, Nathan, YU, Yizhou, MUCHA, Peter J. Particle-Based Simulation of Granular
Materials, SIGGRAPH, Julho 2005, p. 77 86.
BOURG M., David. Physics for Game Developers, Sebastopol: O'REILLY, 2002, First
Edition
DALMAU, Daniel Snchez-Crespo, Core Techniques and Algorithms, EUA: New Riders
Publishing, 2004.
LANDER, Jeff. The Ocean Spray in Your Face, San Francisco: Game Developer Magazine,
Julho 1998.
LEMONS, Don Stephen. An introduction to stochastic processes in physics, EUA: The
Johns Hopkins University Press, 2002.
MILLINGTON, Ian. Game Physics Engine Development, EUA: Morgan Kaufmann
Publishers, 2007.
PALMER, Grant. Physics for Game Programmers, EUA: Apress, 2005.
PARENT, Rick. Computer Animation, San Francisco: Morgan Kaufmann Publishers, 2002.
POKKUNURI, Bhanu. Object Oriented Programming, SIGPLAN Notices, 1989, Volume
24, p. 96 101.
PRESS H., William, et al. Numerical Recipes The Art of Scientific Computing, New York:
Cambridge University Press, 2007, Third Edition.
REEVES, William. Particle Systems: A technique for Modeling a Class of Fuzzy Objects.
SIGGRAPH 83, Julho 1983, p. 359-376.

86

SHIRLEY, Peter. et al. Fundamentals of Computer Graphics. Massachusetts: A K Peters,


2005, Second edition.
SIMS, Karl. Particle Animation and Rendering Using Data Parallel Computation.
SIGGRAPH 90, Agosto 1990, p. 405 413.
TREFETHEN N., Lloyd. Numerical Analysis In: GOWERS, Timothy, GREEN-BARROW,
June, LEADER, Imre. The Princeton Companion to Mathematics. New Jersey: 2008,
p.604-615.
VALADE, Janet, BALLAD, Bill, BALLAD Tricia. PHP and MySQL Web Development,
Indianapolis:Wiley Publishing, 2008.
VENETILLO, Jeronimo S., CELES, Waldemar. GPU-based particle simulation with intercollisions, Rio de Janeiro: TecGraf, Julho 2007.
WEISSTEIN, Eric W. "Disk Point Picking." From MathWorld--A Wolfram Web Resource.
http://mathworld.wolfram.com/DiskPointPicking.html.

WITKIN, Andrew. Physically Based Modeling, SIGGRAPH 2001 Course Notes, 2001.