Mecanica Classica 0301670

Eder Miranda Ferreira Leite
0301670, 8° Semestre
CONSTRUÇÃO DE FRAMEWORK PARA SUPORTE DE
ANIMAÇÕES "NEWTONIANAS" USANDO MECÂNICA CLÁSSICA
Jaguariúna
2006
Eder Miranda Ferreira Leite
0301670, 8° Semestre
CONSTRUÇÃO DE FRAMEWORK PARA SUPORTE DE
ANIMAÇÕES "NEWTONIANAS" USANDO MECÂNICA CLÁSSICA
Monografia apresentada à disciplina Trabalho

de Graduação, do curso de Ciência da
Computação da Faculdade de Jaguariúna, sob
orientação do Prof. Ms. Peter Jandl Jr., como
exigência parcial para conclusão do curso de
graduação.
Jaguariúna
2006
LEITE, Eder Miranda Ferreira. Construção de Framework para Suporte de Animações
"Newtonianas" Usando Mecânica Clássica. Monografia defendida e aprovada na Faculdade de
Jaguariúna em 11 de dezembro de 2006 para banca examinadora constituída pelos professores:
.
Prof. Ms. Peter Jandl Jr.
FAJ - Orientador
.
Prof. Ricardo Menezes Salgado
FAJ - Convidado
.
Prof. Ademário Araújo Jr.
FAJ - Convidado
DEDICATÓRIA
Dedico esse trabalho a todas as pessoas humildes como eu, que com muita garra e luta,
conseguiram chegar até aqui.
AGRADECIMENTOS
A realização desta monografia só foi possível pelo concurso de inúmeras pessoas.

Agradeço a todos que me apoiaram e me deram forças para continuar pelo caminho correto e
a todos que se opuseram e me tentaram ao caminho errado, pois agora que cheguei ao fim sei
que tanto os amigos quanto os inimigos nos dão força para continuar.
De modo particular agradeço:
Ao prof. Peter Jandl Jr. pela orientação dedicada e pelo estímulo dado a mim em todas
as fases de realização deste trabalho.
Aos professores do curso de Ciência da Computação que, durante a graduação, tanto

contribuíram para o meu crescimento intelectual e pessoal.
Aos meus amigos Rogério, Gustavo, Cléia, Rose, Danilo e Carlão pelo apoio, pela ajuda
no levantamento de material e pelas discussões críticas que, em muito enriqueceram a
realização deste trabalho.
Aos meus pais, Antônio e Rita e irmãs, Adriana e Juliana pelo apoio nas longas noites
em claro.
Aprender é a única coisa que a mente nunca se cansa, nunca tem medo e nunca
se arrepende.
(Leonardo da Vinci)
"Newtonianas" Usando Mecânica Clássica. 2006. Monografia (Bacharelado em Ciência da
Computação) – Curso de Ciência da Computação da Faculdade de Jaguariúna, Jaguariúna.
RESUMO
Hoje em dia, estamos o tempo todo cercado pela computação gráfica, seja ela voltada ao
entretenimento (jogos eletrônicos), educação ou publicidade e propaganda (comercias,
banners, etc...), tornou-se uma grande sensação para os profissionais de várias áreas. Porém
esse primeiro associado à tecnologia teve grande aumento qualitativo nas últimas décadas.
Um bom exemplo disso são os aparelhos celulares, que dispõe de vários recursos como jogos
2Ds e 3Ds, vídeos e fotos. Jogos que antigamente eram chamados de passa-tempo, hoje não
são mais conhecidos assim.
Por outro lado, o aumento da qualidade dos jogos implica consideravelmente no realismo dos
mesmos. Isso acabou unindo duas áreas até então distintas a computação gráfica e a física de
movimentos. Este trabalho visa apresentar um demo de framework Java que trate alguns
aspectos dessas duas áreas.
Será apresentada uma base de conhecimentos relacionados à física de movimentos, mais

explicitamente a mecânica clássica. Além de apresentar a tecnologia Java SE e sua ferramenta
para desenvolvimento 3D, a API Java 3D, na qual o framework foi totalmente baseado.
Por fim, todo framework será detalhado, desde o seu projeto até sua implementação, passando
pelas classes auxiliares que facilitam a vida do desenvolvedor.
Palavras Chave:
Computação Gráfica, Java, Java 3D, Jogos Eletrônicos, Física, Mecânica Clássica.
"Newtonianas" Usando Mecânica Clássica. 2006. Monografia (Bacharelado em Ciência da
Computação) – Curso de Ciência da Computação da Faculdade de Jaguariúna, Jaguariúna.
ABSTRACT
Nowadays, we are the time all surrounded by the graphical computation, been it directed to
the entertainment (electronic games), education or advertising and spreading (TV ads,
banners, etc…), it had become a great sensation for professionals among several areas.
However the first one, associated to the technology, had a great qualitative increase in the last
few decades. The cellular devices are a great example of it, because they make use of several
resources, such as 2D and 3D games, videos and photos. Games which were called by pastime
in the past actually are not known by that.
On the other hand, the games quality increasing implies considerably in their realism.
Provided by that two areas, distinct from graphical computation and from the movement
physics, were joined.
This work aims at to present a demon of framework Java that deals with some aspects these
areas. A base of knowledge related to the physics of movements, more clearly will be
presented the classic mechanics. Beyond presenting the Java technology (Java SE) and its
tool for development 3D, the API Java 3D, in which the framework was total based.
Finally, all framework will be detailed, since its project until its implementation, passing for
the classrooms auxiliary that facilitate the life of the programmer.
Key Words:
Graphical Computation, Java, Java 3D, Electronic Games, Physics, Classic Mechanics.
SUMÁRIO
1. INTRODUÇÃO................................................................................................................16
1.1. Computação Gráfica ......................................................................................................19
1.2. Problemas, Solução e Apresentação..............................................................................19
2. LEIS DE MOVIMENTO DA FÍSICA CLÁSSICA.........................................................21

2.1. Movimento Retilíneo.....................................................................................................21
2.1.1. Movimento Retilíneo Uniforme (MRU).....................................................................22
2.1.2. Movimento Retilíneo Uniformemente Variado (MRUV)............................................22
2.2. Velocidade .....................................................................................................................23
2.2.1. Velocidade instantânea ...............................................................................................23
2.2.2. Velocidade média .......................................................................................................23
2.3. Aceleração .....................................................................................................................24
2.3.1. Aceleração Constante .................................................................................................24
2.4. Queda Livre ...................................................................................................................25
2.5. Colisão...........................................................................................................................26
2.5.1. Impulso e Movimento Linear .....................................................................................26
2.5.2. Colisão Inelástica em uma Dimensão.........................................................................27
2.5.3. Colisões Elásticas em uma Dimensão ........................................................................27
2.6. Atrito..............................................................................................................................28
3. API JAVA 3D...................................................................................................................29

3.1. Linguagem Java.............................................................................................................29
3.2. Instalação .......................................................................................................................30
3.3. Universos Virtuais .........................................................................................................30
3.3.1. Grafo de Cena.............................................................................................................30
3.3.2. Principais Classes da API Java 3D .............................................................................32
3.3.2.1. SimpleUniverse .......................................................................................................32
3.3.2.2. GraphicsConfiguration ............................................................................................32
3.3.2.3. Canvas3D ................................................................................................................32
3.3.2.4. BranchGroup ...........................................................................................................33
3.3.2.5. TransformGroup e Transform3D ............................................................................33
3.3.3. Geometrias..................................................................................................................34
3.3.4. Aparências ..................................................................................................................35
4. AVALIAÇÃO E SELEÇÃO DE FUNCIONALIDADES MÍNIMAS ............................36

4.1. Avaliação .......................................................................................................................36
4.1.1. Ambiente ....................................................................................................................37
4.1.2. Gatilho ........................................................................................................................38
4.1.3. Temporizador..............................................................................................................38
4.1.5. Alvo ............................................................................................................................40
5. PROJETO E IMPLEMENTAÇÃO ..................................................................................41

5.1. A Classe Ambiente ........................................................................................................41
5.1.1 Construtores.................................................................................................................41
5.1.1.1 Ambiente ( Component ) ..........................................................................................41
5.1.1.2 Ambiente ( Component, int )....................................................................................42
5.1.1.3 Ambiente ( Component, int, float, float ) .................................................................42
5.1.1.4 Ambiente ( Component, int, float, float, Appearance ) ............................................43
5.1.2 Métodos .......................................................................................................................44
5.1.2.1 setPosicaoCamera ( float, float, float ) .....................................................................44
5.1.2.2 setPlanoDeFundo ( Color3f )....................................................................................44
5.1.2.3 setPlanoDeFundo ( String, Component )..................................................................44
5.1.2.4 setLuzAmbiente ( )6 ..................................................................................................45
5.1.2.5 setLuzCapacete ( ) ....................................................................................................45
5.1.2.6. getCanvas ( )............................................................................................................45
5.1.2.7. adicionar ( TransformGroup ) .................................................................................46
5.1.2.8. getEsferaDeVisualizcaoPadrao ( )...........................................................................46
5.1.3 A Classe Chao .............................................................................................................46
5.1.3.1. Chao (TransformGroup, float, float, Appearance) ..................................................46
5.1.3.4. getLaguraChao ( )....................................................................................................47
5.1.3.5. getProfundidadeChao ( )..........................................................................................47
5.2. A Classe Gatilho............................................................................................................47
5.2.1. Construtor ...................................................................................................................48
5.2.1.1. Gatilho ( ) ................................................................................................................48
5.2.2. Métodos ......................................................................................................................48
5.3. A Classe Temporizador .................................................................................................49
5.3.1. Construtores................................................................................................................51
5.3.1.1. Temporizador ( )......................................................................................................51
5.3.1.2. Temporizador ( int, int, long ) .................................................................................52
5.3.1.2. Temporizador ( int, int, long, long, long ) ...............................................................53
5.3.1.3. Temporizador ( int, int, long, long, long,
long, long, long, long, long ) .............................................54
5.3.2. Métodos ......................................................................................................................55
5.4. As Classes Interpoladoras..............................................................................................56
5.4.1. InterpoladorMRU .......................................................................................................57
5.4.1.1. Construtores.............................................................................................................57
5.4.1.1.1. InterpoladorMRU ( TransformGroup ).................................................................58
5.4.1.1.2. InterpoladorMRU ( Alpha, TransformGroup ) .....................................................58
5.4.1.1.3. InterpoladorMRU ( Alpha, TransformGroup, Point3f, Poinf3f )..............................58
5.4.1.2. Métodos ...................................................................................................................59
5.4.2. InterpoladorAceleracao ..............................................................................................59
5.4.2.1. Construtores.............................................................................................................59
5.4.2.1.1. InterpoladorAceleracao ( TransformGroup )........................................................60
5.4.2.1.2. InterpoladorAceleracao ( Alpha, TransformGroup ) ............................................60
5.4.2.1.3. InterpoladorAceleracao ( Alpha, TransformGroup, double ) ...............................60
5.4.2.1.4. InterpoladorAceleracao ( Alpha, TransformGroup,
double, Point3f, Poinf3f ) .................................61
5.4.2.2. Métodos ...................................................................................................................61
5.5. A Classe Alvo................................................................................................................61
5.5.1. Construtor ...................................................................................................................63
5.5.1.1 Alvo ( Component, TransformGroup ).....................................................................63
5.5.1.2. Alvo ( Component, TransformGroup, String) .........................................................63
5.5.2. Métodos ......................................................................................................................64
5.5.2.1. setImagemAlvo ( String ) ........................................................................................64
5.5.2.2. setPosicaoImagem ( float, float, float ) ...................................................................64
5.5.2.3. setPosicaoImagem ( Point3f )..................................................................................65
5.5.2.4. setEscalaImagem ( Double, Double ) ......................................................................65
6. RESULTADOS OBTIDOS..............................................................................................66
6.1. Comparativo de código entre do framework e da API Java 3D ....................................67
6.1.1. Aplicação usando API Java 3D ..................................................................................67
6.1.2. Aplicação usando o framework ..................................................................................72
6.2. Documentação do framework........................................................................................75
7. CONCLUSÃO..................................................................................................................79
8. REFERÊNCIAS BIBLIOGRÁFICAS .............................................................................80
ANEXO I..............................................................................................................................82
Diagrama de Caso de Uso ....................................................................................................82
Diagrama de Classes.............................................................................................................84
Diagrama de Seqüência ........................................................................................................86
ANEXO II ............................................................................................................................87
A classe JD3Browser............................................................................................................87
J3DBrowser ( ) .....................................................................................................................88
adicionarAmbiente ( Ambiente ) ..........................................................................................88
setTitulo ( String ) ................................................................................................................88
A Classe MouseRotateY.......................................................................................................89
A Classe Cores .....................................................................................................................89
getAparenciaPadrao ( ) .........................................................................................................90
setAparencia ( Color3f ) .......................................................................................................90
setAparencia ( Componet, String ) .......................................................................................90
LISTA DE FIGURAS
FIGURA 1: Jogos de ontem e hoje............................................................................... 17

FIGURA 2: Exemplo de movimento retilíneo uniforme (MRU) ................................. 22
FIGURA 3: Aceleração Constante. .............................................................................. 24
FIGURA 4: Camada de software existente quando se utiliza Java 3D........................30
FIGURA 5: Exemplo de representação gráfica de um grafo
de cena (BOUVIER, 2000).......................................................................... 31
FIGURA 6: Exemplos de geometrias simples (MANSSOUR, 2003).............................. 34
FIGURA 7: Exemplos de geometrias complexas (MANSSOUR, 2003)......................... 34
FIGURA 8: Exemplo de objeto Java 3D reenderizado (BOUVIER, 2000).................... 35
FIGURA 9: Visão geral do funcionamento do framework........................................... 36
FIGURA 10: Comparação da luz de ambiente, do lado esquerdo luz acesa
e do direito luz apagada............................................................................. 45
FIGURA 11: Componente Gatilho instanciado. ............................................................ 47
FIGURA 12: Gráfico de representação do objeto Alpha (BOUVIER, 2006). .................. 49
FIGURA 13: Exemplos de objetos Alpha personalizados (BOUVIER, 2000). ................ 51
FIGURA 14: Exemplo de gráfico do construtor Temporizador (BOUVIER, 2000). ....... 52
FIGURA 15: Exemplos de gráficos de animação que podem ser instanciados
pelo construtor básico (BOUVIER, 2000)................................................... 53
pelo construtor intermediário (BOUVIER, 2000). ...................................... 54
FIGURA 17: Diagrama de classe ilustrando as classes que especializam Behavior...... 57
FIGURA 18: Exemplo de Billboard (VORTEX, 2006). .................................................. 62
FIGURA 19: Resultado da Listagem 10. ....................................................................... 72
FIGURA 20: Resultado da Listagem 11. ....................................................................... 74
FIGURA 21: Exemplo de tags Javadoc (DEITEL, 2005)................................................76
FIGURA 22: Exemplo Javadoc convertido. .................................................................. 78
FIGURA 23: Diagrama de Caso de Uso do framework. ................................................ 82
FIGURA 24: Diagrama de classes do framework. ......................................................... 85
FIGURA 25: Diagrama de seqüência do framework...................................................... 86
FIGURA 26: Exemplo de objeto JD3Browser............................................................... 87
LISTA DE TABELAS
TABELA 1: Documentação do Caso de Uso Criar Ambiente 3D. ............................... 82

TABELA 2: Documentação do Caso de Uso Criar Objeto Alvo.................................. 83
TABELA 3: Documentação do Caso de Uso Criar Temporizador. .............................. 83
TABELA 4: Documentação do Caso de Uso Criar Animação. .................................... 84
LISTA DE EQUAÇÕES
EQUAÇÃO 1: Movimento Retilíneo Uniforme ............................................................... 22

EQUAÇÃO 2: Aceleração. ............................................................................................... 23
EQUAÇÃO 3: Velocidade. ............................................................................................... 23
EQUAÇÃO 4: Aceleração constante. ............................................................................... 25
EQUAÇÃO 5: Impulso e movimento linear..................................................................... 26
EQUAÇÃO 6: Impulso e movimento linear..................................................................... 27
EQUAÇÃO 7: Colisão. ..................................................................................................... 28
LISTA DE LISTAGENS
Instância do SimpleUniverse. ................................................................................................... 32

Instância do GraphicsConfiguration. ....................................................................................... 32
Instância do Canvas3D............................................................................................................. 33
Instância do BranchGroup. ...................................................................................................... 33
Instância do Transform3D. ....................................................................................................... 33
Instancia do objeto Temporizador. ........................................................................................... 52
Exemplo de aplicação usando apenas a API Java 3D. ............................................................. 71
Exemplo de aplicação usando o framework. ............................................................................ 74
Exemplo de código para conversão em Javadoc...................................................................... 77
LISTA DE SIGLAS
2D – Segunda dimensão ou bidimensional.
3D – Terceira dimensão ou tridimensional.
AWT – Abstract Window Toolkit.
HTML – Hyper Text Markup Language (Linguagem de Marcação de Hipertexto).
IDE – Integrated Development Environment (Ambiente Integrado de Desenvolvimento

de Software).
Java SE – Java Standard Edition.
JRE – Java Runtime Environment.
JVM – Java Virtual Machine (Máquina Virtual Java).
MIT – Massachusetts Institute of Technology.
MRU – Movimento Retilíneo Uniforme.
MRUV – Movimento Retilíneo Uniformemente Variado.
PDA – Personal Digital Assistant (Assistente Pessoal Digital).
PC – Personal Computer (Computador Pessoal).
RGB – Red, Green and Blue (Vermelho, Verde e Azul).
UML – Unified Modeling Language (Linguagem de Modelagem Unificada).
URL – Universal Resource Locator (Localizador Uniformizado de Recursos).
VRML – Virtual Reality Modelating Language (Linguagem para Modelagem

de Realidade Virtual).
16
1. INTRODUÇÃO
Hoje em dia é fácil notar o grande avanço na área de informática. Quem atua nesta
área sabe que, tecnologia de ponta hoje, poucos dias depois não será mais. É muito fácil
encontrar “supercomputadores” na rua (em qualquer lugar), um simples celular, aparelhos
mais comuns do século XXI, tem muito mais funcionalidades de que muitos computadores
em atividade. Comparando computadores do “ponta” de século passado, com os celulares
de hoje em dia, muitos desses computadores perderam em recursos para o celular.
Outro fator fácil de notar é o tamanho desses dispositivos, cada vez mais os
dispositivos com celulares, PDAs e até computadores pessoal, tornam-se menores, mas
mantém ou aumentam seus recursos como capacidade de memória, armazenamento de dados
e processamento de tarefas.
Essa evolução do hardware impulsionaram os desenvolvedores à criarem sistemas cada

vez mais bonitos graficamente. Notem a grande evolução gráfica do sistema operacional
Windows. No ano de 1995, a Microsoft lançou o Windows 95, esse sistema foi bem aceito pelos
usuários, pois disponibilizava uma interface bem mais amigável, essa versão já havia sofrido uma
grande evolução gráfica se comparada às versões anteriores dos sistemas operacionais da
Microsoft. Mas tarde, seis anos depois, em 2001, a Microsoft lançou o Windows XP, em um curto
espaço de tempo, esse sistema sofreu uma nova evolução gráfica tornando-se ainda mais amigável
e bonita. A Microsoft chegou a anunciar que a nova versão de seu sistema operacional, o Windows
Vista, teria um desktop 3D, mas infelizmente esse recurso foi cancelado, podendo ser lançando
com um recurso adicional. Em contra partida, a SUN (2006d), está desenvolvendo um projeto
interessante de desktop 3D chamado Looking Glass, o qual é rodado sobre a máquina virtual Java,
sendo assim pode ser portada à qualquer plataforma.
Essa evolução gráfica também é muito fácil de acompanhar nos jogos eletrônicos. Jogos
como os velhos clássicos do Atari 26001, como Enduro, Pitfall e River Raid se comparados
graficamente com jogos atuais como Need for Speed, Prince of Percia ou Fligth Simulator,
certamente ficará fácil notar a grande evolução da computação gráfica (ver Figura 1).
1
“Atari 2600, foi um vídeo game projetado por Nolan Bushnell e lançado em 1978 nos Estados Unidos e em 1983 no
Brasil. Considerado um símbolo cultural dos anos 80, foi um fenômeno de vendas no Brasil entre os anos de 1984 a
1986 e seus jogos permanecem na memória de muitos que viveram a juventude nesta época“ (WIKIPÉDIA, 2006a).
17
FIGURA 1: Jogos de ontem e hoje.
É exatamente nesse pilar que o trabalho se sustenta: computação gráfica. Esse trabalho
tratará o desenvolvimento de um framework para suporte de animações 3D, usando alguns
movimentos da mecânica clássica, tendo como objetivo, auxiliar futuros desenvolvedores
a criarem animações 3D, área que atualmente não existe nenhuma ferramenta gratuita,
diminuindo o tempo gasto para a criação das mesmas, podendo ainda ser usado no
desenvolvimento de jogos eletrônicos, além de facilitar o aprendizado da tecnologia Java 3D
em ambiente educacional.
Como dito, esse trabalho demonstrará o estudo dos movimentos de mecânica clássica
da física, tais como MRU (movimento retilíneo uniforme) e MRUV (movimento retilíneo
uniformemente variado).
Das tecnologias disponíveis no mercado, a linguagem de programação Java foi a que

recebeu atenção nesse projeto, pelo fato dela ser de uso livre e suporte multi-plataforma,
assim, será possível desenvolver um framework que rode na maioria dos sistemas
operacionais disponíveis no mercado, sendo que o usuário final não tenha nenhum ônus
financeiro com licença de software. Além disso, a linguagem Java tem uma ótima API de
suporte a programação 3D, e ultimamente, está sendo bem aceita no desenvolvimento de
jogos eletrônicos para computadores e principalmente para equipamentos móveis, como
PDAs e celulares. Bons exemplos desses jogos, podem ser encontrando em SUN (2006a). Para
18
edição de código, usou-se a IDE de desenvolvimento NetBeans que também pode ser
encontrado em SUN (2006a).
Sendo assim, este trabalho possui os seguintes objetivos:
• Construção de um framework para facilitar futuros desenvolvedores a criarem

animações baseadas nas leis de movimento da mecânica clássica;
• Desenvolvimento de um framework para suportar diversos tipos de movimentos,
tais como: MRU, MRUV, queda livre, colisão e impulsão.
• Facilitar a criação de animações de objetos em um ambiente 3D, sem que o usuário
final (programador/desenvolvedor ou instrutor) necessite ter um vasto
conhecimento da API Java 3D (SUN, 2006b).
• Facilitar o uso da tecnologia Java 3D em ambiente educacional, podendo ser usado
como uma formação de introdução a computação gráfica.
• Facilitar o desenvolvimento de jogos eletrônicos tridimensionais baseados na
tecnologia Java, levando em conta que essa tecnologia vem sendo bem aceita no
mercado para esse tipo de tarefa, principalmente falando de dispositivos móveis,
o qual esse trabalho não engloba.
• Acabar com a dependência de sistema operacional e isentar os desenvolvedores
de ônus financeiros referentes a pagamentos de licenças de produtos.
Nos capítulos seguintes, serão apresentados alguns movimentos da mecânica clássica
da física, descrevendo um breve comentário sobre cada um desses movimentos, mostrando
suas fórmulas para aproximação, e exemplos de aplicação desses movimentos no mundo real.
Em seguida, será apresentada uma breve introdução sobre a linguagem Java e sua
importância no desenvolvimento desse projeto. Além disso, serão apresentadas as
funcionalidades básicas da API Java 3D, mostrando suas principais classes e conceitos para
criação de um mundo virtual.
E por fim, será apresentada a solução proposta, comentando cada uma das classes do
framework, formas de uso dessas classes e seus métodos. Além de comparar o código fonte
de uma aplicação que usa apenas o Java 3D puro e outra usando o Java 3D com o framework.
19
1.1. Computação Gráfica
Computação gráfica é uma área da ciência da computação destinada a geração de

imagens em geral, como forma de apresentação de dados e informação, como gráficos
financeiros, forma de recriação do mundo real e modelos de pessoas e objetos em um
ambiente 3D.
“Em 1950, início da computação gráfica, pela primeira vez, um tubo de raios
catódicos é ligado à um computador, on MIT e projeto Sage, onde um radar
foi ligado à um computador, num projeto do exército americano, utilizando
interação com Light Pen”...
“Em 1959, surge o termo computer graphics - criado por Verne L. Hudson,
quando o mesmo coordenava um projeto para a Boeing de simulação
de fatores humanos em aviões”...
“Em 1962, no MIT o projeto TX2 com o aluno Ivan Sutherland usa um
computador para fazer desenhos em sua tese de doutorado”...
“E em 1970, surgem os primeiros monitores à varredura” (WANGENHEIM, 2006).
Hoje em dia é fato que, a computação gráfica faz parte de vida e muitas pessoas, pois
está presente em vários lugares como filmes, jogos eletrônicos, e até câmeras digitais
e celulares. Mas nesse trabalho será apresentada como uma forma de entretenimento, além de
discutir a importância deste em ambiente educacional.
1.2. Problemas, Solução e Apresentação
Esse trabalho envolve duas questões importantes na computação gráfica: a animações

de objetos e o realismo dessas animações, e cada vez mais esses dois fatores estão mais
íntimos e diretamente ligados, pois quanto mais próximo a animação está dos movimentos
reais, mais interessante e agradáveis serão para quem os vê.
O foco aqui é facilitar para o usuário final (desenvolvedor ou instrutor), a aplicação de

alguns movimentos da física mecânica em animações de objetos 3D, sem que o usuário tenha
a necessidade de conhecer como esse movimento funciona ou é aproximado através
de formulas e cálculos.
20
Hoje em dia, é muito comum a aplicação desses movimentos em jogos eletrônicos,

pois sem eles os jogos acabariam perdendo credibilidade junto aos jogadores. Ninguém
gostaria de perder seu tempo em algo que não traz nenhuma diversão. Por isso hoje as grandes
empresas desenvolvedoras de jogos, investem tanto nessa área de realismo (física
e inteligência artificial dos personagens).
Um personagem quando se movimenta em um jogo, e encontra um obstáculo sólido

(por exemplo: árvore, caixa, parede,...), não poderá simplesmente atravessá-lo como se esse
objeto não existisse. O mínimo que o jogador espera é que esse personagem colida com o
objeto. Outro exemplo seria uma bola de borracha caindo de uma altura qualquer, se essa bola,
ao ter contanto com o chão, ela simplesmente parar, com certeza não passará uma aproximação
de um movimento real. O que o jogador espera é que essa bola “quique” algumas vez no chão,
aí sim seria considerado um movimento real.
Esses são simples exemplos de realidade em jogos eletrônicos, e com certeza, esses
movimentos não são tão simples assim de reproduzi-los, será necessário uma boa base de
conhecimento da física mecânica, além disso, é bem complexa a implementação desses
cálculos nessas animações.
Existem sim, alguns bons motores2 para construção de jogos realistas, mas os
desenvolvedores de jogos deparam com dois problemas. Em primeiro lugar, a maioria desses
motores são mono plataformas, ou seja, rodam apenas em um sistema operacional, ou em
apenas um tipo de dispositivo, com isso, seu jogos, acabam ficando presos a um único sistema
operacional. O segundo problema é, por serem proprietários, os desenvolvedores são
obrigados a pagar um alto preço para licenciar essas ferramentas. Isso acaba inviabilizando
o uso principalmente na área educacional.
A proposta desse trabalho é justamente tentar sanar esses dois problemas, criando uma
ferramenta de fácil uso, com portabilidade a vários sistemas operacionais, além de ser livre de
ônus financeiros para o desenvolvedor, ou seja, software livre e de código aberto.
2
“Um motor pode ser definido como um conjunto de funcionalidades reutilizáveis em alto nível que ajudam o
programador a implementar as tarefas mais comuns de um jogo. Para o exemplo, para jogos 2D, devem
possuir recursos de desenho que permitam a manipulação de camandas (layers), imagens (tiles) e animações
(sprites)”.(MALFATTI, 2004).
21
2. LEIS DE MOVIMENTO DA FÍSICA CLÁSSICA
Seria difícil imaginar um mundo onde nada se movimentasse, por isso é tão importante
o estudo do movimento. "Na Física, o movimento é a variação de posição espacial de um
objeto ou ponto material no decorrer do tempo” (WIKIPÉDIA, 2006b).
A ciência física que estuda o movimento é a mecânica. Ela se preocupa tanto com o
movimento em si, quanto com aquilo que o faz existir, inexistir ou cessar. Se abstraírem as
causas do movimento e preocupar-se apenas com a descrição do movimento, ter-se-á estudos
de uma parte da mecânica chamada cinemática.
Esse capítulo apresentará alguns dos principais movimentos da física clássica,

introduzindo cada um dos movimentos citados a seguir:
• Movimento retilíneo;
• Velocidade;
• Aceleração;
• Queda livre;
• Colisão e impulsão;
• Atrito;
2.1. Movimento Retilíneo
De acordo com WIKIPÉDIA (2006b),
Em mecânica clássica, movimento retilíneo é o movimento em que o objeto,

corpo ou ponto material se movimenta apenas em trajetórias lineares (reta).
Para tanto, a velocidade mantem-se constante ou variada, sendo que a variação
da velocidade dá-se somente em módulo, nunca em direção. A aceleração, se
variar, também variará apenas em módulo, nunca em direção e deverá
orientar-se sempre em paralelo com a velocidade.
22
2.1.1. Movimento Retilíneo Uniforme (MRU)
No movimento retilíneo uniforme a velocidade é constante e, portanto não existe

aceleração. O objeto ou ponto material se desloca distâncias iguais em intervalos de
tempo iguais.
1s 1s
10m 20m 30m
FIGURA 2: Exemplo de movimento retilíneo uniforme (MRU)
Na Figura 2, é demonstrado um exemplo de MRU. O objeto móvel (caixa) se desloca

10m a cada um dos intervalos de tempo iguais (de 1s até 2s, e de 2s até 3s). A velocidade
é constante e igual a 10m/s.
Vale lembrar que uma vez que não se produz aceleração sobre qualquer objeto ou ponto
material em MRU a resultante das forças aplicadas é nula, sendo assim, sua velocidade
em qualquer instante é igual à velocidade média. A Equação 1 é responsável por esse calculo.
V = Vi = Vm = ∆S / ∆t
EQUAÇÃO 1: Movimento Retilíneo Uniforme
2.1.2. Movimento Retilíneo Uniformemente Variado (MRUV)
Movimento retilíneo uniformemente variado é aquele em que o corpo sofre acelerações

constantes, mudando de velocidade num dado incremento ou decremento conhecido, mas
para isso a aceleração deve ter a mesma direção da velocidade para que o movimento seja
ainda retilíneo.
Conforme MASSARO (2006) o MRUV caracteriza-se pelos seguintes conceitos:
• A aceleração é o quociente da variação de velocidade ( ∆v ) pelo intervalo

de tempo correspondente ( ∆t ), ver Equação 2:
23
∆v
a= = cte(≠ 0)
∆t
EQUAÇÃO 2: Aceleração.
• A velocidade não permanece constante, aumenta ou diminui ao longo do tempo,

conforme o valor da aceleração comunicada.
• A posição ocupada pelo móvel e a distância percorrida, são determinadas pelas
Equação 3:
1 2 2 2
s = s 0 + v0 t +
2 t v =v
a ou 0
+ 2a∆s
EQUAÇÃO 3: Velocidade.
2.2. Velocidade
2.2.1. Velocidade instantânea
De acordo com SILVA (2006a),
Todos os carros, trens, ônibus e mesmo os aviões têm um instrumento que

mede a velocidade: é o velocímetro. Se olhar para o velocímetro de um carro
em movimento e estiver marcando 60 km/h, estará lendo uma velocidade
instantânea, ou seja, a velocidade que o veículo tem no instante em que olhar
para o velocímetro.
2.2.2. Velocidade média
Como visto a velocidade instantânea varia o tempo todo. Em uma pista, a velocidade
é pequena nas curvas e nas subidas, mas nas descidas e nas estradas em boas condições,
a velocidade instantânea é maior, para calcular a velocidade média, não há necessidade de
saber a velocidade que o velocímetro marcou em cada instante durante a viagem, precisa-se
conhecer somente à distância percorridas e o tempo total da viagem.
Se um carro, em uma viagem, percorre uma distância de 420 km em 6,0 h, ele andaria
em média 70 km/h. Este resultado foi obtido dividindo-se a distância percorrida pelo tempo de
viagem, que é denominado velocidade.
24
Assim, a velocidade instantânea é diferente da velocidade média. A velocidade

instantânea é a velocidade do veículo a cada instante, enquanto a velocidade média é uma
velocidade calculada para qualquer intervalo de tempo.
2.3. Aceleração
Esse capítulo trata a aceleração, que é a taxa de variação de sua velocidade, em um

instante considerado, ou seja, a taxa de tempo à qual um objeto muda sua velocidade.
A aceleração pode ser positiva, velocidade está crescendo com o tempo, ou negativa, está
decrescendo com o tempo.
Mas o interessante para esse trabalho é conhecer a aceleração constante de um objeto.
2.3.1. Aceleração Constante
Conforme o site UNIFICADO (2006), a aceleração constante é obtida, quando um objeto

acelerado muda sua velocidade pela mesma quantia a cada segundo. Isto se chama aceleração
constante desde que a velocidade esteja mudando por uma quantia constante a cada segundo.
“Um objeto com uma aceleração constante não deve ser confundido com um objeto com uma
velocidade constante”.Se um objeto está mudando sua velocidade por uma quantia constante
ou uma quantia variada então é um objeto acelerando. E um objeto com uma velocidade
constante não está acelerando. A Figura 3 ilustra um exemplo de aceleração constante.
0m 0s
15m 1s
25m 2s
35m 3s
FIGURA 3: Aceleração Constante.
Um objeto cadente, por exemplo, normalmente acelera conforme cai. Observando o

movimento do objeto em queda-livre, na Figura 3 é fácil perceber que o objeto cai a uma
25
velocidade média de 5 m/s no primeiro segundo, 15 m/s no segundo, 25 m/s no terceiro

segundo, 35 m/s no quarto segundo, etc. Esse objeto em queda-livre estaria acelerando
constantemente. Dados estes valores de velocidade durante cada intervalo de tempo sucessivo,
pode-se dizer que o objeto cairia 5 metros no primeiro segundo, 15 metros por segundo
(para uma distância total de 20 metros), 25 metros no terceiro segundo (para uma distância
total de 45 metros), 35 metros no quarto segundo (para uma distância total de 80 metros
depois de quatro segundos).
A aceleração de qualquer objeto é calculada pela Equação 4:
a=
∆v
=
v −v
f i
∆t t −t
f i
EQUAÇÃO 4: Aceleração constante.
2.4. Queda Livre
“Denomina-se queda livre os movimentos de subida ou de descida que os corpos realizam

no vácuo. Estes movimentos são descritos pelas mesmas equações do movimento uniformemente
variado. A aceleração do movimento é a aceleração da gravidade g .” (SILVA, 2006b).
A aceleração da gravidade tem valores diferentes para os diversos pontos da superfície

2 2
terrestre. É uma variação pequena: de 9,78 / s , no equador, até 9,83 / s nos pólos, supondo
medidas feitas ao nível médio dos mares. Em primeira aproximação adota-se para o g o valor
2
de 9,80 / s em qualquer local.
Em 1 segundo, portanto, um corpo abandonado a partir do repouso percorre a distância

4,90m. Mas antes de afirmar que a equação é verdadeira, deve-se testá-la nas diferentes
situações que podem ocorrer: pequenas distâncias e distâncias intermediárias. Se os resultados
matemáticos concordarem com a realidade, então a equação realmente descreve o movimento.
26
2.5. Colisão
Segundo CHAVES (2001), “a colisão é uma interação entre dois ou mais corpos, com
duração limitada. O choque entre duas bolas de sinuca é, portanto, uma colisão. As bolas
se aproximam uma da outra, interagem fortemente entre si durante o choque e em seguida se
afastam”. O importante aqui é o contato entre dois corpos, e que possa definir um antes e um depois.
2.5.1. Impulso e Movimento Linear
“Impulso é a grandeza que descreve o que ocorre quando uma forma é aplicada sobre
um objeto em um intervalo de tempo ∆t .” A relação de impulso e colisão, é definida quando
duas bolas se chocam, exercendo uma força sobre a outra. Isso provoca uma variação do
estado de movimento, nas duas bolas, ou seja, quando um impulso é dado a uma bola, uma
força é exercida sobre ela, alterando sua velocidade, isto é, alterando sua quantidade de
movimento. Nesse caso as duas bolas tem seu estado de movimento alterado, pois, pela
terceira lei de Newton, quando um objeto exerce força sobre outro, este também exerce uma
força sobre o primeiro (CHAVES, 2001).
Conforme JUSTINO (2006), aplicando a segunda lei de Newton3 na forma, têm-se
quantitativamente: F = dp / dt , sendo F (t ) , uma força variável no tempo. Integrando
a equação acima, no intervalo t, ou seja, de um instante inicial t i

(antes da colisão), até um
instante final t f
(após a colisão), obtém-se a Equação 5:
p f d p = p f F (t )dt
∫p ∫p
i i
EQUAÇÃO 5: Impulso e movimento linear.
3
Segunda lei de Newton ou princípio fundamental da dinâmica: “A resultante das forças que agem num
corpo é igual ao produto de sua massa pela aceleração adquirida” (WIKIPÉDIA, 2006c).
27
O lado esquerdo desta equação é p f

, é a variação do momento linear da partícula.
O lado direito é uma medida da duração e da intensidade da força de colisão, chamado

impulsão (J ) da colisão. Assim, a variação da quantidade de movimento linear de cada corpo
em uma colisão é igual a impulsão que age sobre esse corpo (Equação 6):
p − p =∆p = J
f i
EQUAÇÃO 6: Impulso e movimento linear.
Essa equação é denominada teorema do impulso-movimento linear4. Sendo F méd
a intensidade média da força , pode-se escrever a intensidade da impulsão como J = F méd

∆t ,
onde, ∆t é a duração da colisão.
2.5.2. Colisão Inelástica em uma Dimensão
De acordo com HALLIDAY & RESNICK (1994),
Quando solta-se uma superbola sobre um chão áspero, ela perde muito pouco
de sua energia cinética5 com o impacto, retrocedendo essencialmente á sua
altura original; no entanto, se soltar uma bola de golfe, ela perderá parte de sua
energia cinética e retrocederá a 60% de sua altura original. Contudo, se você
largar uma bola feita de massa de vidraceiro no chão, ela perderá toda a sua
energia cinética e não retrocederá de modo algum. Embora o momento linear
seja conservado em todas as colisões, a energia cinética nem sempre
é conservada.
2.5.3. Colisões Elásticas em uma Dimensão
Conforme JUSTINO (2006),
As colisões que ocorrem no dia-a-dia são consideradas inelásticas, no entanto,

algumas delas podem ser aproximadas como elásticas, fazendo a aproximação
de que a energia cinética total dos corpos que colidem se conserva,
não havendo transferência para outras formas de energia:
(energia cinética antes da colisão) = (energia cinética depois da colisão).
4
A impulsão e a quantidade de movimento linear são ambas grandezas vetoriais e possuem as mesmas
unidades e dimensões.
5
Em física, a energia cinética é a quantidade de trabalho que teve que ser realizado sobre um objeto para
tirá-lo do repouso e coloca-lo a uma velocidade V. Sua formala é dada por: K = ½mv2.
28
Pode-se dizer que em uma colisão elástica, a energia cinética de cada corpo que colide
pode variar, mas a energia cinética total do sistema não pode variar. Considerando um corpo
de massa m1
e velocidade inicial v1i
que se move em direção a um corpo de massa m , que
2
está inicialmente em repouso (v 2i

= 0 ). A quantidade movimento linear do sistema
se conserva, como escrito na Equação 7:
2 m1
v = v
2f
m +m
1 2
1i
EQUAÇÃO 7: Colisão.
2.6. Atrito
De acordo com o WIKIPÉDIA (2006d),
Em física, o atrito é uma força natural que atua apenas quando um objeto está
em movimento em contato com outro, e sempre para lhe diminuir o
movimento. Esta força é causada pelo contato dos dois corpos ou meio em que
se move o corpo em movimento, neste caso especial, designado por
viscosidade. O atrito com uma superfície depende da pressão entre o objeto e a
superfície, quanto maior for a pressão maior será o atrito. Passar um dedo pelo
tampo de uma mesa pode ser usado como exemplo prático: se pressionar com
força o dedo, o atrito aumenta e o dedo pára.
Embora se oponham ao movimento, todas as formas de transporte que se deslocam

sobre rodas não poderiam mover-se sem o atrito: é o atrito entre as rodas e o solo que permite
as rodas agarrarem-se ao solo, produzindo movimento pela transferência de forças.
Pode parecer estranho afirmar que nenhuma força é preciso para manter um corpo em
movimento quando um avião a jato se desloca a uma velocidade constante utilizando os seus
poderosos motores. A razão é que a força dos motores que impelem o avião para frente
é igualada pelo atrito com o ar através do qual o avião se movimenta, as duas forças
equilibram-se de tal modo que nenhuma atua sobre o avião e ele, portanto continua a mover-
se com uma velocidade constante. Se aumentar o poder dos motores o avião mover-se mais
rapidamente, até que o atrito aumente de modo a corresponder à força desejada, movendo-se
então, a uma maior mas constante velocidade. Sua equação é dada por V = v0 + ad 2 .
29
3. API JAVA 3D
“A API Java 3D consiste em uma hierarquia de classes Java que serve como interface
para o desenvolvimento de sistemas gráficos tridimensionais”. Possui construtores de alto
nível que permitem a criação e manipulação de objetos geométricos, especificados em um
universo virtual. As cenas são representadas através de grafos, e os detalhes de sua
visualização são gerenciados automaticamente. Assim, o desenvolvimento de um programa
Java 3D se resume na criação de objetos e no seu posicionamento em um grafo de cena.
(MANSSOUR, 2003).
Java 3D foi construída com o objetivo de criar uma API que fosse independente de
plataforma, semelhante a VRML. Em colaboração, Intel, Silicon Graphics, Apple e Sun
Microsystems, definiram a especificação Java 3D. Em 1998, a Sun disponibilizou sua
implementação para download. O Java 3D, é uma API baseada nas bibliotecas gráficas
OpenGL e DirectX, e os programas podem ser escritos como aplicação, applet, ou ambas.
3.1. Linguagem Java
Segundo MANSSOUR (2003), “Java é uma linguagem de programação orientada

a objetos, independente de plataforma, que foi desenvolvida pela Sun Microsystems, Inc.
Atualmente, é uma das linguagens mais utilizadas para o desenvolvimento de sistemas”.
O ambiente Java engloba tanto um compilador, quanto um interpretador. Para executar
programas Java é utilizado o JRE (Java Runtime Environment), o mesmo normalmente
é instalado com um plugin do navegador. E para desenvolvimento de novos programas,
é preciso instalar o Java SE (Java Standard Edition) que inclui o compilador, a JVM (Java
Virtual Machine), responsável por interpretar os bycotes Java e transformá-los em linguagem
de máquina, e uma API básica que dá suporte as funcionalidades de entrada e saída, interface
gráfica, coleções, entre outras.
O objetivo deste trabalho não é ensinar a programar na linguagem Java,

as funcionalidades da linguagem não são abordadas. Sugere-se o estudo da documentação
disponível em SUN (2006b), bem como de livros especializados para quem tem interesse
em aprender a linguagem.
30
3.2. Instalação
Todo software necessário para trabalhar com Java 3D é gratuito e pode ser encontrado
no site da SUN (2006a). A primeira etapa consiste em instalar o Java SE, versão 1.5 ou
posterior. Num segundo momento, deve-se instalar a API Java 3D. Como Java 3D é baseada
nas bibliotecas OpenGL ou DirectX, estas também devem estar instaladas. (ver Figura 4).
APLICAÇÃO / APPLETS
JAVA / JAVA 3D
OPEN GL DIRECT X
HARDWARE
FIGURA 4: Camada de software existente quando se utiliza Java 3D.
Para facilitar o desenvolvimento de aplicações Java, recomenda-se a utilização de IDEs

(Integrated Development Environment ou ambiente integrado de desenvolvimento
de software), tal como NetBeans ou Eclipse.
3.3. Universos Virtuais
Para criar e manipular objetos geométricos 3D, os programadores trabalham apenas com
construtores de alto nível, pois os detalhes para a geração das imagens são gerenciados
automaticamente. Os objetos 3D, juntamente com luzes, som e outros elementos, estão em um
universo virtual. Este universo é composto por um ou mais grafos de cena, que consistem
na organização dos objetos em uma estrutura do tipo árvore.
3.3.1. Grafo de Cena
Um grafo de cena é criado a partir de instâncias de classes Java 3D que definem som,
luz, orientação, geometria, localização e aparência visual dos objetos. Estes objetos
correspondem aos nodos (ou vértices), e os seus relacionamentos são identificados por arcos
(ou arestas) que representam dois tipos de relacionamentos:
31
• Referência, que simplesmente associa um objeto com o grafo de cena;

• Herança, onde um nodo do tipo grupo pode ter um ou mais filhos, mas apenas um pai,
e um nodo do tipo folha não pode ter filhos. “Em um grafo de cena, os nodos do tipo
grupo são identificados por círculos, e do tipo folha por triângulos”. Representação
gráfica do grafo de cena pode ser visto na figura 5. (MANSSOUR, 2003).
FIGURA 5: Exemplo de representação gráfica de um grafo de cena (BOUVIER, 2000).
De acordo com MANSSOUR (2003),
É recomendado que cada grafo de cena possua um único objeto

VirtualUniverse. Este objeto define um universo e possui pelo menos um
objeto Locale, que é responsável pela especificação do ponto de referência no
universo virtual e serve como raiz dos subgrafos de um grafo de cena.
A seguir passo a passo de forma simplificada para criação de um programa Java 3D:
1. Criar um objeto GraphicsConfiguration;

2. Criar um objeto Canvas3D;
3. Construir e compilar pelo menos um subgrafo de conteúdo;
4. Criar um objeto SimpleUniverse, que referencia o objeto Canvas3D criado
e automaticamente cria os objetos VirtualUniverse e Locale, e constrói o subgrafo
de visualização;
5. Inserir o subgrafo de conteúdo no universo virtual.
32
3.3.2. Principais Classes da API Java 3D
A API Java 3D fornece um grande número de classes específicas para criação,

posicionamento e visualização de objetos e ambientes gráficos. Nesse capítulo, serão
apresentadas algumas dessas principais classes.
3.3.2.1. SimpleUniverse
Essa classe é uma das classes mais importantes da API Java 3D, pois é responsável pela
configuração das informações mínimas criando um universo para execução de um programa
Java 3D. Fornece as funcionalidades necessárias para a maioria das aplicações. Quando um
SimpleUniverse é instanciado, cria-se automaticamente todos os objetos necessários para
o subgrafo de visualização, tais como Locale, ViewingPlatform e Viewer. A Listagem 1
mostra um exemplo de instanciação do objeto SimpleUniverse.
1. //declara e simpleUniverse
2. SimpleUniverse u = universo = new SimpleUniverse(canvas);
Instância do SimpleUniverse.
3.3.2.2. GraphicsConfiguration
A classe GraphicsConfiguration, faz parte do pacote AWT, e é responsável pela

descrição das características dos dispositivos gráficos (impressora ou monitor). Sua estrutura
varia de plataforma para plataforma, fornecendo, por exemplo, resolução desses dispositivos.
A Listagem 2 mostra um exemplo de instanciação do objeto GraphicsConfiguration.
1. //declara e obtém configuração

2. GraphicsConfiguration c =
SimpleUniverse.getPreferredConfiguration();
Instância do GraphicsConfiguration.
3.3.2.3. Canvas3D
Essa classe fornece um canvas, ou seja, uma área de desenho, onde é realizada
a visualização 3D. Nesse componente, é realizada a renderização de uma cena 3D, sempre
é instanciado conforme a configuração do dispositivo gráfico em uso. Além disso, ele pode
33
ser adicionado a um frame, applet, ou outro container da aplicação. A Listagem 3 mostra um

exemplo de instanciação do objeto Canvas3D.
1. //declara e cria canvas com a configuração do dispositivo

2. Canvas3D canvas = new Canvas3D(c);
Instância do Canvas3D.
3.3.2.4. BranchGroup
A classe BranchGroup, funciona como um ponteiro para a raiz de um subgrafo de cena.

Instâncias dessa classe são os únicos objetos que podem ser inseridos em um Locale. Um
subgrafo de cena que tem um BranchGroup como raiz pode ser compilado, inserido em um
universo virtual e desassociado deste universo virtual em tempo de execução. A Listagem 4
mostra um exemplo de instanciação do objeto BranchGroup.
1. //cria uma raiz e adiciona um subgrafo como filho

2. BranchGroup raiz = new BranchGroup();
3. raiz.addChild(transf);
Instância do BranchGroup.
3.3.2.5. TransformGroup e Transform3D
As transformações geométricas de escala, rotação e translação, são especificadas através de

uma instância da classe Transform3D, que representa uma matriz de 4x4 de números reais (float).
Objetos da classe TransformGroup permite realizar agrupamento de objetos, por sua

vez, especificam uma transformação através de um objeto Transform3D, que será aplicada a
todos os filhos. Deve-se considerar que os efeitos num grafo de cena são cumulativos, além
disso, a classe TransformGroup determina as formas de interação e animação desses objetos.
A Listagem 5 mostra um exemplo de instanciação do objeto Transform3D.
1. //cria transformação
2. Transforme3D t1 = new Transforme3D();
3. t1.rotY(Math.PI/4); // rotação de 45° em y
Instância do Transform3D.
34
3.3.3. Geometrias
Conforme MANSSOUR (2003), “em computação gráfica, modelos são utilizados para
representar entidades físicas ou abstratas e fenômenos no computador. Portanto, a etapa de
modelagem consiste em todo o processo de descrever um modelo, objeto ou cena, de forma
que se possa desenhá-lo.”
Geometrias é a forma de representação de modelos em Java 3D, e aparência é o que

define a propriedade material desse modelo, tais como cor, transparência e textura.
A API Java 3D possui diversas formas para criação de geometrias. Como dito
anteriormente, para que os objetos criados sejam visíveis, é necessárias basicamente duas
coisas, a aparência ou material, e uma fonte de luz cuja região de influência inclua os objetos.
Existem dois tipos de geometrias, as geometrias básicas, são formas pré-fabricadas,

podem ser criadas apenas com a instância das classes Box, Cylinder, Sphere e Cone
(ver Figura 6), mas são bem limitadas. E as geometrias complexas, com maior versatilidade,
mas maior trabalho para criação, implementadas pelas classes GeometryArray,
CompressedGeometry, Raster, Text3D (ver Figura 7).
FIGURA 6: Exemplos de geometrias simples (MANSSOUR, 2003).
FIGURA 7: Exemplos de geometrias complexas (MANSSOUR, 2003).

35
3.3.4. Aparências
As classes que determinam as primitivas gráficas não especificam cor, pois sua
aparência é determinada através do nodo Appearance. Se esse nodo não for instanciado,
a geometria é desenhada com a cor branca, sem a possibilidade de determinar suas
propriedades, tais como textura, transparência, cor, estilo de linha e material. Os métodos
principais para obtenção dessas propriedades são:
• void SetColoringAttributes(ColoringAttributes coloringAttributes);

• void SetLineAttributes(LineAttributes lineAttributes);
• void setTexture(Texture texture);
• void setMaterial(Material material);
• Material getMaterial();
FIGURA 8: Exemplo de objeto Java 3D reenderizado (BOUVIER, 2000).

36
4. AVALIAÇÃO E SELEÇÃO DE FUNCIONALIDADES MÍNIMAS
Nos capítulos anteriores foram mostrados as necessidades e princípios básicos para a

construção desse projeto. No capítulo 2, foi apresentado o funcionamento dos principais
movimentos mecânicos das leis da física. Já no capítulo 3, foi apresentado a API Java 3D para
desenvolvimento de ambientes 3D, comentando suas principais classes e funcionamento geral
dessa API. Neste capítulo, serão apresentadas as avaliações das funcionalidades mínimas para
o desenvolvimento do framework que auxilie os desenvolvedores a criarem suas próprias
animações usando a linguagem Java.
4.1. Avaliação
A linguagem Java, conta com diversos tipos de framework, cada um tem sua própria
importância e usabilidade. Sendo assim, para ter uma devida avaliação das funcionalidades
mínimas, foi interessante analisar dois pontos:
• Público alvo – Foi necessário avaliar quais seriam os usuários do framework.

Considerando que no ambiente educacional não existe uma ferramenta para esses
fins, decidiu-se que o framework seria voltado para os desenvolvedores iniciantes
ou aprendizes.
• Facilidade – Construção de ambientes e animações 3D escrevendo poucas linhas
de código, além de simular alguns movimentos de mecânica das leis da física.
Analisando esses pontos, criou-se um esboço das funcionalidades que o framework
suportaria. Na Figura 9 é possível ter uma visão geral do funcionamento:
FIGURA 9: Visão geral do funcionamento do framework.

37
4.1.1. Ambiente
A classe Ambiente é responsável por criar um ambiente virtual simples, instanciando

automaticamente vários objetos necessário para criação de um mundo virtual, essa classe
poupa o desenvolvedor de programar grande número de linhas de código, deixando a criação
do ambiente transparente. A seguir há uma lista dos principais objetos instanciados pela classe
Ambiente:
• GraphicsConfiguration;
• BranchGroup;
• SimpleUniverse;
• Canvas3D;
• AmbientLight (Luz de ambiente);
• DirectionalLight (Luz de capacete);
• Capacidade de interação;
• Chão (Base fixa para criação da animação).
Além dessas, a ela fornece alguns métodos para a personalização do ambiente virtual,
no capítulo seguinte será detalhado o uso de cada um dos métodos dessa classe. A seguir
alguns exemplos desses métodos:
• setPosicaoCamera(SimpleUniverse, float, float, float);

• setPlanoDeFundo(TransformGroup, Color3f);
• setLuzAmbiente();
• setLuzCapacete();
• getCanvas();
O objeto Ambiente instanciado pode ser obtido e anexado a um container Java
(JPainel, JFrame, etc...) para isso usa-se o método getCanvas(), que retorna o Canvas3D,
possibilitando a visualização dos objetos em cena.
38
4.1.2. Gatilho
A classe Gatilho consiste na união de alguns componentes swing, para a criação de

uma barra de ferramentas. Os objetos utilizados nessa classe são: um JToolBar, com três
botões do tipo JToggleButton. Cada um dos botões realiza uma ação na animação (iniciar,
pausar ou parar), e apenas um botão poderá estar pressionado por vez.
Quando o usuário achar necessário testar a aplicação 3D baseada no framework, será

necessário que ele interaja com o componente Gatilho, fornecendo uma das ações para que
a aplicação possa fluir.
O objeto Gatilho é bem simples e poderá ser adicionado à uma janela (JFrame). No
Anexo 2, há uma introdução para uso do visualizador J3DBrowser. Usando esse visualizador,
o usuário ficará isento de criar uma interface para visualização do ambiente virtual, pois ele
dá suporte para adicionar um Canvas3D, além de ser baseado em um JFrame, dando
a possibilidade de adicionar o objeto Gatilho à ele.
4.1.3. Temporizador
A classe Temporizador estende a classe Alpha da API Java 3D. Essa classe funciona
com um relógio fornecendo recursos de tempo usado para marcar os eventos de cada animação.
Além de servir como um relógio, a classe temporizar disponibiliza através de Alpha,

um conjunto de funcionalidades que poderá ser usado para criação de uma animação.
Um bom exemplo dessas funcionalidades são os modos de interação.
A classe Temporizador simplifica o uso da classe Alpha disponibilizando todos os

métodos. Caso haja necessidade de personalizar alguma funcionalidade do Temporizador,
o mesmo pode ser feito atrás dos métodos de Alpha.
O capítulo seguinte, explicará detalhadamente o uso da classe Temporizador.

39
4.1.4. Interpolador
Interpoladores são classes usadas na animação de objetos em um ambiente virtual.

A API Java 3D (SUN, 2006b) é dotada de alguns interpoladores que facilitam a criação dessas
animações.
Basicamente pode-se dizer que, os interpoladores são maneiras simplificadas de cria

interação em um ambiente virtual. O usuário informa alguns parâmetros como ponto inicial
e final, tempo de duração da animação, em alguns casos o eixo que ocorrerá a animação e o
objeto alvo que sofrerá a animação. Como resultado, o interpolador cria todos os pontos
intermediários aos informados pelo usuário e conduz a transformação do objeto alvo
consumindo o tempo até o ponto ou estado final.
Alguns dos interpoladores padrão do Java 3D são:
• ColorInterpolator – simula o efeito de camaleão, o objeto alvo troca de cor

conforme o tempo.
• PositionInterpolator – cria a animação de um objeto, o objeto corre de um ponto
ao outro, seguindo uma linha reta, em qualquer um dos eixo (x, y ou z) que podem
ser fornecidos pelo usuário.
• ScaleInterpolator – cria a animação de um objeto, o objeto aumenta e diminui seu
tamanho conforme o tempo, o tamanho máximo e mínimo podem ser fornecidos
pelo usuário.
• RotateInterpolator – cria a animação de um objeto, o objeto rotaciona em um dos
eixos (x, y ou z) que podem ser fornecidos pelo usuário, além disso pode ser
fornecido um raio para que a rotação seja percebida.
Na construção desse framework foi adicionado mais dois Interpolador,
o InterpoladorAceleracao, simula o movimento de um objeto acelerando constantemente,
e o InterpoladorMRU, simula o movimento de um objeto na velocidade constante.
40
4.1.5. Alvo
A classe Alvo é responsável por adicionar um objeto ao ambiente virtual. Essa classe
só instancia objetos do tipo 2D, e usa a técnica de Billboard, fornecida pela API Java 3D para
criar a ilusão de um modelo 3D.
A técnica de Billboard faz com que o objeto sempre seja visto de frente para a câmera,
como se o objeto estivesse olhando para o usuário. Sendo assim, o usuário poderá adicionar
qualquer tipo de imagem (jpg e gif) no ambiente, e terá a impressão de ser um objeto 3D.
Essa técnica é muito utilizada no desenvolvimento de jogos eletrônicos bons exemplos

desses objetos em jogos são árvores, nuvens, chuva, etc.
A classe carrega uma imagem indicada pelo usuário e cria-se uma textura a partir
dessa imagem. A textura é adicionada a uma forma geométrica de quatro pontos (retângulo).
Quando o retângulo é criado, o mesmo sofre uma transformação, através de cálculos

matemáticos, o mesmo é movimento para uma posição que pareça estar apoiado ao chão do
ambiente (ver capítulo 5.1.3).
Como o próprio nome diz, esse objeto será o alvo da animação, será ele que sofrerá
a interação dos interpoladores.
41
5. PROJETO E IMPLEMENTAÇÃO
O capítulo anterior descreve superficialmente as funcionalidades do que serão pelo

framework. Nesse capítulo, será descrito com maior detalhe o funcionamento das classes
encapsuladas pelo framework. Será possível conhecer cada método e sua aplicação em projeto
de computação gráfica, além de detalhar o funcionamento dos mesmos.
A Figura 9 ilustra a estrutura básica do framework. Pode-se ver que, para criar um
aplicativo usando o framework, o usuário no mínimo precisará instanciar um de cada objeto
da Figura 9.
No Anexo 1, pode-se encontrar alguns diagramas UML que especificam o projeto.
5.1. A Classe Ambiente
Como visto anteriormente, a classe Ambiente tem a responsabilidade de reproduzir um

ambiente virtual para que seja possível a criação da animação. A classe Ambiente possui
quatro construtores, oito métodos e uma classe de apoio, os quais dão a possibilidade
de personalização dessa classe. Os subcapítulos a seguir detalham o funcionamento da classe.
5.1.1 Construtores
A classe Ambiente possui quatro construtores:
5.1.1.1 Ambiente ( Component )
Construtor simples da classe Ambiente é responsável por construir um ambiente virtual

completo, com tudo necessário para instanciação dos objetos de cena. Recebe como
parâmetro um objeto Component, esse objeto é usado para criar texturas para os objetos
internos dessa classe. Esse construtor chama o construtor trivial passando para o objeto
Component e uma constante do tipo inteiro, chamado CAPAC_TOTAL que define o tipo de
capacidade interativa que o usuário terá com o ambiente (ver capítulo 5.1.1.2). Ele não define
qualquer atributo para a construção do objeto chao, tudo é passado como nulo e o construtor
instancia um objeto padrão.
42
5.1.1.2 Ambiente ( Component, int )
Construtor básico da classe Ambiente é responsável por construir um ambiente virtual

completo, com tudo necessário para instanciação dos objetos de cena. Recebe como
parâmetro o já conhecido objeto Component e possibilita também que o usuário defina qual o
tipo de interação que o eles terá no ambiente. A seguir são detalhadas todas as constantes que
poderão ser usadas para esse fim. Os tributos para construção com objeto Chao também são
passados como nulo, sendo assim, o construtor instancia um objeto padrão.
• CAPAC_ROTACAO_Y – define que o ambiente terá capacidade de rotacionar

seus filhos no eixo y, usando para isso o botão esquerdo do mouse.
• CAPAC_ROTACAO – define que o ambiente terá capacidade de rotacionar seus
filhos em todos os eixos (x, y, z), usando para isso o botão esquerdo do mouse.
• CAPAC_ZOOM – define que o ambiente terá capacidade de movimentar
(transladar) seus filhos no eixo z, dano a impressão zoom nos objetos. Usa-se
o botão central do mouse (é necessário que o mouse em questão tenha 3 botões
para que consiga ver essa interação).
• CAPAC_TRANSLATE – define que o ambiente terá capacidade de movimentar
(transladar) seus filhos nos eixos x e y, Usa-se o botão direto do mouse para
interagir com o ambiente.
• CAPAC_TECLADO – define que o ambiente terá capacidade de movimentar
(transladar) seus filhos nos eixos x, y e z. Usa-se as setas do teclado para interagir
com o ambiente.
• CAPAC_TOTAL – define que o ambiente terá capacidade total de interação. Essa
constante configura toda a capacidade de interação acima especificadas, com
exceção da capacidade de rotação livre (CAPAC_ROTACAO), sendo assim,
o ambiente só poderá ser rotacionado no eixo y.
5.1.1.3 Ambiente ( Component, int, float, float )
Construtor intermediário da classe Ambiente é responsável por construir um ambiente

virtual completo, com tudo necessário para instanciação dos objetos de cena. Recebe como
parâmetro o já conhecido objeto Component, possibilita que o usuário defina qual o tipo de
interação que ele terá no ambiente, além de permitir que o usuário defina qual a dimensão do
objeto chao através das variáveis floats, sendo que a primeira define largura e a segunda
43
profundidade. O último atributo que define a aparência do chão é passado como nulo para
o construtor trivial.
5.1.1.4 Ambiente ( Component, int, float, float, Appearance )
Construtor trivial da classe Ambiente é responsável por construir um ambiente virtual

completo, com tudo necessário para instanciação dos objetos de cena. Esse construtor chama
os métodos responsáveis pela criação do ambiente, todos os outros construtores passam essa
responsabilidade para ele. Ele recebe como parâmetro um objeto Component, um inteiro que
define o tipo de capacidade de interação com o usuário, duas variáveis floats que definem
a largura e profundidade do objeto chao e por fim, um objeto Appearance que define
a aparência do objeto chao. Os atributos que definem o objeto chão são detalhados no
subcapítulo 5.1.3.
O construtor trivial da classe Ambiente, instancia os objetos responsáveis pela

construção do ambiente virtual, boa parte desses objetos foram visto anteriormente no
capítulo 3, um ótimo exemplo do grafo de cena que representa o ambiente pode ser observado
na Figura 5. A seguir pode ser observada uma lista dos objetos instanciados pela classe
Ambiente:
• SimpleUniverse;
• GraphicsConfiguration;
• BranchGroup;
• Canvas3D;
• AmbientLight;
• DirectionalLight;
• Chao.
Três dos objetos listados não foram comentados até o momento. O objeto
AmbientLight cria uma fonte de luz para o ambiente, funciona como se uma lâmpada estivesse
acesa, iluminando o ambiente como todo. O objeto DirectionalLight cria uma fonte de luz
direcional, como se a câmera tive uma lanterna apontada na direção do objeto. As luzes são de
extrema importância para o ambiente, sem elas não é possível a visualização dos objetos
de cena. E por fim o objeto Chao, o mesmo é detalhado no capítulo 5.1.3.
44
5.1.2 Métodos
A classe Ambiente da suporte para algumas personalizações que poderão ser feitas pelo
usuário. Detalhe do uso de cada método poderá ser observado nos subcapítulos seguintes:
5.1.2.1 setPosicaoCamera ( float, float, float )
Método responsável por posicionar o ViewPlatform (plataforma de visualização

ou câmera, fornecido pelo objeto SimpleUniverse) na posição indicada pelo usuário. Quando
o objeto Ambiente é instanciado, automaticamente a posição da câmera é alterada, fazendo
com que o usuário tenha uma visão completa da base. Isso também acontece se o usuário
decidir alterar o tamanho padrão do objeto chao. Esse método recebe como parâmetros
os seguintes atributos:
• float x – Posição no eixo x;

• float y – Posição no eixo y;
• float z – Posição no eixo z.
5.1.2.2 setPlanoDeFundo ( Color3f )
Método responsável por alterar a cor de fundo do ambiente virtual. A cor de fundo
padrão para o ambiente é composta por 20% de vermelho, 0% de verde e 60% de azul,
criando um tom de azul escuro.
• Color3f bgColor – Objeto que dará cor ao plano de fundo do ambiente virtual.
5.1.2.3 setPlanoDeFundo ( String, Component )
Método altera o fundo do ambiente virtual adicionando uma imagem a ele. A cor de
fundo padrão para o objeto Ambiente é composta por 20% de vermelho, 0% de verde e 60%
de azul, criando um tom de azul escuro.
• String textura – Caminho físico de uma imagem, essa imagem será aplicada
ao fundo do ambiente virtual.
• Component componente – Componente Java qualquer, necessário para criação
da textura.
45
5.1.2.4 setLuzAmbiente ( )6
Método responsável por alterar o estado da luz do ambiente virtual. Os estados

possíveis para esse objeto são, aceso e apagado. A luz de ambiente é instanciada como aceso
de padrão.
O uso desse método é bem simples, a cada chamada desse método o estado da luz é
alterado. Se estiver aceso irá apagar, e se estiver apagado irá acender. A Figura 10 compara os
estados da luz de ambiente.
FIGURA 10: Comparação da luz de ambiente, do lado esquerdo luz acesa e do direito luz apagada.
5.1.2.5 setLuzCapacete ( )6
Esse método é bem similar ao funcionamento do método setLuzAmbiente ( ). Possui

os mesmos estados e sua utilização é idêntica a anterior.
A diferença da luz de capacete para a luz de ambiente é que a luz de capacete emite
um foco de luz direcional horizontal, é como se o visualizador tivesse uma lanterna apontada
para o objeto visualizado.
5.1.2.6. getCanvas ( )
Método retorna um objeto do tipo Canvas3D que deverá ser adicionado a um container.
6
A classe J3DBrowser possui dois botões que interagem com esses métodos. Leia mais sobre o J3DBrowser
no Anexo 2.
46
5.1.2.7. adicionar ( TransformGroup )
Método responsável por adicionar um objeto ao ambiente virtual. Recebe como

parâmetro um grupo de transformação, o qual será adiciona ao objeto SimpleUniverse.
5.1.2.8. getEsferaDeVisualizcaoPadrao ( )
Método retorna um objeto do tipo BoundingSphere, esse objeto deverá ser usado como
delimitador de visualização do ambiente virtual. É necessário o uso desse objeto quando
houver a necessidade de mexer com a câmera.
5.1.3 A Classe Chao
A classe chao é usada para criar um chão no ambiente virtual. Como o próprio nome
diz, serve de base para os objetos que serão adicionados ao ambiente.
Essa classe é usada internamente pela classe ambiente sendo assim o usuário não tem
como alterar propriedades desse objeto, após ele ter sido instanciado.
A classe instancia um objeto do tipo box de tamanho fixo. Ela possui apenas
um construtor e seus métodos públicos são apenas para informativos.
5.1.3.1. Chao (TransformGroup, float, float, Appearance)
Recebe como parâmetros um objeto TransformGroup, necessário para a adição do chão

no ambiente, duas variáveis do tipo float, necessárias para configurar da largura e
profundidade do objeto (caso não seja informado classe instancia um box 10m x 0,2m x 10m)
e um objeto Appearance, necessário para configurar uma aparência (caso não seja informado
a cor assumida será a padrão amarela).
47
5.1.3.4. getLaguraChao ( )
Método simples retorna a largura do chão.
5.1.3.5. getProfundidadeChao ( )
Método simples retorna a profundidade do chão.
5.2. A Classe Gatilho
A classe Gatilho como descrita anteriormente, é responsável por promover ao usuário

final uma interface simples para controlar uma determinada animação. Essa interface é dada
através de botões de estado, e cada um dos botões executa uma interação distinta
na animação.
Essa classe é um componente estendida da classe JToolBar, por tanto poderá ser usado
como um desses componentes, podendo ser adicionado à uma janela swing. A Figura 11
ilustra o componente Gatilho.
FIGURA 11: Componente Gatilho instanciado.

48
Na Figura 11 é fácil perceber as funcionalidades do componente, vê-se que o mesmo

funciona como um centro de controle da animação. O funcionamento de cada botão é simples
de identificar:
• Botão Iniciar – botão responsável por iniciar a animação esse botão gera o evento
que dispara o interpolador da animação.
• Botão Pausar – botão responsável por pausar a animação esse botão só funcionará
caso a animação esteja em andamento. Ao pressionar o botão iniciar novamente
a animação continuará de onde parou.
• Botão Parar – botão responsável por parar a animação, para utilizar esse botão,
é necessário que um dos outros botões esteja pressionado. Ao pressionar o botão
iniciar novamente a animação voltará ao inicio.
Nos subcapítulos seguintes serão detalhados os construtores e métodos dessa classe.
5.2.1. Construtor
A classe Gatilho possui apenas um construtor, portando seu uso é simples.
5.2.1.1. Gatilho ( )
Construtor padrão da classe Gatilho. Esse construtor defini e instancia os botões

responsáveis pelo controle da animação.
O construtor também desabilita as funções dos botões pausar e parar quando o objeto
Gatilho é criado, isso garante que os botões, só poderão ser pressionados após o inicio
da animação.
5.2.2. Métodos
A classe Gatilho não dispõe de nenhum método próprio, mais por ser estendida de
JToolBar, todos os métodos pertencentes ao pai é herdado pelo filho, sendo assim todos
as funcionalidades fornecidas pelos métodos do pai poderão ser usados em Gatilho.
49
5.3. A Classe Temporizador
A classe Temporizador é baseada na classe Alpha (BOUVIER, 2000). Ela é de extrema

importância para aplicações que implementam um interpolador de animação.
A classe Alpha possui funções relacionadas à animação de um objeto. Sua principal

função é transformar um intervalo de tempo em milesegundos, em um intervalo fechado entre
0.0 e 1.0 (I=[0.0, 1.0]).
Em seguida, I é mapeado em um espaço de valores pertinente ao objeto do grafo de

cenas que se deseja animar.
O objeto Alpha é representado pela Figura 12. Ele é composto por um gráfico de
animação que é dividida em algumas partes. Um ponto interessante neste objeto é que não há
a necessidade de usar todos as partes representadas no gráfico, o usuário poderá escolher
quais as partes que quer usar, personalizando assim o objeto Alpha para criar uma animação
mais condizente com o esperado pelo usuário.
FIGURA 12: Gráfico de representação do objeto Alpha (BOUVIER, 2006).
Um ciclo do objeto Alpha é dividido em quatro fases distintas, fase de crescimento,

fase de decrescimento, fase constantes em uma e fase constantes em zero. A definição desse
objeto pode ser composta por todas as quatro fases ou apenas as definidas pelo usuário.
50
Existe também a possibilidade de definir a quantidade de repetição do ciclo do objeto,

para isso é necessário informar um LoopCount. Por padrão esse contador é iniciado com
o valor -1, esse valor configura um contador infinito. Ele poderá ser iniciado também com um
valor inteiro positivo, esse valor referencia a quantidade de ciclos que a animação terá.
A seguir descrição da composição de cada uma das fases do gráfico Alpha:
• Crescimento:
a. incresingAlphaDuration – Representa a linha de crescimento do gráfico,
a animação é executada seguindo o sentido do intervalo de tempo.
b. incresingAlphaRampDuration – Representa a curva de suavização da linha de
crescimento do gráfico, causando o efeito de aceleração no inicio da linha
e efeito de desaceleração do fim da linha.
• Decrescimento :
1) incresingAlphaDuration – Representa a linha de decrescimento do gráfico,
a animação é executada seguindo o sentido inverso do intervalo de tempo.
2) incresingAlphaRampDuration – Representa a curva de suavização da linha de
decrescimento do gráfico, causando o efeito de aceleração no inicio da linha
e efeito de desaceleração do fim da linha.
• Constante em um:
a. AlphaAtOneDuration – Representa o tempo da animação quando a linha está
no topo do gráfico, ou quando seu valor é um.
• Constante em zero:
a. AlphaAtOneDuration – Representa o tempo da animação quando a linha está
na base do gráfico, ou quando seu valor for zero.
Conhecendo as fases do objeto Alpha, fica fácil criar curvas personalizadas que define
a real necessidade do usuário. Na Figura 13 são representados alguns tipos de objetos Alpha
personalizados.
51
FIGURA 13: Exemplos de objetos Alpha personalizados (BOUVIER, 2000).
Depois de introduzir os principais elementos da classe Alpha, torna-se possível

entender a classe temporador. A essa classe foi definida para facilitar a criação dos objetos
Alpha necessários para criação das animações.
Ela disponibiliza dois construtores adicionais, que facilitam a criação desses objetos.
A seguir é descrito o uso dos construtores e métodos dessa classe.
5.3.1. Construtores
A classe Temporizador, disponibiliza quatro construtores que facilitam a instanciação

do objeto Alpha. A seguir é possível analisar e entender o funcionamento de cada um desses
construtores.
5.3.1.1. Temporizador ( )
Construtor simples da classe Temporizador. Não há necessidade de ser parametrizada

para a instanciação do objeto, a classe assumi valores padrões para instanciação dos objetos.
Nesse construtor os atributos iniciados por padrão são:
• Número de repetição – recebe o valor inteiro de -1 (repetição infinita). Sendo

assim a animação não terá termino, podendo ser pausado ou parado apenas quando
usuário interagir com a animação através do Gatilho.
52
• Modo de interação – define em qual das faces a animação correrá. A constante

RAMPA_SUBIDA, faz com que os objetos sejam animados sempre partindo da
base do gráfico onde a fração correspondente ao tempo é 0 e segue até atingir
o topo do gráfico onde a fração do tempo é 1. Atingindo o topo a animação retorna
ao inicio e reinicia o processo.
• Tempo da Animação – recebe o valor long 1000 (milesegundos). Esse será
o tempo em que a animação ocorrerá.
Esses são os atributos instanciados nesse construtor, os demais atributos são iniciados
com o valor 0.
A instanciação desse objeto é simples, é dada pela Listagem 6. Na Figura 14 é possível

visualizar o gráfico de animação instanciado nesse construtor.
4. Temporizador tempo = new Temporizador();

Instancia do objeto Temporizador.
FIGURA 14: Exemplo de gráfico do construtor Temporizador (BOUVIER, 2000).
5.3.1.2. Temporizador ( int, int, long )
Construtor básico da classe Temporizador. Necessita-se que o usuário parametrize três

atributos vistos no construtor simples, número de repetição (numRepeticao), modo
de interação e tempo da animação.
• Número de repetição – como visto anteriormente esse atributo define o número

de repetições de uma animação. Nesse construtor é possível atribuir um número de
repetições diferente de -1.
• Modo de interação – nesse construtor o usuário poderá optar por um dos modos
de interação a seguir:
RAMPA_SUBIDA – explora a linha de crescimento do gráfico de animação.
RAMPA_DESCIDA – explora a linha de decrescimento do gráfico de animação.
53
RAMPA_SUBIDA_E_DESCIDA – explora a duas linhas (crescimento de

decrescimento) do gráfico de animação, iniciando na base do gráfico de
animação até o topo do mesmo e assim que chegar no topo inicia-se o caminho
inverso, do topo do gráfico de animação até a base do mesmo.
• Tempo da Animação – nesse construtor o tempo de animação é definido pelo
usuário, o tempo deve ser expresso em milesegundo, e será usado independente do
modo escolhido.
Os demais atributos desse construtor são iniciados por padrão com o valor 0.
A Listagem 7 mostra a instanciação desse construtor. Na Figura 15 é possível visualizar
exemplos de gráficos de animação instanciado nesse construtor.
1. Temporizador tempo = new Temporizador(

10, RAMPA_SUBIDA, 5000);

pelo construtor básico (BOUVIER, 2000).
5.3.1.2. Temporizador ( int, int, long, long, long )
Construtor intermediário da classe Temporizador. Recebe como parâmetros cinco

variáveis, três das quais foram apresentadas no construtor básico. Os outros são tempo em
zero e tempo em um. Detalhes desses dois últimos podem ser conhecidos a seguir:
• Tempo em zero – especifica o tempo que a animação permanecerá no ponto 0,0

(base) da linha do gráfico de animação.
• Tempo em um – especifica o tempo que a animação permanecerá no ponto 1,0
(topo) da linha do gráfico de animação.
54
Os atributos número de repetição, modo de interação e tempo da animação, funcionam

como os do construtor básico. Os demais atributos desse são iniciados por padrão com o valor
0. Na Listagem 8 nota-se exemplo da instanciação desse construtor. Esse construtor pode criar
gráficos de animação com os construtores mais básicos, além disso, na Figura 16 é possível
visualizar outros exemplos de gráficos de animação.
1. Temporizador tempo = new Temporizador(10, RAMPA_SUBIDA,

5000, 1000, 1000);

pelo construtor intermediário (BOUVIER, 2000).
5.3.1.3. Temporizador ( int, int, long, long, long,
long, long, long, long, long )
Construtor trivial da classe Temporizador. Recebe como parâmetros dez variáveis,

cinco deles já apresentadas no construtor intermediário. Esse construtor permite
a personalização completa do objeto Alpha. É necessário que o usuário passe valores para
todos os atributos. A seguir é detalhado o funcionamento de cada um desses atributos:
• numRepeticao – atributo responsável pela repetição da animação, os construtores

mais simples detalham melhor seu funcionamento.
• modoOperacao – atributo especifica quais dos modos de operação será usado
na animação. Os modos de operação são descritos no construtor básico.
• tempoGatilho – tempo de gatilho especifica o tempo que precede o início da
animação, esse tempo também é expresso em milesegundos. Essa fase precede
o inicio do ciclo de animação, portanto só acontecerá uma vez.
• tempoAposGatilho – tempo após gatilho define um tempo de delay entre o fim do
tempo de gatilho e o inicio da animação. Esse atributo é similar ao tempoGatilho,
portanto também é expresso em milesegundos, mas seu evento é percebido sempre
no inicio cada ciclo de animação.
55
• tempoRampaSubida – define o tempo da linha de subida, para o modo

de operação definido seja o RAMPA_SUBIDA ou RAMPA_SUBIDA_E_DESCIDA.
• suavizaSubida – define a suavização da linha de subida, também recebe o tempo
expresso em milesegundos. Esse atributo também depende do modo de operação
para ter seu evento percebido.
• tempoEmUm – detalhes desse atributo são descritos no construtor intermediário.
• tempoRampaDescida – define o tempo da linha de descida, sua funcionalidade
é restrita ao uso do modo de operação RAMPA_DESCIDA ou
RAMPA_SUBIDA_E_DESCIDA. Tem funcionamento similar ao atributo
tempoRampaSubida.
• suavizaDescida – define a suavização da linha de descida, seu funcionamento
é similar ao atributo suavizaSubida.
• tempoEmZero – e por fim, detalhes desse atributo são descritos no construtor
intermediário.
A representação do gráfico desse construtor pode ser dada por todos os anteriores, pois
ele é totalmente personalizável. A Figura 12 vista anteriormente demonstra todas as fases
e atributos configuráveis por esse construtor. A Listagem 9 mostra um exemplo da
instanciação desse construtor:
1. Temporizador tempo = new Temporizador( 10, RAMPA_SUBIDA,

500, 0, 5000, 1000, 0, 0, 0, 0 );
5.3.2. Métodos
A classe Temporizador possui três métodos muito importantes para interação do

usuário na animação. Esses métodos são privados, e é usado pela classe Gatilho. As funções
desses métodos são pausar, reiniciar e parar.
Além desses, Temporizador herda todos os métodos da sua classe pai Alpha. A seguir
pode ser visto um breve comentário das funcionalidades dos principais métodos. Maiores
informações podem ser encontrado em no site da SUN (2006b).
• finished ( ) – Testa se o objeto Alpha já terminou sua execução e retorna

verdadeiro ou falso (valor do tipo boolean).
56
• setAlphaAtOneDuration ( long ) – Método que configura o tempo de duração

da animação no topo do gráfico.
• setAlphaAtZeroDuration ( long ) – Método que configura o tempo de duração
da animação na base do gráfico.
• setDecreasingAlphaDuration ( long ) – Método que configura o tempo
de duração da animação durante a linha de descida.
• setDecreasingAlphaRampDuration ( long ) – Método que configura o tempo
de duração da animação durante a suavização da linha de descida
• setIncreasingAlphaDuration ( long ) – Método que configura o tempo de duração
da animação durante a linha de subida.
• setIncreasingAlphaRampDuration ( long ) – Método que configura o tempo
de duração da animação durante a suavização da linha de subida.
• setLoopCount ( int ) – Método que configura a quantidade de repetição
da animação.
• valeu ( ) – Método que retorna um valor float entre 0.0 e 1.0, esse valor refere-se
a conversão do tempo durante a animação.
5.4. As Classes Interpoladoras
As classes interpoladoras implementadas no framework são baseadas na classe

behavior (BOUVIER, 2000). O Java 3D implementa os conceitos de interação e animação na
classe behavior. Essa classe disponibiliza uma grande variedade de métodos que capacita
a aplicação a perceber e tratar vários tipos de eventos, entre eles eventos AWT.
“Os behaviors são nós do grafo de cena usados para especificar o ínício da execução
de uma determinada ação baseada na ocorrência se um conjunto de determinados eventos”.
(BICHO, 2002).
A classe behavior serve de base para todo e qualquer tipo de interação que os objetos
sofram no ambiente virtual. A Figura 17, mostra a hierarquia das classes que estendem suas
funcionalidades.
57
FIGURA 17: Diagrama de classe ilustrando as classes que especializam Behavior.
Além dos interpoladores padrão do Java 3D (ver capítulo 4.1.4), o framework

dá suporte para mais dois novos interpoladores:
• InterpoladorMRU;
• InterpoladorAceleracao.
Os mesmos são descritos nos capítulos seguintes.
5.4.1. InterpoladorMRU
A classe InterpoladorMRU implementa as funcionalidades necessárias para a animação

de um objeto baseando-se nos movimentos derivados do MRU (ver capítulo 4.1.1).
Através dessa classe é possível criar movimentos retilíneos uniforme. Todos os

cálculos matemáticos necessários para que a simulação de movimento ocorra são
implementados internamente em métodos privados da classe, deixando seu uso transparente
para o usuário.
A classe disponibiliza três construtores que tornam possível a criação de animações

baseadas nesse interpolador. Além disso, por estender behavior, ela implementa dois métodos
abstratos públicos, initialize() e processStimulus() (ver capitulo 5.4.1.2).
5.4.1.1. Construtores
A classe InterpoladorMRU disponibiliza três construtores para aplicação dessa

animação.
58
5.4.1.1.1. InterpoladorMRU ( TransformGroup )
Construtor simples da classe InterpoladorMRU. É necessário que o usuário forneça

um objeto TransformGroup com parâmetro. Os outros parâmetros necessários são fornecidos
automaticamente pela classe e são passados como parâmetro para o construtor trivial. Esse
construtor cria uma animação simples, fazendo com que um objeto se mova de um ponto
inicial até um ponto final com em uma velocidade constante.
Os pontos inicial e final são definidos pelas constantes PONTO_INICIAL (8.0)

e PONTO_FINAL (-8.0). O tempo da animação é dado por um objeto Alpha ou Temporizador
(ver capítulo 5.3).
5.4.1.1.2. InterpoladorMRU ( Alpha, TransformGroup )
Construtor básico da classe InterpoladorMRU recebe como parâmetro dois objetos:

objeto Alpha ou Temporizador e um objeto TransformGroup. Os outros atributos necessários
são fornecidos automaticamente pela classe e são passados como parâmetro para o construtor
trivial. Esse construtor cria uma animação simples, fazendo com que um objeto se mova de
um ponto inicial até um ponto final com uma velocidade constante, sendo que o tempo da
animação é definido pelo usuário através de Alpha. Da mesma forma que no construtor
anterior os pontos inicial e final são fornecidos pela classe.
5.4.1.1.3. InterpoladorMRU ( Alpha, TransformGroup, Point3f, Poinf3f )
Construtor trivial da classe InterpoladorMRU cria efetivamente uma animação

simples, onde o objeto move-se de um ponto inicial á um ponto final, como uma velocidade
constante. Todos os métodos internos responsáveis por produzir a animação são chamados por
esse construtor. Ele espera que seja passado por parâmetro quatro variáveis, um objeto Alpha
ou Temporizador, um objeto TransformGroup e dois pontos inicial e final.
59
5.4.1.2. Métodos
Os métodos públicos implementados pela classe InterpoladorMRU são, initialize()

e processStimulus(), detalhes desse métodos podem ser visto a seguir:
• initialize ( ) – Esse método é chamado apenas uma vez, e é responsável por iniciar
o behavior e estabelecer condições (WakeupConditions) para reação do behavior...
• processStimulus ( Enumeration ) – Esse método processa uma ação em resposta
a um evento. Ação processada por esse método é a translação do objeto pelo
ambiente virtual (SUN, 2006b).
5.4.2. InterpoladorAceleracao
A classe InterpoladorAceleracao implementa as funcionalidades necessárias para

animar um objeto baseados nos movimentos derivados do MRUV (ver capítulo 2.2.1).
Como o próprio nome diz, podem ser criados movimentos de aceleração de um objeto.
Bons exemplos de possíveis animações são: aceleração ou desaceleração de um veículo em
linha reta ou a queda livre de um objeto.
Todos os cálculos matemáticos necessários para que o movimento ocorra são

implementados internamente em métodos privados da classe, deixando seu uso transparente
para o usuário.
A classe disponibiliza quatro construtores para tornar possível a criação de animações

baseadas nesse interpolador. Além disso, ela estende a classe behavior, ela implementas dois
métodos abstratos públicos, initialize() e processStimulus() (ver capitulo 5.4.2.2).
5.4.2.1. Construtores
A classe InterpoladorAceleracao disponibiliza quatro construtores para aplicação

dessa animação.
60
5.4.2.1.1. InterpoladorAceleracao ( TransformGroup )
Construtor simples da classe InterpoladorAleceracao. Necessita-se que o

usuário forneça um objeto TransformGroup com parâmetro. Todos os outros parâmetros
necessários são fornecidos automaticamente pela classe e são passados como parâmetro para
O construtor trivial recebe cinco variáveis, um objeto simples do tipo Temporizador

instanciado com os valores padrão (ver capítulo 5.3.1.1), um objeto do tipo TransformGroup,
um variável de aceleração, nesse caso a variável recebe o valor da constante
ACELERACAO_GRAVITACIONAL (9,8) e dois pontos, inicial e final.
5.4.2.1.2. InterpoladorAceleracao ( Alpha, TransformGroup )
Construtor básico da classe InterpoladorAleceracao recebe como parâmetro dois

objetos: objeto Alpha ou Temporizador e um objeto TransformGroup. Os outros atributos
necessários são fornecidos automaticamente pela classe e são passados como parâmetro para
O construtor trivial além dos objetos fornecidos pelo usuário recebe a aceleração
e dois pontos, inicial e final.
5.4.2.1.3. InterpoladorAceleracao ( Alpha, TransformGroup, double )
Construtor intermediário da classe InterpoladorAleceracao recebe como parâmetro os

objetos: Alpha ou Temporizador, um objeto TransformGroup e uma variável do tipo double
contendo o valor da aceleração do objeto. Os outros atributos necessários são fornecidos
automaticamente pela classe, sendo passados como parâmetro para o construtor trivial.
O construtor trivial recebe cinco variáveis, três delas fornecidas pelo usuário,
aceleração e dois pontos, inicial e final.
61
5.4.2.1.4. InterpoladorAceleracao ( Alpha, TransformGroup,
double, Point3f, Poinf3f )
Construtor trivial da classe InterpoladorAleceracao recebe cinco parâmetros, os quais

podem ser definidas pelo usuário. Todos os outros construtores vistos anteriormente
o chamam para instanciar a classe.
Os parâmetros esperados são: um objeto Alpha ou Temporizador, um objeto

TransformGroup, uma aceleração (double) e dois pontos inicia e final.
5.4.2.2. Métodos
Os métodos públicos implementados pela classe InterpoladorAceleracao são,

initialize() e processStimulus(), os mesmos utilizados no InterpoladorMRU, eles poderão ser
visto com maior detalhes no capítulo 5.4.1.2.
5.5. A Classe Alvo
A classe Alvo é muito importante para o framework, ela é o objeto central para o
desenvolvimento de aplicações baseadas no framework, pois todos interpoladores necessitam
de um objeto para poder ser iniciado.
O objetivo dessa classe é possibilitar que o usuário crie uma animação usando objetos
complexos de serem modelados, por exemplo: carro, avião ou bola de futebol. Essa classe usa
dos recursos da classe Billboard (BOUVIER, 2000), pode carregar qualquer imagem
bidimensional (jpg, gif), ao ambiente virtual dando a impressão de ser um modelo
tridimensional para quem vê esse objeto.
Como descrito acima, a técnica de Billboards é utilizada para simular a geometria de

alguma figura bidimensional em três dimensões. É bastante utilizada em jogos, porque simula
uma geometria complexa utilizando apenas um polígono (retângulo). A Figura 18 exemplifica
essa técnica.
62
FIGURA 18: Exemplo de Billboard (VORTEX, 2006).
Árvores, nuvens, chuva, neves, são bons exemplos de aplicação dessa técnica em um jogo
eletrônico. Uma árvore qualquer possui uma geometria complexa. Em jogos eletrônicos,
normalmente o jogador não está interessado em apreciar todos os detalhes de uma árvore. Utiliza-
se então um retângulo e uma textura para simular a geometria da árvore (ver Figura 18). A textura
contém uma projeção bidimensional da árvore. E ela é aplicado ao quadrilátero, que é exibido de
forma a sempre estar de frente para o observador. Desta forma o observador é iludido a acreditar
que está visualizando um modelo tridimensional complexo. (VALENTE, 2006).
Como visto, o Java 3D dá suporte a uso dessa técnica. A classe Alvo por sua vez,
além de facilitar o uso da classe Billboard, facilita também a criação de outros objetos que são
usados em conjunto com o Billboard, deixando transparente a criação do polígono (retângulo)
que servirá de base para a textura, a própria textura que representará o objeto a ser animado,
o posicionamento inicial do objeto no ambiente e atributos necessário para instanciação
do objeto Alvo.
A classe Alvo conta com dois construtores e disponibiliza alguns métodos para
personalização do mesmo como reposição do objeto e adequação da escala do objeto.
Nos capítulos seguintes é demonstrado como usar esses construtores e métodos.
63
5.5.1. Construtor
A classe Alvo disponibiliza dois construtores para instanciação de um objeto

bidimensional, com as características de um modelo tridimensional como citado
anteriormente.
5.5.1.1 Alvo ( Component, TransformGroup )
Construtor simples da classe Alvo recebe como parâmetros duas variáveis de extrema
importância para instanciação desse objeto, um objeto Component e um TransformGroup,
a seguir maiores informações sobre esse parâmetros:
• Component – objeto necessário para carregar uma imagem bidimensional, esse

objeto será usado quando a imagem estiver para ser instanciada. A classe
TextureLoader (SUN, 2006b) necessita que seja parametrizado um Component
qualquer para que a imagem possa ser carregada.
• TransformGroup – esse objeto é uma referência parar o grupo de transformação
geral do ambiente virtual, é usado para que o objeto Alvo possa ser adicionado ao
objeto Ambiente (ver capítulo 5.1). Esse objeto pode ser obtido através do método
getGrupoAmbiente( ) da classe Ambiente.
5.5.1.2. Alvo ( Component, TransformGroup, String)
Construtor trivial da classe Alvo recebe como parâmetros três variáveis, um

Component, um objeto TransformGroup e um objeto String. A seguir maiores informações
sobre esses parâmetros:
• Component – maiores informações sobre a importância desse objeto pode ser

obtida no capítulo 5.5.1.1.
• TransformGroup – maiores informações sobre a importância desse objeto pode
ser obtida no capítulo 5.5.1.1.
• String – esse objeto referencia a URL (endereço, caminho físico) da imagem
a ser carregada.
64
5.5.2. Métodos
A classe Alvo disponibiliza alguns métodos para personalização das características

padrão implementadas pela classe.
5.5.2.1. setImagemAlvo ( String )
Método setImagemAlvo carrega uma imagem bidimensional que será usado como
textura de um polígono. Esse polígono tem a forma de um retângulo e servirá de base para
adição dessa textura.
O método setImagemAlvo, aciona um método interno da classe Alvo que obtém o

alguns atributos da imagem carregada, como largura e altura da imagem. Esses atributos são
usados para criar um polígono no tamanho exato da imagem carregada. Além disso, um
objeto do tipo Billboard é instanciado, e a ele é adicionado o polígono.
Tudo isso é transparente para o usuário. Ele não precisa saber nada do funcionamento
prático, o importante é saber que ele precisa passar a String contendo o caminho para uma
determinada imagem, o restante é tudo feito internamente pela classe.
Também é importante saber que não há necessidade de uso desse método se

o construtor usado pelo usuário for o construtor trivial (ver capítulo 5.5.1.2), pois o mesmo já
o chama na instanciação.
5.5.2.2. setPosicaoImagem ( float, float, float )
Método setPosicaoImagem tem a função de reposicionar o objeto Alvo no ambiente

virtual. Sua interface é bem simples e espera que seja fornecido como parâmetro uma
coordenada (x, y, z) representadas pelas variáveis floats.
65
5.5.2.3. setPosicaoImagem ( Point3f )
Método setPosicaoImagem tem a função de reposicionar o objeto Alvo no ambiente

virtual. Sua interface é bem simples e espera que seja fornecida como parâmetro uma
coordenada (x, y, z) representadas pelo objeto Point3f.
5.5.2.4. setEscalaImagem ( Double, Double )
Método setPosicaoImagem tem a função de reescalonar (aumentar ou diminuir

o tamanho) o objeto Alvo. Sua interface é bem simples e espera que seja fornecida como
parâmetro duas variáveis do tipo double, a primeira referencia a largura e a segunda referencia
a altura do objeto.
66
6. RESULTADOS OBTIDOS
Foi desenvolvido um protótipo de framework como a intenção de facilitar o

desenvolvimentos de animações tridimensionais usando alguns movimentos da mecânica
clássica. Entre os movimentos estudados nesse trabalho, foram escolhidos dois deles, os quais
foram implementados, e poderá ser usando transparentemente pelo usuário, sem que o mesmo
tenha a necessidade de conhecer fórmulas, ou ser especialista em desenvolvimento de
aplicações tridimensionais.
Os movimentos considerados nesse trabalho são: MRU e MRUV, sendo que o

primeiro poderá ser aplicado através da classe InterpoladorMRU, o qual produz uma
animações simples, onde o objeto alvo movimenta-se de um ponto ao outro com uma
velocidade constante, e o segundo poderá ser aplicado através da classe
InterpoladorAcelecacao que produz animações mais complexas, onde o objeto alvo
movimenta-se de um ponto ao outro com aceleração constante, bons exemplos são: veículos
com aceleração constante ou a queda livre de uma bola (ver capítulo 5.4).
Para interagir com os interpoladores é necessário usar a classe Alpha do Java 3D, mais
para facilitar essa tarefa, foi implementando a classe Temporizador que encapsula a classe
Alpha, diminuindo a complexidade da mesma. Além disso, essa classe implementa funções
de contagem de tempo exclusivo para os interpoladores InterpoladorMRU
e InterpooladorAceleracao. Dois construtores diferentes da classe genérica também foram
implementados, dando mais versatilidade ao usuário (ver capítulo 5.3).
Foi implementado também um componente simples baseando no componente swing

JToolBar. Esse componente poderá ser acionado a qualquer componente do tipo janela, da
biblioteca swing (ver Anexo 2). Esse componente dispõe de um interface a qual o usuário
poderá interagir como a animação, podendo iniciar, pausar ou parar o ciclo dessa animação
(ver capítulo 5.2).
Além disso, o framework fornece um ambiente virtual completo com tudo o

necessário para se criar uma aplicação, como por exemplo: universo, canvas, gerenciamento
da câmera, grafo de conteúdo para adição de objetos, capacidades de interação através dos
periféricos de entrada (mouse e teclado), gerenciamento plano de fundo e um chão (base
horizontal) onde todos os objetos adicionados serão apoiados (ver capítulo 5.1).
67
O framework também fornece facilidades para criação de objetos complexos no

ambiente virtual, importando imagens bidimensionais e usando a técnica de Billboard para
parecer que esse objeto é um objeto tridimensional (ver capítulo 5.5).
Esse framework por ser implementado em Java não tem dependência com nenhuma
plataforma de hardware ou software. É necessário apenas que a máquina possua JRE
(SUN, 2006a) e o Java 3D (SUN, 2006a) instalado no sistema.
Esse trabalho mostra que a linguagem Java junto com a API Java 3D pode ser usada
também na criação de jogos eletrônicos. Foi visto anteriormente que as mesmas implementam
funcionalidades para animação de objetos, interação como o usuário final (jogadores), adição
de objetos bidimensionais, entre outros recursos, os quais podem ser visto na
API Specification do Java 3D (SUN, 2006b).
6.1. Comparativo de código entre do framework e da API Java 3D
Nesse capítulo será mostrado um comparativo entre os códigos de uma aplicação

usando como base o framework e a mesma aplicação usando apenas o API Java 3D.
A intenção é provar a eficiência prática do framework sobre a API Java 3D em relação
a construção de aplicações simples e aplicações que usam animações lineares.
6.1.1. Aplicação usando API Java 3D
De acordo com MANSSOUR (2003), para se criar uma aplicação simples usando a
API Java 3D é necessário seguir alguns passos. A seguir há um passo a passo simplificado
para criação de uma aplicação Java 3D:
1. Criar um objeto GraphicsConfiguration;

2. Criar um objeto Canvas3D;
3. Construir e compilar pelo menos um subgrafo de conteúdo;
4. Criar um objeto SimpleUniverse, que referencia o objeto Canvas3D criado. Esse
objeto cria automaticamente os objetos VirtualUniverse e Locale, e constrói
o subgrafo de visualização;
5. Inserir o subgrafo de conteúdo no universo virtual;
68
Para criar uma aplicação mais interessante, adiciona-se ao passo-a-passo

mais alguns item:
6. Criar objetos alvo ou geometrias e adicioná-lo ao subgrafo de conteúdo;

7. Dar aparência aos objetos alvo ou geometria;
8. Configurar posicionamento, escala e rotação dos objetos;
9. Criar algum dos tipos de iluminação que possibilita a visualização da cena;
10.Criar um interpolador para animação dos objetos.
Na Listagem 10 é possível observar um exemplo dessa aplicação usando apenas a API
Java 3D. É importante observar a quantidade de linhas de código necessária para criar uma
aplicação simples usando de alguns recursos interessantes, como transformação e animação
de objetos.
1. import com.sun.j3d.utils.geometry.Box;
2. import com.sun.j3d.utils.geometry.ColorCube;
3. import com.sun.j3d.utils.geometry.Sphere;
4. import com.sun.j3d.utils.universe.PlatformGeometry;
5. import com.sun.j3d.utils.universe.SimpleUniverse;
6. import Java.awt.BorderLayout;
7. import Java.awt.GraphicsConfiguration;
8. import Java.awt.GridLayout;
9. import Javax.media.j3d.Alpha;
10.import Javax.media.j3d.AmbientLight;
11.import Javax.media.j3d.Appearance;
12.import Javax.media.j3d.Background;
13.import Javax.media.j3d.BoundingSphere;
14.import Javax.media.j3d.BranchGroup;
15.import Javax.media.j3d.Canvas3D;
16.import Javax.media.j3d.DirectionalLight;
17.import Javax.media.j3d.Light;
18.import Javax.media.j3d.Material;
19.import Javax.media.j3d.RotationInterpolator;
20.import Javax.media.j3d.Transform3D;
21.import Javax.media.j3d.TransformGroup;
22.import Javax.swing.JFrame;
23.import Javax.swing.JPanel;
24.import Javax.vecmath.Color3f;
25.import Javax.vecmath.Point3d;
26.import Javax.vecmath.Vector3f;
27.
28.public class Exemplo1 extends JFrame{
29.
30. private JPanel pCanvas;
31.
32. public Exemplo1() {
33. InicializaJanela();
34. InicializaJ3D();
35. }
36.
37. private void InicializaJanela(){
38. // configurando janela do Browser
39. setSize(800,600);
69
40. setLayout(new BorderLayout());

41. setTitle("Aplicação Java 3D – Exemplo 1");
42. setDefaultCloseOperation(
Javax.swing.WindowConstants.EXIT_ON_CLOSE);
43.
44. JPanel pGeral = new JPanel();
45. add("South", pGeral);
46.
47. // adicionando o canvas 3D ao painel central
48. pCanvas = new JPanel();
49. pCanvas.setLayout(new GridLayout(1,1));
50. add("Center",pCanvas);
51.
52. }
53.
54. private void InicializaJ3D(){
55. // declara e obtém configuração gráfica p/ Canvas3D
56. GraphicsConfiguration config =
SimpleUniverse.getPreferredConfiguration();
57.
58. // cria Canvas3D com configuração obtida
59. Canvas3D canvas = new Canvas3D(config, false);
60. pCanvas.add(canvas);
61.
62. // cria Universo Simples associado ao canvas criado
63. SimpleUniverse universo =
new SimpleUniverse(canvas);
64. universo.getViewingPlatform().
setNominalViewingTransform();
65.
66. // cria ramo de conteúdo
67. BranchGroup conteudo = criarRamoConteudo(universo);
68.
69. // adiciona ramo de conteúdo ao universo
70. universo.addBranchGraph(conteudo);
71.
72. }
73.
74. private BranchGroup criarRamoConteudo(
75. SimpleUniverse universo){
76. // cria ramo adiciona-se o conteúdo da cena 3D
77. BranchGroup ramo = new BranchGroup();
78.
79. // cria grupo considerando transformação
80. TransformGroup grupo = new TransformGroup();
81.
82. // ajusta capacidades modificáveis do grupo
83. grupo.setCapability(
TransformGroup.ALLOW_TRANSFORM_WRITE);
84.
85. // adiciona grupo ao ramo de conteúdo
86. ramo.addChild(grupo);
87.
88. // delitimador de visualização
89. BoundingSphere bounds = new BoundingSphere(
new Point3d(0.0,0.0,0.0), 100.0);
90.
91. // seta plano de fundo do ambiente
92. Background bg = new Background(
new Color3f(0.2f, 0.0f, 0.6f));
93. bg.setApplicationBounds(bounds);
70
94. grupo.addChild(bg);
95.
96. // Cria fonte de luz ambiente
97. AmbientLight luzAmb = new AmbientLight(
new Color3f(1.0f,1.0f,1.0f));
98. // cria e ajusta esfera de influência
99. luzAmb.setInfluencingBounds(bounds);
100. // indica estados modificáveis
101. luzAmb.setCapability(Light.ALLOW_STATE_WRITE);
102. luzAmb.setCapability(Light.ALLOW_STATE_READ);
103. //adiciona ao conteúdo
104. ramo.addChild(luzAmb);
105.
106. // cria fonte de luz direcional
107. DirectionalLight luzCap =
new DirectionalLight();
108. // ajusta cor e direção
109. luzCap.setColor(new Color3f(1.0f,1.0f,1.0f));
110. luzCap.setDirection(new Vector3f(
0.0f, 0.0f, -1.0f));
111. // cria e ajusta esfera de influência
112. BoundingSphere tudo = new BoundingSphere(
new Point3d(0, 0, 0), 100000.0);
113. luzCap.setInfluencingBounds(tudo);
114. // indica estados modificáveis
115. luzCap.setCapability(Light.ALLOW_STATE_WRITE);
116. luzCap.setCapability(Light.ALLOW_STATE_READ);
117. // monta luz na plataforma c/luz de capacete
118. PlatformGeometry pg = new PlatformGeometry();
119. pg.addChild(luzCap);
120. universo.getViewingPlatform().
setPlatformGeometry(pg);
121.
122. /********************************************/
123. // cria materia - aparência para chão
124. Appearance appChao = new Appearance();
125. Material matChao = new Material(
126. new Color3f(1.0f,1.0f,0.0f), //amarelo
127. new Color3f(0.0f,0.0f,0.0f), //preto
128. new Color3f(1.0f,1.0f,0.0f), //amarelo
129. new Color3f(1.0f,1.0f,1.0f), //branco
130. 100f);
131. appChao.setMaterial(matChao);
132.
133. //criar chão
134. Box chao = new Box(10.0f,0.2f,10.0f, appChao);
135.
136. //transformação chão
137. Transform3D tChao = new Transform3D();
138. tChao.setTranslation(new Vector3f(
0.0f,-2.2f, -15.0f));
139. TransformGroup gChao =
new TransformGroup(tChao);
140. gChao.addChild(chao);
141. grupo.addChild(gChao);
142.
143. /********************************************/
144. // cria materia - aparência para bola
145. Appearance appBola = new Appearance();
146. Material matBola = new Material(
147. new Color3f(1.0f,0.0f,0.0f), //vermelho
71
148. new Color3f(0.0f,0.0f,0.0f), //preto

149. new Color3f(1.0f,0.0f,0.0f), //vermelho
150. new Color3f(1.0f,1.0f,1.0f), //branco
151. 100f);
152. appBola.setMaterial(matBola);
153.
154. // cria um objeto
155. Sphere bola = new Sphere(0.5f, appBola);
156.
157. //transformação chão
158. Transform3D tBola = new Transform3D();
159. tBola.setTranslation(new Vector3f(
0.0f,-1.5f, -10.0f));
160. TransformGroup gBola = new TransformGroup(tBola);
161. gBola.addChild(bola);
162. grupo.addChild(gBola);
163.
164. /********************************************/
165. //criar Caixa
166. ColorCube caixa = new ColorCube();
167.
168. //grupo geral da caixa
169. Transform3D tCaixa = new Transform3D();
170. tCaixa.setTranslation(new Vector3f(
171. 0.0f,0.0f, -10.0f));
172. TransformGroup cGeral = new TransformGroup(tCaixa);
173.
174. //animação (rotação)
175. Transform3D eixo = new Transform3D();
176. TransformGroup gCaixa = new TransformGroup(eixo);
177. gCaixa.setCapability(
178. gCaixa.addChild(caixa);
179. //define animação
180. Alpha Temporizador = new Alpha(-1, 4000);
181. RotationInterpolator rotacionar = new
RotationInterpolator(Temporizador, gCaixa,
eixo, 0.0f, (float) Math.PI*2.0f);
182. rotacionar.setSchedulingBounds(bounds);
183.
184. //adiciona caixa e animação ao grupo geral da caixa
185. cGeral.addChild(gCaixa);
186. cGeral.addChild(rotacionar);
187.
188. //adiciona grupo geral da caixa ao ramo
189. ramo.addChild(cGeral);
190.
191. ramo.compile();
192.
193. return ramo;
194. }
195.
196. public static void main(String[] args) {
197. JFrame tela = new Exemplo1();
198. tela.setVisible(true);
199. }}
Exemplo de aplicação usando apenas a API Java 3D.
72
O resultado da aplicação descrita na Listagem 10, pode-se ver na Figura 19 (o código

fonte e executável do exemplo 1 estão no CD anexo).
FIGURA 19: Resultado da Listagem 10.
6.1.2. Aplicação usando o framework
Ao usar o framework, o usuário estará aumentando sua produtividade, pois terá que
escreverá menos linhas para criar aplicações simples. O usuário também não precisará saber
como o framework trabalha, pois ele encapsula um grande número de funcionalidades da API
Java 3D, seu uso é transparente para o usuário. Além disso, o usuário iniciante torna-se
empolgado a conhecer melhor a computação gráfica, pois a base para o desenvolvimento de
aplicações 3D é facilmente tratada pelo framework.
Como visto anteriormente o framework é composto de cinco classes (ver Figura 9), elas
são muito importantes no desenvolvimento de aplicações com base no. A seguir
é apresentando um passo a passo simples para criação de uma aplicação de exemplo.
Na Listagem 11 pode ser observado um exemplo da aplicação anterior implementado agora
usando o framework.
73
A seguir, passo a passo para criação de um aplicação com o integrando o framework

com a API Java 3D:
1. Criar um objeto Ambiente;

2. Criar um objeto Alvo ou uma geometria e adicioná-lo ao Ambiente;
3. Criar um objeto Temporizador ou Alpha para controle da animação;
4. Criar um objeto interpolador, referenciando o objeto Temporizador ou Alpha
ao objeto Alvo ou geometria.
1. import com.sun.j3d.utils.geometry.ColorCube;
2. import com.sun.j3d.utils.geometry.Sphere;
3. import Javax.media.j3d.RotationInterpolator;
4. import Javax.media.j3d.Transform3D;
5. import Javax.media.j3d.TransformGroup;
6. import Javax.media.j3d.Alpha;
7. import Javax.media.j3d.BoundingSphere;
8. import Javax.vecmath.Vector3f;
9. import Javax.vecmath.Point3d;
10.
11.public class Exemplo2{
12.
13. public static void main(String[] args) {
14. //cria janela para visualização
15. J3DBrowser tela = new J3DBrowser();
16. tela.setTitulo("Exemplo 2");
17.
18. //cria ambiente 3D
19. Ambiente amb = new Ambiente(tela);
20.
21. /********************************************/
22. //cria bola
23. Sphere bola = new Sphere(0.5f,
Cores.setAparencia(Cores.VERMELHO));
24.
25. //transformação
26. Transform3D tBola = new Transform3D();
27. tBola.setTranslation(new Vector3f(
0.0f,-1.5f, -10.0f));
28. TransformGroup gBola = new TransformGroup(tBola);
29. gBola.addChild(bola);
30.
31. //adiciona bola ao Ambiente
32. amb.adicionar(gBola);
33.
34. /********************************************/
35. //criar Caixa
36. ColorCube caixa = new ColorCube();
37.
38. //grupo geral da caixa
39. Transform3D tCaixa = new Transform3D();
40. tCaixa.setTranslation(new Vector3f(
41. 0.0f,0.0f, -10.0f));
42. TransformGroup cGeral = new TransformGroup(tCaixa);
43.
44. //animação (rotação)
45. Transform3D eixo = new Transform3D();
74
46. TransformGroup gCaixa = new TransformGroup(eixo);

47. gCaixa.setCapability(
48. gCaixa.addChild(caixa);
49.
50. //define animação
51. Alpha Temporizador = new Alpha(-1, 4000);
52. RotationInterpolator rotacionar = new
RotationInterpolator(Temporizador, gCaixa,
eixo, 0.0f, (float) Math.PI*2.0f);
53. BoundingSphere bounds = new BoundingSphere(
new Point3d(0.0,0.0,0.0), 100.0);
54. rotacionar.setSchedulingBounds(bounds);
55.
56. //adiciona caixa e animação ao grupo geral da caixa
57. cGeral.addChild(gCaixa);
58. cGeral.addChild(rotacionar);
59.
60. //adiciona caixa ao Ambiente
61. amb.adicionar(cGeral);
62. /********************************************/
63.
64. //adiciona ambiente a janela
65. tela.adicionarAmbiente(amb);
66.
67. //mostra janela
68. tela.setVisible(true);
69. }
70.}
Exemplo de aplicação usando o framework.
O resultado da aplicação descrita na Listagem 11, pode-se ver na Figura 20 (o código

fonte e executável do exemplo 2 podem ser visto no CD anexo).
FIGURA 20: Resultado da Listagem 11.

75
Nota-se que a quantidade de passos para construção da Listagem 10 é menor que da

Listagem 11. Além disso, a otimização do código é visível, observando a quantidade de linhas
gastas para criar a Listagem 10, que teve como resultado a Figura 19 e a Listagem 11, que
teve como resultado a Figura 20. Na Listagem 11 tem-se uma economia de aproximadamente
65% de linha de código em relação a Listagem 10.
Observa-se também que a Figura 19 encontra-se um pouco mais próxima a câmera

(ViewPlatform), dando a impressão dos objetos serem maior que a Figura 20. Isso acontece,
pois a classe Ambiente (ver capítulo 5.1), dispõe de posicionamento automático da câmera na
cena. Essa variação dá-se através do tamanho do objeto chão (ver capítulo 5.1.3).
Entre as linhas 37-52 da Listagem 10 é definida uma janela à qual o ambiente e os

objetos 3D serão adicionados. Já na Listagem 11, essas linhas são substituídas pela
a instanciação do objeto J3DBrowser nas linhas 15-16, sendo que, o uso desse objeto adiciona
duas formas de interação com o usuário, pois possui dois botões para controle das luz
do ambiente.
Além disso, as linhas 54-120 na Listagem 10, são iniciados as funcionalidades básicas
para que possa criar um ambiente virtual. Nessas linhas, são instanciados objetos como
simpleUniverse, Background , BoudingSphere, BranchGroup, entre outros recursos (ver
capítulo 5). Já na Listagem 11 todas essas linhas são substituídas por apenas a linha 19, a qual
instancia o objeto Ambiente.
6.2. Documentação do framework
O framework foi totalmente documentando usando a ferramenta javadoc7, essa

ferramenta fornece algumas facilidades, e é hoje o padrão usado para documentação de
aplicações Java. A ferramenta fornece um conjunto de regras e tags as quais são adicionadas
ao código fonte das aplicações em forma de comentários ao texto. Por fim, através de uma
ferramenta qualquer de geração de documentos javadoc, (IDEs de desenvolvimento como
NetBeans e Eclipse possuem internamente um plugin para geração dessa documentação)
os comentários do código fonte é convertido para um documento HTML.
7
“javadoc - Ferramenta utilizada para criar arquivos HTML que documentam o código Java. Essa
ferramenta é usada pela Sun para criar a documentação da Java API” (DEITEL, 2005).
76
Conforme DEITEL & DEITEL (2005), “os comentários de documentação são os únicos
reconhecidos pelo javadoc. Comentários de documentação iniciam com /** e terminam com
*/. Os comentários de documentação podem abranger múltiplas linhas”. A Listagem 12
mostra um exemplo de um comentário simples de documentação:
1. /** Classifica um array de inteiros

utilizando o algoritmo MySort */
Como visto anteriormente, o javadoc possui também algumas tags usadas para auxiliar
a criar a documentação, essas tags dão algum tipo de destaque na documentação. Essa tags
não são tags HTML, elas podem ser adicionadas a qualquer comentário e sempre iniciam com
o símbolo @. “Os tags @see e @author são usados para especificar um See Also: e uma nota
Author:, respectivamente na documentação em HTML” (DEITEL, 2005). Além disso,
é possível adicionar tags HTML ao comentário, fazendo com que a documentação fique mais
legível. A Figura 21 exemplifica o uso das tags javadoc comentadas anteriormente.
FIGURA 21: Exemplo de tags Javadoc (DEITEL, 2005).
Na Listagem 13 é possível analisar um código Java usando comentário Javadoc como

algumas das funcionalidades citadas anteriormente. Note que nesse exemplo foram usadas
tags Javadoc e tags HTML.
77
1. /**
2. * MouseRotateY is a Java3D behavior object that lets
3. * users control the rotation of an object via a mouse.<p>
4. *
5. * To use this utility, first create a transform group
6. * that this rotate behavior will operate on. Then,
<blockquote>
7. *
8. * <pre>
9. * MouseRotateY behavior = new MouseRotateY();
10. * behavior.setTransformGroup(objTrans);
11. * objTrans.addChild(behavior);
12. * behavior.setSchedulingBounds(bounds);
13. * </pre>
14. *
15. * </blockquote> The above code will add the rotate
16. * behavior to the transform group. The user can rotate
17. * any object attached to the objTrans.
18. */
19.
20. public class MouseRotateY extends MouseBehavior {
21. double y_angle;
22. double y_factor;
23.
24. /**
25. * Creates a rotate behavior given the
transform group.
26. * @param transformGroup
27. * The transformGroup to operate on.
28. */
29. public MouseRotateY(TransformGroup transformGroup) {
30. super(transformGroup);
31. }
32.
33. ...
34.
35. }
Exemplo de código para conversão em Javadoc.
A Figura 22 ilustra o código fonte comentado da Listagem 12 para o formato HTML,

é nota-se que todo o comentário feito entre as linhas 1-18 da listagem, podem ser observadas
no quadro de destaque na figura.
78
FIGURA 22: Exemplo Javadoc convertido.
Toda a documentação do framework pode ser consultada no CD anexo à esse trabalho.

Todos os arquivos HTML estão na pasta javadoc.
79
7. CONCLUSÃO
Através de todos os elementos estudados ao longo deste trabalho, foi possível

desenvolver um framework Java, capaz de unir duas áreas distintas, a computação gráfica
e a física de movimentos. Assim, tornou possível facilitar o trabalho de futuros
desenvolvedores da área de computação gráfica a criarem animações baseadas nos movimento
de mecânica clássica.
Quanto às tecnologias, pôde-se avaliar a ferramenta de desenvolvimento de aplicações

tridimensionais do Java, a API Java 3D. Boa parte do tempo disposto para o desenvolvimento
desse trabalho, foi no aprendizado dessa ferramenta, principalmente no entendimento das
classes que dão sustento aos interpoladores de animação. Além disso, é importante lembrar
que grande parte da documentação usada para criação do framework, está no idioma inglês,
dificultando um pouco o aprendizado.
Para o desenvolvimento do projeto, foi importante também estudar as características

básicas dos movimentos da mecânica clássica da física. Como descrito no capítulo 2, vários
movimentos poderiam ser simulados através dos interpoladores, alguns um pouco mais
simples e outros um pouco mais complexos. A partir desse estudo, foi possível criar dois
interpoladores um para simular o MRU (velocidade constante) e outro para simulação da
Aceleração Constante.
Como esse trabalho, espera-se poder contribuir para o melhor entendimento da API
Java 3D, facilitando o uso da mesma na tarefa de criação de aplicações tridimensionais,
adicionando mas alguns recursos como interpoladores de movimentos mecânico,
Temporizador simplificado, importe de imagens 2D tratando-a como um modelo 3D,
configuração simplificada do universo virtual e controle dos interpoladores através de
interface gráfica, além disponibilizar recursos adicionais como visualizador, interação com
mouse e implementação de biblioteca para tratamento de aparência dos objetos.
Como sugestão de continuação desse trabalho, seria interessante a construção de outros

interpoladores que simulassem os movimentos da mecânica clássica que não foram abordados
nesse trabalho. Assim o framework poderia ficar mais flexível ao usuário, atraindo mais
adeptos a área de computação gráfica, aumentando a usabilidade, e explorando melhor esses
recursos no desenvolvimento de jogos eletrônicos.
80
8. REFERÊNCIAS BIBLIOGRÁFICAS
BICHO, A. L. et al. “Programação Gráfica 3D com OpenGL, Open

Inventor e Java 3D”. [Internet: http://www.tecgraf.puc-rio.br/publications/
artigo_2002_programacao_grafica_3d.pdf, recuperado em 26/08/2006] 2002.
BOUVIER, Dennis J. “Getting Started with the Java 3DTM API”. Tutorial v1.5.1.
California: Sun Microsystems, Inc., 2000.
CHAVES, Alaor. “Física: Mecânica”. Rio de Janeiro: Reichmann & Affonso Ed., 2001.
DEITEL, H. M.; DEITEL, P. J. Tradução FURMANKOEWICZ, E. “Java Como Programar”.

Criando Documentação com Javadoc. 6° Ed. São Paulo: Pearson P. H., 2005.
HALLIDAY, David; RESNICK, Robert. “Fundamentos de Física 1 - Mecânica”. 3. Ed. Rio

de Janeiro: LTC Ed., 1994.
JANDL, Peter Jr., “Java3d Browser”. Faculdade de Jaguariúna. [Internet: http://ni.faj.br/

nourau/document/get.php/2237/Java3D-Browser.ppt, recuperado 17/03/2006], 2004.
JUSTINO, Marcio J. C. “Laboratório Virtual de Física”. [Internet:

http://www.virtual.unilestemg.br/laboratorio/mecnew.html, recuperado em 14/06/06].
MALFATTI, Silvano M., DIHL, Leandro L., BRANCHER, Jacques D. “J3DTOOL – Um

Motor para o Desenvolvimento de Jogos Educacionais em JAVA 3D”. [Internet:
http://www.uricer.edu.br/~aitem/6333.pdf, recuperado em 06/04/06].
MANSSOUR, Isabel Harb. “Introdução ao Java 3DTM”. Rev. RITA, 2003.
MASSARO, Marlon. “Movimento Retilíneo Uniformemente Variado (MRUV)”. [Internet:

http://servlab.fis.unb.br/matdid/2_1999/Marlon-Eduardo/mruv.htm, recuperado em 12/06/2005].
SILVA, Luiz C. M. “Velocidade”. [Internet: http://br.geocities.com/saladefisica6/

cinematica/velocidade.htm, recuperado em 12/06/2006a].
SILVA, Luiz C. M. “Queda Livre”. [Internet: http://br.geocities.com/saladefisica8/

cinematica/quedalivre.htm, recuperado em 14/06/2006b].
SUN Microsystems. “Sun Developer Network (SDN)”. [Internet: http://Java.sun.com/,

recuperado em 14/06/2006a].
81
SUN Microsystems. “API Specification”. [Internet: http://Java.sun.com/products/

Java-media/3D/forDevelopers/J3D_1_3_API/j3dapi/index.html, recuperado em 20/10/2006b].
SUN Microsystems. “MouseRotateY”. [Internet: http://Java.sun.com/products/Java-

media/3D/downloads/index.html, recuperado em 15/09/2006]. 2000c.
SUN Microsystems. “Java”. [Internet: http://Java.sun.com/, recuperado em 20/10/2006d].
SUN Microsystems. “Project Looking Glass”. [Internet: http://www.sun.com/software/looking_glass/,

recuperado em 10/11/2006e].
UNIFICADO - FÍSICA. “Aceleração”. [Internet: http://www.unificado.com.br/fisica/

Aceleracao_fisica.htm, recuperado em 05/06/2006].
VALENTE, Luiz. “Representação de Cenas Tridimensionais: Grafo de Cenas”. Instituto

de Computação - Universidade Federal Fluminense [Internet: http://www.ic.uff.br/~lvalente/
docs/LuisValente_SceneGraph.pdf, recuperado em 25/10/2006], 2006.
VORTEX Entretenimento. “19-poly tree.jpg”. [Internet: http://www.unidev.com.br/

imagemExibe.asp?id=1832, recuperado em 25/10/2006], 2006.
WANGENHEIM, Aldo Von. “Apostila de Computação Gráfica”. [Internet:

http://www.inf.ufsc.br/~awangenh/CG/apostilas/apostilaport.pdf, recuperado em 30/05/2006].
WIKIPÉDIA. “Atari 2600”. [Internet: http://pt.wikipedia.org/wiki/Atari_2600, recuperado

em 30/05/2006a].
WIKIPÉDIA. “Movimento”. [Internet: http://pt.wikipedia.org/wiki/Movimento, recuperado

em 25/05/2006b].
WIKIPÉDIA. “Leis de Newton”. [Internet: http://pt.wikipedia.org/wiki/Leis_de_Newton,

recuperado em 16/06/2006c].
WIKIPÉDIA. “Atrito”. [Internet: http://pt.wikipedia.org/wiki/Atrito, recuperado em 07/06/06d].

82
ANEXO I
Neste anexo são demonstrados os diagramas UML utilizados para implementação do

framework. A segui são apresentados três diagramas: diagrama de caso de uso, diagrama de
classes e diagrama de seqüência.
Diagrama de Caso de Uso
Esse diagrama foi utilizado na fase de levantamento de requisitos e projeto, tem

a função de dar uma visão geral do funcionamento do framework. Na Figura 23 é possível ver
o diagrama de caso de uso e em seguida sua documentação.
FIGURA 23: Diagrama de Caso de Uso do framework.
TABELA 1: Documentação do Caso de Uso Criar Ambiente 3D.

Nome do Caso de Uso Criar Ambiente 3D
Ator Principal Usuário desenvolvedor
Resumo Este caso de uso cria
ambiente completo com
todo o necessário para
instanciação de objetos alvo.
Pré-Condições O Ator precisa passar
no mínimo um objeto
Component para criação
de texturas
Ações do Ator Ações do Sistema
1. Instanciar um objeto
Ambiente.
2. Construir universo, ramo
de conteúdo, canvas 3D,
Iluminação, capacidades
interativas e chão.
Restrições / Validações Consultar capítulo 5.1
83
TABELA 2: Documentação do Caso de Uso Criar Objeto Alvo.

Nome do Caso de Uso Criar objeto Alvo
Resumo Este caso de uso cria um
objeto Alvo para ser usado
no ambiente virtual.
Pré-Condições O ator precisa ter
instanciado um
objeto Ambiente.
Alvo.
2. Constrói um objeto com
a imagem fornecida pelo
usuário.
3. O sistema transforma
desse objeto em um
Billboard (ver capítulo 5.5)
Restrições / Validações Consultar capítulo 5.5.1.
TABELA 3: Documentação do Caso de Uso Criar Temporizador.

Nome do Caso de Uso Criar Temporizador
Resumo Este caso de uso cria um
Temporizador para ser usado
junto com os inteporladores
para criação de animações.
Pré-Condições
do tipo Temporizador.
2. Constrói um Temporizador
com os parâmetros
informados pelo usuário
(ver capítulo 5.3)
Restrições / Validações Consultar capítulo 5.3.1.

84
TABELA 4: Documentação do Caso de Uso Criar Animação.

Nome do Caso de Uso Criar animação
Resumo Este caso de uso é
responsável por criar
uma animação em um
objeto alvo através dos
interpoladores.
Pré-Condições É necessário que o
usuário instancie um
objeto ambiente, um
Temporizador e um alvo.
1. Instanciar um objeto do tipo
interpolador.
2. Constrói um
intepolador conforme
parâmetros fornecidos
pelo usuário.
Restrições / Validações Consultar capítulo 5.4
Diagrama de Classes
Esse diagrama foi utilizado na fase projeto, teve a função de definir as classes que
seriam usadas na criação do framework, definindo associações, generalizações e
especializações com as classes da API Java 3D e associações com as classes do próprio
framework. A Figura 24 ilustra como o framework está ligado com a API Java 3D.
As classes representadas na cor branca são classes da API Java 3D. As classes
representadas na cor amarela são classes do framework. E as classes representadas pela cor
verde, são classes integrantes do framework, mas não fazem parte do objetivo principal do
projeto, são classes auxiliares disponibilizadas por outros desenvolvedores.
85
FIGURA 24: Diagrama de classes do framework.

86
Diagrama de Seqüência
O diagrama de seqüência (Figura 25) define qual a ordem de instanciação dos objetos para
criação de uma aplicação baseada no framework.
FIGURA 25: Diagrama de seqüência do framework.

87
ANEXO II
A classe JD3Browser
A classe JD3Browser foi implementada para facilitar a criação de aplicações

tridimensionais baseadas no framework. A grande vantagem em usar essa classe é que o
usuário fica isento da responsabilidade de criar uma janela ou applet para exibição da
aplicação tridimensional.
Ela possui uma interface simples com dois botões os quais funcionam como um
interruptor para acender e apagar as luzes de ambiente e de capacetes implementadas na
classe Ambiente. A Figura 26 ilustra o objeto JD3Browser.
FIGURA 26: Exemplo de objeto JD3Browser.
Essa classe foi base na classe Java3D Browser (JANDL, 2004). Boa parte dos recursos
de classe foi mantida, alguns recursos foram retirados pois não teriam usabilidade e outros
adicionados.
88
Por se especificar da classe JFrame, o J3DBrowser disponibiliza todas

as funcionalidades de sua classe pai, sendo assim, objetos como botões, barra de ferramentas
e menus, podem ser adicionados a ele. Portanto, fica simples adicionar o componente Gatilho
a ele (ver figura 11).
A classe é composta por apenas um construtor e um método. Os mesmos são tratados

a seguir.
J3DBrowser ( )
Construtor padrão da classe J3DBrowser não precisa ser parametrizado. Sua função é
instanciar uma janela para adição de um ambiente virtual. A janela é dividida em dois painéis:
• pCanvas – onde é adicionado o objeto canvas3D da aplicação.

• pControle – onde são adicionados os botões luz de capacete e luz de ambiente
responsáveis por acender e apagar as luzes da aplicação.
adicionarAmbiente ( Ambiente )
O método adicionarAmbiente é responsável por adicionar um objeto Ambiente ao

painel pCanvas, ele também configura os botões do luz de capacete e luz de ambiente
habilitando as funções de acender ou apagar as luz quando solicitado pelo usuário. O método
recebe por parâmetro um objeto Ambiente.
setTitulo ( String )
O método setTitulo é responsável por alterar o título padrão do J3DBrowser

adicionando ao fim do original um comprimento para o título. O método recebe por parâmetro
um objeto String.
89
A Classe MouseRotateY
A classe MouseRotateY é responsável por criar uma interação no ambiente virtual,

essa interação é feita através do mouse por intermédio do usuário. E como o próprio nome
diz, o efeito esperado por essa interação é a rotação do objeto no eixo y. A classe Ambiente
implementa essa funcionalidade (ver capítulo 5.1), assim é possível que o usuário rotacione
o ambiente inteiro no eixo y.
A API Java3D disponibiliza algumas classes que possibilitam a interação do usuário

com o ambiente virtual, mas não havia por padrão uma classe que disponibilizava a função de
rotação no eixo y. Em pesquisas pela internet foi encontrada a classe MouseRotateY (SUN,
2000c), disponibilizada sobre licença gratuita, podendo ser alterada mas mantendo o
cabeçalho (comentário de licença) da classe. No caso do framework, não houve a necessidade
de fazer qualquer alteração.
A classe MouseRotateY por ser usada internamente pela classe Ambiente sem que o
usuário a defina diretamente, não haverá a necessidade de comentar seus construtores ou
métodos, para maiores informações consultar o código fonte da classe, disponível de CD
anexo há essa trabalho.
A Classe Cores
A classe Cores serve de apoio para o framework, ela disponibiliza com maior
facilidades funções relacionadas a aparência de objetos (matéria, textura e cores).
Ela é composta de vários métodos constantes e por serem estáticas podem ser usadas
em outras classes, sem maiores esforços. A classe Cores define oito constantes de cores.
Os métodos e constantes definidos por essa classe são descritos a seguir:
• PRETO – definida pela instancia Color3f (0.0f,0.0f,00.0f).

• VERMELHO – definida pela instancia Color3f (1.0f,0.0f,0.0f).
• VERDE – definida pela instancia Color3f (0.0f,1.0f,0.0f).
90
• AMARELO – definida pela instancia Color3f (1.0f,1.0f,0.0f).

• AZUL – definida pela instancia Color3f (0.0f,0.0f,1.0f).
• AZULCLARO – definida pela instancia Color3f (0.0f,1.0f,1.0f).
• MAGENTA – definida pela instancia Color3f (1.0f,0.0f,1.0f).
• BRANCO – definida pela instancia Color3f (1.0f,1.0f,1.0f).
getAparenciaPadrao ( )
Método estático da classe Cores retorna uma aparência padrão. Essa aparência tem um
tom de cor amarelada. Não necessita parametrização.
setAparencia ( Color3f )
Método estático da classe Cores recebe como parâmetro um objeto do tipo Color3f
definido pelo usuário e retorna uma aparência com o tom de cor definido.
setAparencia ( Componet, String )
Método estático da classe Cores recebe como parâmetro um objeto do tipo Component
e um objeto do tipo String definidos pelo usuário, esses são necessários para criação da
textura. Esse método retorna um objeto do tipo Appearance contendo a textura definida.

Mecanica Classica 0301670

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Mecanica Classica 0301670

Caricato da

Copyright:

Formati disponibili

Eder Miranda Ferreira Leite

CONSTRUÇÃO DE FRAMEWORK PARA SUPORTE DE

ANIMAÇÕES "NEWTONIANAS" USANDO MECÂNICA CLÁSSICA

CONSTRUÇÃO DE FRAMEWORK PARA SUPORTE DE

ANIMAÇÕES "NEWTONIANAS" USANDO MECÂNICA CLÁSSICA

Monografia apresentada à disciplina Trabalho

A realização desta monografia só foi possível pelo concurso de inúmeras pessoas.

De modo particular agradeço:

Aos professores do curso de Ciência da Computação que, durante a graduação, tanto

Será apresentada uma base de conhecimentos relacionados à física de movimentos, mais

2. LEIS DE MOVIMENTO DA FÍSICA CLÁSSICA.........................................................21

3. API JAVA 3D...................................................................................................................29

4. AVALIAÇÃO E SELEÇÃO DE FUNCIONALIDADES MÍNIMAS ............................36

5. PROJETO E IMPLEMENTAÇÃO ..................................................................................41

8. REFERÊNCIAS BIBLIOGRÁFICAS .............................................................................80

FIGURA 1: Jogos de ontem e hoje............................................................................... 17

TABELA 1: Documentação do Caso de Uso Criar Ambiente 3D. ............................... 82

EQUAÇÃO 1: Movimento Retilíneo Uniforme ............................................................... 22

Instância do SimpleUniverse. ................................................................................................... 32

2D – Segunda dimensão ou bidimensional.

3D – Terceira dimensão ou tridimensional.

AWT – Abstract Window Toolkit.

HTML – Hyper Text Markup Language (Linguagem de Marcação de Hipertexto).

IDE – Integrated Development Environment (Ambiente Integrado de Desenvolvimento

Java SE – Java Standard Edition.

JRE – Java Runtime Environment.

JVM – Java Virtual Machine (Máquina Virtual Java).

MIT – Massachusetts Institute of Technology.

MRU – Movimento Retilíneo Uniforme.

MRUV – Movimento Retilíneo Uniformemente Variado.

PDA – Personal Digital Assistant (Assistente Pessoal Digital).

PC – Personal Computer (Computador Pessoal).

RGB – Red, Green and Blue (Vermelho, Verde e Azul).

UML – Unified Modeling Language (Linguagem de Modelagem Unificada).

URL – Universal Resource Locator (Localizador Uniformizado de Recursos).

VRML – Virtual Reality Modelating Language (Linguagem para Modelagem

Essa evolução do hardware impulsionaram os desenvolvedores à criarem sistemas cada

FIGURA 1: Jogos de ontem e hoje.

Das tecnologias disponíveis no mercado, a linguagem de programação Java foi a que

Sendo assim, este trabalho possui os seguintes objetivos:

• Construção de um framework para facilitar futuros desenvolvedores a criarem

1.1. Computação Gráfica

Computação gráfica é uma área da ciência da computação destinada a geração de

“E em 1970, surgem os primeiros monitores à varredura” (WANGENHEIM, 2006).

1.2. Problemas, Solução e Apresentação

Esse trabalho envolve duas questões importantes na computação gráfica: a animações

O foco aqui é facilitar para o usuário final (desenvolvedor ou instrutor), a aplicação de

Hoje em dia, é muito comum a aplicação desses movimentos em jogos eletrônicos,

Um personagem quando se movimenta em um jogo, e encontra um obstáculo sólido

2. LEIS DE MOVIMENTO DA FÍSICA CLÁSSICA

Esse capítulo apresentará alguns dos principais movimentos da física clássica,

2.1. Movimento Retilíneo

De acordo com WIKIPÉDIA (2006b),

Em mecânica clássica, movimento retilíneo é o movimento em que o objeto,

2.1.1. Movimento Retilíneo Uniforme (MRU)

No movimento retilíneo uniforme a velocidade é constante e, portanto não existe

10m 20m 30m

FIGURA 2: Exemplo de movimento retilíneo uniforme (MRU)

Na Figura 2, é demonstrado um exemplo de MRU. O objeto móvel (caixa) se desloca

2.1.2. Movimento Retilíneo Uniformemente Variado (MRUV)

Movimento retilíneo uniformemente variado é aquele em que o corpo sofre acelerações

Conforme MASSARO (2006) o MRUV caracteriza-se pelos seguintes conceitos:

• A aceleração é o quociente da variação de velocidade ( ∆v ) pelo intervalo

• A velocidade não permanece constante, aumenta ou diminui ao longo do tempo,