Embed Size (px)
Citation preview
UNIVERSIDADE REGIONAL DE BLUMENAU
CENTRO DE CIÊNCIAS EXATAS E NATURAIS
CURSO DE CIÊNCIA DA COMPUTAÇÃO – BACHARELADO
UM MOTOR DE PERSONAGENS ARTICULADOS 3D PARA
ANDROID
ANDRÉ WILLIAM PRADE HILDINGER
BLUMENAU
2012
2012/1-07
ANDRÉ WILLIAM PRADE HILDINGER
UM MOTOR DE PERSONAGENS ARTICULADOS 3D PARA
ANDROID
Trabalho de Conclusão de Curso submetido à
Universidade Regional de Blumenau para a
obtenção dos créditos na disciplina Trabalho
de Conclusão de Curso II do curso de Ciência
da Computação — Bacharelado.
Prof. Dalton Solano dos Reis, M. Sc. - Orientador
BLUMENAU
2012
2012/1-07
UM MOTOR DE PERSONAGENS ARTICULADOS 3D PARA
ANDROID
Por
ANDRE WILLIAM PRADE HILDINGER
Trabalho aprovado para obtenção dos créditos
na disciplina de Trabalho de Conclusão de
Curso II, pela banca examinadora formada
por:
______________________________________________________
Presidente: Prof. Dalton Solano dos Reis, M. Sc. – Orientador, FURB
______________________________________________________
Membro: Prof. Aurélio Faustino Hoppe, M. Sc. – FURB
______________________________________________________
Membro: Prof. Mauro Marcelo Mattos, Dr. – FURB
Blumenau, 9 de Julho de 2012
Dedico este trabalho a todos que me apoiaram
durante todo o curso, especialmente meus pais,
minha noiva e amigos.
AGRADECIMENTOS
À minha família, por sempre me apoiar e incentivar o conhecimento.
À minha noiva, Kriséven Campana, pelo carinho e compreensão.
Ao meu orientador, Dalton Solano dos Reis, por ter acreditado na conclusão deste
trabalho.
A persistência é o menor caminho do êxito.
Charles Chaplin
RESUMO
Este trabalho apresenta a implementação de uma biblioteca que envolve o conceito de
personagens articulados para dispositivos móveis da plataforma Android e um aplicativo que
utiliza a biblioteca para desenhar um braço mecânico articulado. A biblioteca disponibiliza
ferramentas para a criação de personagens articulados simples. Para o desenho destes
personagens foi utilizada a biblioteca OpenGL ES 1.0 disponível no Android. A interação
com o aplicativo se dá pelo toque na tela, sendo possível girar livremente a câmera e mover
cada uma das articulações. Por fim foi apresentado um estudo de desempenho prático com a
aplicação rodando em um dispositivo da plataforma Android.
Palavras-chave: Android. Personagens articulados. Motor. 3D.
ABSTRACT
This work describes the construction of a library for development of articulated characters for
Android platform mobile devices and an application that uses the library to draw a mechanic
articulated arm. The library provides tools for creating simple articulated characters. It was
used OpenGL ES 1.0 library available on Android to draw these characters. The interaction
with the application is done by touch screen, and the camera can rotate freely and move each
of the joints. Finally it was presented a study of practical performance with the application
running an Android platform device.
Key-words: Android. Articulated characters. Game. 3D.
LISTA DE ILUSTRAÇÕES
Figura 1 - Pipeline de função fixa existente ............................................................................. 16
Figura 2 - ES2.0 Pipeline programável .................................................................................... 17
Figura 3 - Graus de liberdade ................................................................................................... 18
Figura 4 - Animação de arquivo FBX no simulador ................................................................ 20
Figura 5 - Jogo desenvolvido com o Catcake ........................................................................... 21
Figura 6 - Diagrama de casos de uso ........................................................................................ 23
Quadro 1 - Caso de uso UC01 .................................................................................................. 24
Quadro 2 - Caso de uso UC02 .................................................................................................. 24
Quadro 3 - Caso de uso UC03 .................................................................................................. 25
Quadro 4 - Caso de uso UC05 .................................................................................................. 26
Figura 7 - Principais classes da biblioteca ................................................................................ 27
Figura 8 - Principais classes do aplicativo ............................................................................... 29
Figura 9 - Diagrama de sequência Mover articulações ....................................................... 30
Figura 10 - Estrutura de classes da aplicação ........................................................................... 32
Quadro 5 - Iteração principal da aplicação ............................................................................... 33
Quadro 6 - Arquivo main.xml .............................................................................................. 34
Quadro 7 - Instanciação das classes GestureDetector e JointActionRenderer ................. 34
Quadro 8 - Método initializeScene da classe JointActionRenderer ........................ 35
Quadro 9 - Criação dos objetos tridimensionais e suas articulações ........................................ 36
Figura 11 - Aplicação rodando no simulador ........................................................................... 37
Figura 12 - Sequência de movimentação de um DOF .............................................................. 38
Figura 13 - Efeito visual dos botões da aplicação .................................................................... 38
Figura 14 - Tela principal da aplicação de testes...................................................................... 39
Figura 15 - Sequência de execução do teste de quantidade de nodos ...................................... 40
Figura 16 - Tela principal da aplicação de testes com resultados ............................................ 41
Tabela 1 - Resultados de quantidade de nodos ......................................................................... 42
Figura 17 - Gráfico de quantidade de nodos............................................................................. 43
Tabela 2 - Resultados de quantidade de DOFs ......................................................................... 43
Figura 18 - Gráfico de quantidade de DOFs............................................................................. 44
Figura 19 - Memória utilizada para quantidade de nodos ........................................................ 44
Figura 20 - Memória utilizada para quantidade de DOFs ........................................................ 45
Quadro 10 - Classes convertidas do V-ART ............................................................................ 46
Quadro 11 - Memória ocupada pelos tipos primitivos em Java ............................................... 52
Quadro 12 - Memória ocupada pelas classes da biblioteca ...................................................... 52
Quadro 13 - Fórmula de um cenário ......................................................................................... 53
LISTA DE SIGLAS
ADT – Android Development Tools
API – Application Programming Language
CPU – Central Processing Unit
DOF - Degree Of Freedom
FPS – Frames Per Second
GHz – Giga Hertz
GPU – Graphics Processing Unit
IDE - Integrated Development Environment
KB - Kilo Bytes
MB – Mega Bytes
OpenGL – Open Graphics Library
OpenGL ES – OpenGL for Embedded Systems
RAM – Random Access Memory
ROM – Read Only Memory
SDK - Software Development Kit
UML - Unified Modeling Language
XML - eXtensible Markup Language
SUMÁRIO
1 INTRODUÇÃO .................................................................................................................. 13
1.1 OBJETIVOS DO TRABALHO ........................................................................................ 13
1.2 ESTRUTURA DO TRABALHO ...................................................................................... 14
2 FUNDAMENTAÇÃO TEÓRICA .................................................................................... 15
2.1 SISTEMA OPERACIONAL ANDROID ......................................................................... 15
2.2 BIBLIOTECA OPENGL ES ............................................................................................. 16
2.3 V-ART ............................................................................................................................... 17
2.4 PERSONAGENS ARTICULADOS ................................................................................. 18
2.5 TRABALHOS CORRELATOS ........................................................................................ 19
2.5.1 Visualizador de Animação 3D com Suporte ao Formato de Arquivos FBX em
Objective-C++ ................................................................................................................. 19
2.5.2 Catcake ............................................................................................................................ 20
3 DESENVOLVIMENTO .................................................................................................... 22
3.1 DESENVOLVIMENTO EM ANDROID ......................................................................... 22
3.2 REQUISITOS PRINCIPAIS DO PROBLEMA A SER TRABALHADO ....................... 22
3.3 ESPECIFICAÇÃO ............................................................................................................ 23
3.3.1 Casos de uso .................................................................................................................... 23
3.3.1.1 Mover articulações ........................................................................................................ 24
3.3.1.2 Girar câmera ................................................................................................................. 24
3.3.1.3 Adicionar e movimentar câmeras ................................................................................. 24
3.3.1.4 Adicionar e movimentar objetos tridimensionais e articulações .................................. 25
3.3.2 Diagramas de classes....................................................................................................... 26
3.3.2.1 Biblioteca ...................................................................................................................... 27
3.3.2.2 Aplicativo ..................................................................................................................... 28
3.3.3 Diagrama de sequência ................................................................................................... 30
3.4 IMPLEMENTAÇÃO ........................................................................................................ 31
3.4.1 Técnicas e ferramentas utilizadas.................................................................................... 31
3.4.2 A aplicação ...................................................................................................................... 31
3.4.2.1 Criação a configuração de um novo projeto ................................................................. 31
3.4.2.2 Estrutura de classes da aplicação e utilização da biblioteca ......................................... 32
3.4.3 Aplicação para testes de desempenho ............................................................................. 39
3.5 RESULTADOS E DISCUSSÃO ...................................................................................... 41
3.5.1 Resultados obtidos nos testes de desempenho e memória .............................................. 42
3.5.1.1 Testes de desempenho .................................................................................................. 42
3.5.1.2 Memória ........................................................................................................................ 44
3.5.2 Classes convertidas ......................................................................................................... 45
4 CONCLUSÕES .................................................................................................................. 47
4.1 EXTENSÕES .................................................................................................................... 48
REFERÊNCIAS BIBLIOGRÁFICAS ................................................................................. 49
APÊNDICE A – Cálculos de memória ................................................................................. 52
13
1 INTRODUÇÃO
Vive-se hoje uma batalha de dispositivos móveis em que cada empresa que possui um
sistema operacional para celulares, tablets, entre outros tenta inovar mais e oferecer mais
funcionalidades a seus usuários.
Um destes sistemas operacionais é o Android, que vem cada vez mais conquistando
novos usuários. Para este sistema operacional já existem vários dispositivos com alta
capacidade de processamento de dados e processamento gráfico, como por exemplo o
dispositivo Nexus S da Google (2011b), podendo, desta forma, executar aplicativos em duas
dimensões (2D) e três dimensões (3D).
No mundo 3D existe uma biblioteca multiplataforma chamada Open Graphics Library
(OpenGL). OpenGL é uma Application Programming Interface (API) gráfica multiplataforma
que especifica uma interface de software padrão para hardware de processamento de gráficos
3D. Para dispositivos embarcados existe uma versão do OpenGL chamada OpenGL for
Embedded Systems (OpenGL ES).
Android inclui suporte para gráficos de alto desempenho em 2D e 3D com o Open
Graphics Library (OpenGL), especificamente, a API OpenGL ES. As especificações do
OpenGL ES 1.0 e 1.1 têm sido suportadas desde o Android 1.0. Começando com o Android
2.2 (API Nível 8), a estrutura suporta a especificação da API OpenGL ES 2.0 (GOOGLE,
2011a).
Este trabalho disponibiliza um motor para facilitar o desenvolvimento de aplicativos
com personagens articulados 3D simples para dispositivos Android, utilizando o OpenGL ES.
O motor permite criar um personagem 3D articulado e executar movimento de articulações
num mundo virtual simples (somente o personagem sobre um chão).
A implementação do motor utiliza como base o código do framework chamado Virtual
Articulations for Virtual Reality (V-ART) que foi desenvolvido com participação do
orientador deste trabalho (VART, 2011).
1.1 OBJETIVOS DO TRABALHO
O objetivo deste trabalho é implementar um motor de personagens articulados 3D para
14
dispositivos Android.
Os objetivos específicos do trabalho são:
a) migrar o código do V-ART desenvolvido em C++ para Java;
b) disponibilizar uma API em Java, criada a partir da migração do código do V-ART
desenvolvido em C++;
c) permitir descrever um personagem 3D articulado e exibir as suas movimentações
num mundo virtual simples;
d) disponibilizar uma aplicação com funções básicas de visualização.
1.2 ESTRUTURA DO TRABALHO
A estrutura deste trabalho está apresentada em quatro capítulos, sendo que o segundo
capítulo contém a fundamentação teórica necessária para o entendimento deste trabalho.
O terceiro capítulo apresenta como foi desenvolvida a aplicação na plataforma
Android, os casos de uso da biblioteca, os diagramas de classe e toda a especificação que
define a aplicação. Ainda no terceiro capítulo são apresentadas as partes principais da
implementação e também os resultados e discussões que aconteceram durante toda a etapa de
desenvolvimento do trabalho.
Por fim, o quarto capítulo refere-se às conclusões do presente trabalho e sugestões para
trabalhos futuros.
15
2 FUNDAMENTAÇÃO TEÓRICA
De modo a revisar alguns conceitos importantes que aplicam-se ao trabalho, a seção
2.1 conta com conteúdo relativo ao sistema operacional Android. Em seguida, nas seções 2.2
e 2.3, são descritas as principais características da biblioteca OpenGL ES e do framework V-
ART, respectivamente. Na seção 2.4 é apresentado o conceito de personagens articulados. Por
fim, na seção 2.5 são apresentados trabalhos similares ao que é proposto.
2.1 SISTEMA OPERACIONAL ANDROID
Android é um conjunto de softwares para dispositivos móveis que inclui aplicações de
um sistema operacional, middleware e aplicativos chave. O Android SDK fornece as
ferramentas e APIs necessárias para começar a desenvolver aplicações para a plataforma
Android usando a linguagem de programação Java (GOOGLE, 2011c).
Segundo Google (2011c), o sistema operacional é dividido em quatro principais
camadas, sendo elas: kernel Linux, bibliotecas, framework de aplicação e aplicações.
O kernel Linux utilizado pelo Android é a versão 2.6 e é ele o responsável por serviços
centrais do sistema, como segurança, gerenciamento de memória, gestão de processos, pilha
de rede e modelo de driver. O kernel também atua como uma camada de abstração entre o
hardware e o resto da pilha de software (GOOGLE, 2011c).
A camada de bibliotecas é implementada em C/C++ e é utilizada por diversos
componentes do sistema Android. Estas capacidades são expostas a desenvolvedores através
do framework de aplicação Android (GOOGLE, 2011c).
A camada de framework de aplicação é aquela que é exposta aos desenvolvedores,
permitindo acesso ao hardware do dispositivo, informações de localização, rodar serviços,
entre outros (GOOGLE, 2011c).
Aplicações são os softwares utilizados diretamente pelos usuários finais, como jogos,
calculadora e agenda telefônica. Igualmente aos sistemas operacionais para computadores
comuns, são estes softwares que mais interessam ao usuário final, pois ele estará diariamente
lidando com os mesmos (GOOGLE, 2011c).
16
2.2 BIBLIOTECA OPENGL ES
OpenGL ES é uma API multiplataforma livre para gráficos de função completa 2D e
3D, em sistemas embarcados - incluindo consoles, celulares, eletrodomésticos e veículos. Ele
consiste de subconjuntos bem definidos de OpenGL desktop, criando uma flexível e poderosa
interface de baixo nível entre software e aceleração gráfica (KHRONOS GROUP, 2011a).
OpenGL é uma das mais difundidas APIs gráficas da atualidade. Sua versão OpenGL
ES para dispositivos móveis não é exceção, ela vem sendo utilizada amplamente nas
plataformas mais importantes da atualidade, como Android, Symbian (2011), iOS (2011),
BlackBerry (2011), Nintendo 3DS (2011), entre outros.
O Android 2.2 é a primeira versão do Android a suportar o OpenGL ES 2.0. De acordo
com Khronos Group (2011b), a especificação do OpenGL ES 2.0 foi feita baseada na
especificação do OpenGL 2.0, tornando a implementação para dispositivos móveis mais
parecida com a implementação para computadores desktop.
O OpenGL 2.0 traz pipelines programáveis. Isso substitui a transformação de função
fixa e fragmento de pipeline do OpenGL 1.x. Utiliza também shaders, o que minimiza o custo
e aumenta o poder de subsistemas avançados de gráficos programáveis (KHRONOS GROUP,
2011b).
A Figura 1 mostra a arquitetura do OpenGL ES antes da versão 2.0. Já a Figura 2
mostra a arquitetura a partir da versão 2.0.
Fonte: Khronos Group (2011b).
Figura 1 - Pipeline de função fixa existente
17
Fonte: Khronos Group (2011b).
Figura 2 - ES2.0 Pipeline programável
Na versão 2.0 do OpenGL ES, a parte de transformação e luz foi substituída por vertex
shader e as partes de ambiente de textura, soma de cor, fumaça e teste de transparência foram
substituídas por fragment shader, também conhecido como pixel shader.
No campo da computação gráfica, um shader é um conjunto de instruções de software,
que é usado, principalmente, para calcular efeitos de renderização de hardware de gráficos
com um elevado grau de flexibilidade. Shaders são usados para programar o pipeline de
processamento programável da Graphics Processing Unit (GPU), que substituiu o pipeline de
função fixa. Isso permite apenas transformação de geometria comum e funções de pixel
shading. Com shaders, efeitos personalizados podem ser utilizados (SHADER, 2011).
2.3 V-ART
O Virtual ARTiculations for virtual reality (V-ART) é um framework desenvolvido em
C++ para facilitar a criação de programas com ambientes 3D, em especial os que contém
humanóides. Ele distingue-se de outros frameworks semelhantes como Open Inventor (2011),
PLIB (2011), Maverik (2011) e VRJuggler (2011) por ser inteiramente orientado a objetos,
possuir um sistema de suporte a animações e permitir a representação de articulações
biologicamente corretas (VART, 2011).
O V-ART tem suas origens no projeto Visualization and interaction with virtual
PATients (VPAT) (VPAT, 2011) e era conhecido por este nome até maio de 2006, quando foi
renomeado. Ele é projetado para ser multiplataforma e independente de API gráfica (OpenGL,
18
Direct3D, entre outras) (VART, 2011).
2.4 PERSONAGENS ARTICULADOS
As possibilidades de movimento do mecanismo de articulação no espaço
tridimensional correspondem ao número de parâmetros cinemáticos independentes
permitidos, chamados de Degree Of Freedom (DOF). Quanto maior o número de DOFs,
maior a liberdade de movimentação da estrutura e configurações possíveis para o
estabelecimento de poses (MIDIAARTE, 2002).
A Figura 3 demonstra os três possíveis graus DOFs de rotação, sendo eles inclinar para
frente e para trás (pitch), virar para esquerda e para direita (yaw) e inclinar de lado a lado
(roll) (DOF, 2012).
Fonte: DOF (2012)
Figura 3 - Graus de liberdade
Articulação ou juntura é a conexão entre duas ou mais peças esqueléticas (SISTEMA
ARTICULAR, 2012). De acordo com Aulas Fisio (2012), cada articulação é composta por
um, dois ou três DOFs, sendo nomeadas:
a) Uniaxial: 1 DOF (um par de movimento). Exemplos: interfalangianas (pontos dos
dedos) e tornozelos;
19
b) Biaxial: 2 DOFs (dois pares de movimento). Exemplos: punhos e joelhos;
c) Triaxial: 3 DOFs (três pares de movimento) Exemplo: ombro.
De acordo com Thalmann e Thalmann (1990, p. 3), animação se refere ao processo de
gerar dinamicamente uma série de quadros de um conjunto de objetos, em que cada quadro é
uma alteração do quadro anterior.
2.5 TRABALHOS CORRELATOS
Existem muitos motores para o desenvolvimento de aplicações 3D. Dentre eles, dois
foram escolhidos como trabalhos correlatos, sendo o primeiro o trabalho de Pereira (2010)
(Visualizador de Animação 3D com Suporte ao Formato de Arquivos FBX em Objective-
C++) e o segundo um motor de gráfico 3D chamado Catcake (2011).
2.5.1 Visualizador de Animação 3D com Suporte ao Formato de Arquivos FBX em
Objective-C++
O trabalho de Pereira (2010) é um protótipo de visualização de arquivos no formato
FilmBoX (FBX) para a plataforma iOS4 implementado na linguagem Objective-C++,
denominado iSceneViewer, que também utiliza a biblioteca OpenGL ES para a construção de
formas geométricas representadas pela estrutura de dados importada de um arquivo FBX.
Segundo Pereira (2010), o formato FBX desenvolvido pela Autodesk vem sendo
aperfeiçoado há alguns anos. Este formato de arquivo tende a tornar-se cada vez mais versátil
e universal dado que, sendo de código aberto, permite a adoção por outras marcas de software
que integram nas suas plataformas. O FBX permite assim aos criadores de conteúdos 3D um
favorecimento da colaboração em nível de arquivos de dados de geometria, uma vez que
podem utilizar diferentes aplicações, partilhando e integrando as suas criações sem limites de
compatibilidade.
Neste trabalho foi implementada a visualização do modelo 3D e a visualização de
animações e posições de câmera contidas no arquivo FBX importado.
No protótipo desenvolvido, além da visualização do modelo 3D, é possível visualizar
20
as animações e posições de câmeras que foram definidas na confecção da cena na ferramenta
usada para geração do arquivo importado.
Possui como limitações a falta de suporte a texturas e iluminações, que podem estar
contidas no arquivo importado.
Pode-se visualizar mais detalhes da animação de um arquivo FBX com este trabalho
no vídeo de Pereira (2011) (Figura 4).
Fonte: Pereira (2011).
Figura 4 - Animação de arquivo FBX no simulador
2.5.2 Catcake
Catcake é um motor de gráfico 3D multiplataforma, destinado a ser fácil de usar e de
alto desempenho, que também suporta os recursos para desenvolvimento de jogos, como
animação, manuseio do dispositivo de entrada e reprodução de som. Este motor roda nas
plataformas Windows, Linux e Android e possui os seguintes recursos:
a) renderização de polígonos e sprite com grafo de cena;
b) gerenciamento de objetos transparentes;
c) gerenciamento de tarefas leves para animação;
d) gestão de recursos;
e) gerenciamento de memória;
f) ajuste automático de frame-rate;
21
g) renderização de fontes;
h) divisão de tela (útil para jogos que mais de um jogador irá jogar na mesma tela);
i) monitor de depuração em tempo real;
j) shaders programáveis;
k) iluminação;
l) gestão de periféricos (mouse e teclado);
m) reprodução de sons com mixer de 4 canais;
n) detecção de colisão;
o) desenho de modelagem 3D;
p) geração automático de modelo 3D a partir de imagens 2D.
A Figura 5 demonstra um jogo desenvolvido com o motor Catcake.
Fonte: Catcake (2011).
Figura 5 - Jogo desenvolvido com o Catcake
Em comparação ao trabalho proposto, Catcake possui funcionalidades não
disponibilizadas para a criação de aplicações 3D, principalmente para jogos, como detecção
de colisão, reprodução de sons e gestão de periféricos. Não possui controle preciso sobre as
articulações e DOFs dos personagens criados.
22
3 DESENVOLVIMENTO
Neste capítulo são detalhadas as etapas do desenvolvimento do trabalho. São ilustrados
os principais requisitos, a especificação, a implementação e por fim são listados resultados e
discussão.
3.1 DESENVOLVIMENTO EM ANDROID
O presente trabalho foi desenvolvido em dois projetos. Em um projeto foi
desenvolvida a biblioteca do código convertido do V-ART. No segundo projeto foi
desenvolvido um aplicativo que demonstra funcionalidades da biblioteca.
Ambos projetos foram desenvolvidos utilizando o Android SDK, ambiente de
desenvolvimento padrão da plataforma. Detalhes sobre a instalação do Android SDK podem
ser obtidos através da referência Android Developers (2012a). Para a execução do projeto no
simulador é necessário definir um dispositivo virtual. Informações sobre a criação desses
dispositivos podem ser encontradas na referência Android Developers (2012b).
3.2 REQUISITOS PRINCIPAIS DO PROBLEMA A SER TRABALHADO
O presente trabalho deverá:
a) exibir um personagem articulado num mundo virtual simples, somente o
personagem sobre um chão (Requisito Funcional - RF);
b) disponibilizar uma aplicação usando o MJ3A-PA com funções básicas de
visualização que permita inspecionar o personagem mudando a posição da câmera
(RF);
c) o sistema deve ser desenvolvido na linguagem Java (Requisito Não Funcional -
RFN);
d) o sistema deve ser compatível com o sistema operacional Android 2.3.3 ou
superior (RNF);
23
e) o código fonte deve ser documentado utilizando JavaDoc (RNF);
f) a aplicação disponibilizada deve ser testada no simulador e também no dispositivo
físico (RNF).
3.3 ESPECIFICAÇÃO
A especificação do presente trabalho foi desenvolvida através das ferramentas
StarUML e Object Aid, utilizando os conceitos de orientação a objetos e baseando-se nos
diagramas da Unified Modeling Language (UML), gerando como produtos os diagramas de
caso de uso, de classes e de sequência apresentados nas seções seguintes.
3.3.1 Casos de uso
Nesta sessão são descritos os casos de uso de todos os recursos da aplicação. Foram
identificados dois atores principais. O primeiro deles, o Usuário, faz uso de uma aplicação
baseada na biblioteca desenvolvida. Já o ator Desenvolvedor faz uso das ferramentas
disponibilizadas para possibilitar o desenvolvimento de personagens articulados. Na Figura 6
é apresentado o diagrama de casos de uso da aplicação.
Figura 6 - Diagrama de casos de uso
24
3.3.1.1 Mover articulações
Este caso de uso descreve como o ator Usuário interage com o aplicativo para mover as
articulações do personagem articulado. Detalhes deste caso de uso estão descritos no Quadro 1.
UC01 - Mover articulações
Descrição As articulações possuem um valor mínimo e um máximo que delimitam o
quanto esta articulação pode ser movida.
Pré-Condição O aplicativo de personagem articulado deve estar aberto.
Cenário
Principal 1. O Usuário pressiona um dos botões de movimento de articulação;
2. A aplicação move a articulação de acordo com o botão pressionado.
Exceção 1 1. Se a articulação estiver em seu limite mínimo ou máximo e o Usuário
pressionar o botão que equivale à movimentação da mesma direção,
nada acontece.
Pós-Condição A articulação equivalente ao botão pressionado deve estar movida. Quadro 1 - Caso de uso UC01
3.3.1.2 Girar câmera
Este caso de uso descreve como o ator Usuário interage com o aplicativo para girar a
câmera ao redor do personagem. Detalhes deste caso de uso estão descritos no Quadro 2.
UC02 - Girar câmera
Descrição A câmeras possui a funcionalidade de girar ao redor do personagem.
Pré-Condição O aplicativo de personagem articulado deve estar aberto.
Cenário
Principal
1. O Usuário arrasta o dedo sobre a tela vertical ou horizontalmente;
2. A aplicação gira a câmera ao redor do personagem articulado de
acordo com a direção que o Usuário arrastou.
Pós-Condição A câmera dever ter girado na direção que o Usuário arrastou o dedo. Quadro 2 - Caso de uso UC02
3.3.1.3 Adicionar e movimentar câmeras
Este caso de uso descreve como o ator Desenvolvedor interage com a biblioteca para
adicionar e movimentar câmeras. Detalhes deste caso de uso estão descritos no Quadro 3.
25
UC03 - Adicionar e movimentar câmeras
Descrição Várias câmeras podem ser adicionadas a uma cena. Cada câmera pode
estar direcionada a um ponto diferente e poder girar ao redor deste ponto.
Pré-Condição O Desenvolvedor deve possuir uma aplicação que utiliza a biblioteca de
personagens articulados e deve possuir uma instância da classe Scene.
Cenário
Principal
1. O Desenvolvedor cria uma nova câmera informando a posição da
câmera, o foco da câmera e a orientação da câmera;
2. A biblioteca cria uma nova câmera com as informações passadas;
3. O Desenvolvedor utiliza o método addCamera da classe Scene para
adicionar a câmera criada à cena;
4. A biblioteca adiciona a câmera à lista de câmeras da cena;
5. O Desenvolvedor utiliza o método setTarget da classe Camera para
definir um novo alvo da câmera;
6. A biblioteca direciona a câmera para o novo alvo definido;
7. O Desenvolvedor utiliza o método setLocation da classe Camera
para definir uma nova posição para a câmera;
8. A biblioteca move a câmera para a nova posição definida;
9. O Desenvolvedor utiliza os métodos yawAroundTarget e
pitchAroundTarget da classe Camera para girar ao redor do alvo;
10. A biblioteca gira a câmera ao redor do alvo definido;
Pós-Condição As imagens da câmera são exibidas na tela do dispositivo. Quadro 3 - Caso de uso UC03
3.3.1.4 Adicionar e movimentar objetos tridimensionais e articulações
Este caso de uso descreve como o ator Desenvolvedor interage com a biblioteca para
adicionar e movimentar objetos tridimensionais e articulações. Detalhes deste caso de uso estão
descritos no Quadro 4.
26
UC04 - Adicionar e movimentar objetos tridimensionais e articulações
Descrição
Vários objetos tridimensionais e articulações podem ser adicionados a
uma cena. As articulações são adicionadas entre dois objetos e fazem com
que cada objeto filho do objeto base seja movido ao movimentar a
articulação.
Pré-Condição O Desenvolvedor deve possuir uma aplicação que utiliza a biblioteca de
personagens articulados e deve possuir uma instância da classe Scene.
Cenário
Principal
1. O Desenvolvedor cria um novo objeto da classe MeshObject e utiliza
o método makeBox passando as coordenadas de largura, altura e
profundidade mínimas e máximas;
2. A biblioteca cria uma nova forma retangular tridimensional de acordo
com as coordenadas informadas;
3. O Desenvolvedor utiliza o método addObject da classe Scene
passando como parâmetro o objeto criado no passo 1;
4. A biblioteca adiciona o objeto criado no passo 1 na lista de objetos da
cena;
5. O Desenvolvedor cria um novo objeto da classe UniaxialJoint e
utiliza o método addDof e armazena o retorno deste método em um
atributo do tipo Dof;
6. A biblioteca cria uma nova articulação e adiciona a ela um grau de
liberdade;
7. O Desenvolvedor utiliza o método addChild do objeto MehsObject
criado no passo 1 passando a articulação criada no passo 5 como
parâmetro;
8. A biblioteca adiciona a articulação do passo 5 à lista de objetos filhos
do objeto do passo 1;
9. O Desenvolvedor repete os passos 1 e 2;
10. O Desenvolvedor utiliza o método addChild da articulação criada no
passo 5 passando como parâmetro o objeto criado no passo 9;
11. A biblioteca adiciona o objeto criado no passo 9 à lista de objetos da a
articulação criada no passo 5;
12. O Desenvolvedor cria em seu aplicativo um botão que utiliza o
método move do objeto Dof criado no passo 5.
Pós-Condição
O dispositivo deve exibir dois objetos retangulares tridimensionais e um
botão que ao ser pressionado deve mover a articulação que conecta estes
dois objetos. Quadro 4 - Caso de uso UC05
3.3.2 Diagramas de classes
Nesta seção são descritas as classes necessárias para o desenvolvimento da biblioteca
de personagens articulados e do aplicativo que utiliza a biblioteca, o relacionamento entre elas
e as suas estruturas. Nos capítulos 3.3.2.1 e 3.3.2.2 estão sendo demonstradas as principais
27
classes que compõem a biblioteca e o aplicativo, respectivamente.
3.3.2.1 Biblioteca
As classes da biblioteca de personagens articulados são responsáveis por renderizar a
camada de OpenGL da tela e estão representadas na Figura 7.
Figura 7 - Principais classes da biblioteca
A primeira classe a ser utilizada por uma aplicativo é a Scene, que armazena uma
instância da interface GL10, que é por sua vez a porta de comunicação do desenvolvedor com
a implementação da especificação 1.0 da OpenGL ES. Scene também armazena listas das
classes Camera, Light e SceneNode e possui o método drawOGL, que desenha recursivamente
todos objetos, transformações e luzes que serão visualizados na tela do dispositivo.
A classe abstrata SceneNode é a base para tudo que é renderizado, como formas
(GraphicObj), transformações (Transform) e luzes (Light). Cada nodo pode possuir filhos,
28
formando uma hierarquia, vários nodos juntos compõem a cena. Estes nodos são renderizados
a cada ciclo através do método recursivo drawOGL, que chama o método drawInstanceOGL
para renderizar a si próprio e chama o método drawOGL de seus filhos para renderizar os
mesmos.
A classe abstrata GraphicObj é a base para objetos gráficos que possuem formas. Ela
armazena informações como visibilidade do objeto gráfico, a bounding box objeto, a
bounding box recursiva (que envolve o próprio objeto mais os seus filhos) e a forma que o
objeto deve ser desenhado. O método computeRecursiveBoundingBox calcula a bounding
box recursiva e o método getRecursiveBoundingBox retorna a mesma.
Uma de suas especializações de GraphicObj é a classe MeshObject, a representação
de um objeto gráfico feito de polígonos. O método makeBox é um facilitador para a criação de
objetos 3D retangulares e é utilizado na construção dos objetos visíveis no aplicativo descrito
no capítulo 3.3.2.2.
A classe Joint é a representação de articulações. Pode ser considerada um tipo
especial de transformação geométrica, lidando com a complexidade de articulações reais.
Joint possui uma lista da classe Dof em que sua ordem é importante. As transformações
feitas em um Dof influenciam os Dofs sucessores.
A classe Dof representa um grau de liberdade (do inglês degree of freedom) e é o
componente básico de uma articulação (Joint). Degree Of Freedom (DOF) é um eixo de
rotação que pode mover-se ao longo de uma curva 3D, possuindo esta rotação um alcance
limitado que pode mudar de acordo com elementos externos (VART DOCS, 2012).
Transform é a classe base de classe Joint e representa transformações geométricas.
Ela possui uma matriz de transformação que é aplicada aos seus objetos filhos.
3.3.2.2 Aplicativo
O diagrama da Figura 8 apresenta as principais classes do aplicativo e como elas
relacionam-se com as classes da API do Android.
29
Figura 8 - Principais classes do aplicativo
Ao utilizar o Android Development Tools (ADT) para criar um novo projeto, a
primeira classe que é criada pela própria Integrated Development Environment (IDE) é a
JointActionActivity, que está diretamente ligada à tela e é responsável por instanciar e
utilizar as demais classes, como a JointActionRenderer e GestureDetector e
GestureListener. A JointActionActivity descende diretamente da classe Activity, que
é uma classe disponibilizada pela API do Android e possui métodos que possibilitam a
comunicação com os componentes visuais de uma tela.
A classe JointActionRenderer implementa a interface Renderer que é responsável
por fazer chamadas OpenGL para renderizar um quadro. JointActionRenderer utiliza em
seu método de desenho de quadro onDrawFrame o método drawOGL da classe Scene, fazendo
com que toda a cena configurada pelo desenvolvedor seja renderizada.
A classe GestureListener é uma especialização da classe
SimpleOnGestureListener da API do Android e em seu método onScroll é chamado o
30
método rotate do JointActionRenderer, que faz a câmera girar de acordo com o
movimento de arrastar o dedo sobre a tela realizado pelo usuário.
GestureDetector é a classe que encapsula o JointActionRenderer. O método
onTouchEvent do JointActionActivity detecta qualquer toque que ocorra na tela, e nele, é
chamado o método onTouchEvent do GestureDetector, que internamente chamará o
método onScroll do GestureListener.
3.3.3 Diagrama de sequência
O diagrama de sequência da Figura 9 mostra a interação do Usuário com a aplicação de
personagem articulado do caso de uso UC01.
Figura 9 - Diagrama de sequência Mover articulações
Quando o Usuário acessa a aplicação, o sistema operacional invoca o método
onCreate da classe JointActionActivity que inicializará o conteúdo da aplicação. O
método onCreate cria uma nova instância da classe JointActionRenderer. O evento
onSurfaceChanged invoca o método initializeScene do JointActionRenderer que por
sua vez cria os DOFs utilizados na cena.
Quando o usuário toca na tela, o método onTouch da classe é invocado, que por sua
vez invoca o método moveDof do JointActionRenderer que finalmente invoca o método
move da classe Dof.
31
3.4 IMPLEMENTAÇÃO
A seguir são descritas as técnicas e ferramentas utilizadas na implementação, bem
como detalhes das principais classes e rotinas implementadas durante o desenvolvimento da
aplicação.
3.4.1 Técnicas e ferramentas utilizadas
O desenvolvimento da biblioteca de personagens articulados foi feito na linguagem
Java com a API de desenvolvimento do Android na versão 2.3.3, também chamada de
Gingerbread. O ambiente de desenvolvimento utilizado foi o Eclipse com o conjunto de
plugins do Android Development Tools (ADT), que possui uma série de recursos para criação,
execução e depuração de aplicações Android de forma a facilitar o desenvolvimento. Para a
execução e a depuração da aplicação também foi utilizado um dispositivo smartphone da
fabricante Samsung chamado Galaxy S que possui o sistema operacional Android 4.0.3,
também chamado de Ice Cream Sandwich.
O dispositivo Galaxy S possui processador Cortex-A8 com 1 Giga Hertz (GHz), sua
GPU é PowerVR SGX540, com memória de 512 Mega Bytes (MB) de RAM, 2 GB de Read
Only Memory (ROM) e resolução de 480x800 (GSM ARENA, 2012).
3.4.2 A aplicação
Esta seção descreve como criar a aplicação de personagem articulado descrita neste
trabalho. Como criar e configurar um novo projeto que utiliza a biblioteca e o uso da
biblioteca e suas classes.
3.4.2.1 Criação a configuração de um novo projeto
Para a criação de um novo projeto, foi utilizada a opção do ADT de novo projeto
Android, foi escolhido o nome Joint-Action para o novo projeto, como versão de
32
plataforma, selecionada a Software Development Kit (SDK) Android 2.3.3
Após ter o novo projeto criado, a biblioteca de personagens articulados deve ser
importada para o Eclipse. Para isto, deve ser utilizada a opção Import no menu File e
informado o caminho do projeto V-ART.
Para fazer o novo projeto utilizar a biblioteca, deve-se clicar com o botão direito do
mouse sobre o projeto e clicar em Properties. Será aberta a tela de configurações do projeto.
Na árvore de opções à esquerda, deve ser selecionada a opção Android, clicado no botão
Add... e adicionado o projeto V-ART, que aparecerá na lista de projetos do tipo Library. Ao
clicar no botão OK, o projeto estará pronto para utilizar a biblioteca de personagens
articulados.
3.4.2.2 Estrutura de classes da aplicação e utilização da biblioteca
A aplicação possui classes estendidas da API do Android e classes utilitárias para
calcular e desenhar na tela Frames Per Second (FPS) como demonstrado na Figura 10.
Figura 10 - Estrutura de classes da aplicação
As classes contidas no pacote br.furb.jointaction.util são responsáveis pelo
FPS. Numbers é uma enumeração que contém números de 0 a 9 e as coordenadas para
desenhar cada um destes números. NumberDrawer é a classe que utiliza a enumeração
Numbers para desenhar na tela um número que recebe em seu método estático draw.
FpsCalculator possui o método calculateFps que deve ser utilizado na iteração principal
da aplicação OpenGL e recebe como parâmetro o tempo atual em milissegundos e calcula o
FPS atual e a média dos últimos 100 quadros. O uso deste pacote pode ser observado no
método onDrawFrame da classe JointActionRenderer, demonstrado no Quadro 5.
33
Quadro 5 - Iteração principal da aplicação
A classe JointActionActivity é a primeira classe a ser criada juntamente ao projeto,
é responsável pela tela da aplicação, configurada no arquivo main.xml (Quadro 6). Nela é
feita a instanciação das classes JointActionRenderer e GestureListener (Quadro 7).
O arquivo XML demonstrado no Quadro 6 possui informações sobre cada componente
presente na tela. O primeiro item LinearLayout é recipiente mais externo. O segundo item
LinearLayout é o recipiente dos botões visualizados na aplicação. Os itens Button
representam cada um dos botões que disponibilizados. O item
android.opengl.GLSurfaceView é o quadro onde é desenhada a cena através do OpenGL
ES.
34
Quadro 6 - Arquivo main.xml
Quadro 7 - Instanciação das classes GestureDetector e JointActionRenderer
35
A classe JointActionRenderer estende da classe Renderer da API do Android. Em
seu método onDrawFrame recebe a interface GL10 como parâmetro, que como explicado no
capítulo 3.3.2.1, é a interface de comunicação com o OpenGL. Nesta classe ocorrem as
chamadas à biblioteca de personagens articulados, que utiliza diretamente a interface GL10. É
responsável por desenhar o personagem articulado e utilizar as classes de cálculo de FPS
(Quadro 5).
O método initializeScene é onde ocorre a criação da cena, câmera, luz, objetos e
articulações (Quadro 8). Ao instanciar a classe Camera, são passados três pontos como
parâmetros, sendo eles posição da câmera no espaço 3D, foco, que é a direção que a câmera
estará apontada e o último indica qual eixo aponta para cima.
Quadro 8 - Método initializeScene da classe JointActionRenderer
Os métodos createBase, createArm1, createArm2 e createArm3 são responsáveis
pela criação dos objetos tridimensionais visualizados na tela e pelas articulações que os
movem. Como observado no Quadro 9, o objeto base é inserido diretamente na lista de
objetos da cena e a articulação base inserida na lista de objetos do objeto base. O objeto arm1
do método createArm1 é inserido na lista de objetos da articulação base e assim por diante. A
classe UniaxialJoint representa uma articulação com apenas um grau de liberdade, a
biblioteca também disponibiliza as classes BiaxialJoint e PolyaxialJoint, que são
articulações com dois e três graus de liberdade respectivamente. O método addDof recebe
como parâmetros dois pontos que juntos definem o eixo de rotação de um DOF e os ângulos
mínimo e máximo de rotação. O método addNode adiciona o objeto criado a uma lista e seus
DOFs a um mapa, para controle de tela.
36
Quadro 9 - Criação dos objetos tridimensionais e suas articulações
Ao executar a aplicação no simulador, é exibida a tela com os botões, o FPS atual e a
média dos últimos 100 quadros e o personagem articulado, como demonstrado na Figura 11.
37
Figura 11 - Aplicação rodando no simulador
Os botões localizados na primeira fileira possuem funções de seleção e movimentação:
a) Sel Obj - alterna o objeto selecionado entre a base, em cinza, e os três segmentos
verdes localizados acima da base. O contorno branco ao redor da base, indica que
este é o atual objeto selecionado;
b) Sel DOF - seleciona o próximo DOF da articulação do objeto selecionado, sendo
que cada um dos objetos visualizados, com exceção do objeto localizado na ponta,
possui três DOFs;
c) < DOF e DOF > - fazem a movimentação do DOF selecionado.
O botões da segunda fileira possuem funções de renderização:
a) Light - ativa e desativa a utilização de luzes pelo OpenGL;
b) Objs - ativa e desativa a visibilidade dos objetos;
c) BBox - ativa e desativa a visibilidade da bounding box dos objetos;
38
d) Rec BBox - ativa e desativa a visibilidade da bounding box recursiva dos objetos.
Ao selecionar o primeiro segmento verde pressionando uma vez o botão Sel Obj e
pressionar várias vezes o botão DOF >, pode ser observada a sequência demonstrada na Figura
12.
Figura 12 - Sequência de movimentação de um DOF
A Figura 13 demonstra o efeito visual ocorrido ao pressionar cada um dos botões da
segunda fileira.
Figura 13 - Efeito visual dos botões da aplicação
39
3.4.3 Aplicação para testes de desempenho
A partir da aplicação demonstrada no capítulo 3.4.2, foi criada uma aplicação para
testes de desempenho. Nesta nova aplicação foram removidos os botões de controle do
personagem e adicionado controle de tempo na renderização da cena.
Foi também adicionada uma nova tela que é responsável por inicializar a tela de testes
e exibir os resultados obtidos na execução de cada teste. Como observado na Figura 14, esta
nova tela possui dois botões. Start Obj Test executa a sequência do teste de quantidade de
nodos, enquanto Start DOF Test executa a sequência do teste de quantidade de DOFs.
Figura 14 - Tela principal da aplicação de testes
Ao pressionar o primeiro botão, o teste executa uma lista de combinação de quantidade
de nodos com quantidade de DOFs, configurada no próprio código fonte. A Figura 15
demonstra a sequência de execução do teste de quantidade de nodos.
40
Figura 15 - Sequência de execução do teste de quantidade de nodos
Ao fim da execução de uma sequência de testes, a aplicação volta a exibir a tela inicial
com os resultados da média de tempo em milissegundos de cada um dos testes. A Figura 16
demonstra esta tela rodando no dispositivo real.
41
Figura 16 - Tela principal da aplicação de testes com resultados
3.5 RESULTADOS E DISCUSSÃO
O presente trabalho teve como objetivo inicial portar a biblioteca Virtual Articulations
for Virtual Reality (V-ART), desenvolvido em C++ para Java Android. Uma biblioteca de
personagens articulados que disponibilize a importação de personagens 3D e suas animações
através de um arquivo XML e um aplicação que utiliza esta biblioteca. Algumas
funcionalidades não foram transcritas, como a importação de um personagem através de um
arquivo XML, o correto funcionamento de luzes e texturas (Figura 13) e formas geométricas
diferentes de cubos.
Ao realizar a transcrição, a primeira dificuldade encontrada foram as diferenças entre
as linguagens C++ e Java Android, sendo a primeira utilizada para implementar o V-ART.
Além da diferença de linguagem, também existem diferenças entre as versões da biblioteca
42
Open Graphic Library (OpenGL). A versão para Android chama-se OpenGL for Embedded
Systems (OpenGL ES) e possui algumas mudanças para a versão desktop, como a remoção
das funções utilizadas pelo V-ART glBegin e glEnd para desenhar primitivas, dando vez a
vertex arrays.
Foram desenvolvidas classes para a exibição de Frames Per Second (FPS). Para exibir
a taxa de FPS atual e a taxa média dos últimos 100 quadros, foi necessário implementar
funções para desenhar os números na tela, pois a biblioteca OpenGL não disponibiliza
funcionalidades para desenho de números e textos.
Durante o desenvolvimento do aplicativo que utiliza a biblioteca, o simulador do
Android, disponibilizado no Android Development Tools (ADT), praticamente não foi
utilizado, devido ao seu baixo desempenho comparado ao dispositivo real.
3.5.1 Resultados obtidos nos testes de desempenho e memória
Para a medição de desempenho deste trabalho foi calcular o tempo que o método
drawOGL da classe Scene leva para executar e a quantidade teórica de memória consumida.
3.5.1.1 Testes de desempenho
Para os testes de desempenho, foram utilizados dois cenários, sendo o primeiro
variando a quantidade de objetos desenhados na tela e o segundo variando a quantidade de
DOFs das articulações. Os testes foram executados apenas no dispositivo real, devido à
grande deficiência de desempenho do simulador. A Tabela 1 demonstra o teste de quantidade
de nodos rodado três vezes e a média entre eles.
Quantidade de Nodos Teste 1 Teste 2 Teste 3 Média
1 4,15 3,82 3,51 3,83
2 4,23 3,82 3,59 3,88
4 7,08 6,01 6,34 6,48
8 9,96 9,64 10,67 10,09
16 8,62 10,37 9,89 9,63
32 12,24 11,16 11,50 11,63
64 20,85 18,93 18,70 19,49
128 38,01 36,39 34,82 36,41 Tabela 1 - Resultados de quantidade de nodos
43
Para este teste, foi obtida a média de tempo em milissegundos de 100 quadros. A
última coluna mostra média entre os três testes. Observando o quadro, percebe-se que o tempo
para gerar um quadro contendo entre 8 e 32 nodos é altamente influenciado por funções
secundárias do próprio sistema operacional, fazendo com que aconteçam anomalias como a
vista no teste 1, onde o tempo com 8 nodos é maior que com 16 nodos.
A Figura 17 exibe graficamente o comportamento dos testes e deixa ainda mais claro
como o sistema operacional influencia os testes.
Figura 17 - Gráfico de quantidade de nodos
Para o teste de quantidade de DOFs, foram utilizados 64 nodos, variando de 1 a 3
DOFs. A Tabela 2 demonstra os resultados obtidos.
Quantidade de DOFs Teste 1 Teste 2 Teste 3 Média
1 21,64 19,51 20,15 20,43
2 21,33 19,43 22,12 20,96
3 20,38 19,92 21,63 20,64
Tabela 2 - Resultados de quantidade de DOFs
Este teste foi executado da mesma forma que o teste de quantidade de nodos. Pode-se
observar na Tabela 2 que a quantidade de DOFs não influencia no desempenho da
renderização da cena. A Figura 18 demonstra o quadro graficamente.
44
Figura 18 - Gráfico de quantidade de DOFs
3.5.1.2 Memória
A medição de memória demonstrada a seguir foi feita de forma teórica, somando a
quantidade de bytes utilizados por cada objeto (Apêndice A) em dois cenários diferentes,
sendo no primeiro variando a quantidade de nodos e no segundo variando a quantidade de
DOFs.
No uso do OpenGL ES, alguns métodos recebem como parâmetro instâncias de
FloatBuffer e ByteBuffer. Estas duas classes são construídas através de vetores de float e
byte, respectivamente. Para os cenários a seguir, foi assumido que o tamanho de instâncias
destas classes é o mesmo do próprio vetor que foi utilizado na construção das mesmas.
O cenário com variação de quantidade de nodos é demonstrado na Figura 19.
Figura 19 - Memória utilizada para quantidade de nodos
Observando o gráfico, nota-se que o aumento de uso de memória é constante de acordo
com a quantidade de novos nodos inseridos, ou seja, é uma progressão aritmética.
45
A Figura 20 demonstra o gráfico com a variação de DOFs. Neste cenário, é
considerada a inserção de apenas um nodos com variação da quantidade de DOFs.
Figura 20 - Memória utilizada para quantidade de DOFs
Da mesma forma que a variação da quantidade de nodos, a variação da quantidade de
DOFs forma uma progressão aritmética.
3.5.2 Classes convertidas
O Quadro 10 demonstra as classes originais do V-ART no momento do
desenvolvimento deste trabalho. As classes convertidas estão representadas por um círculo ao
lado esquerdo do nome da classe, as demais estão representadas pelo ícone de um arquivo.
46
Quadro 10 - Classes convertidas do V-ART
47
4 CONCLUSÕES
Este trabalho apresentou uma biblioteca de personagens articulados, uma aplicação que
utiliza esta biblioteca e um aplicação de testes de desempenho. Como objetivo inicial, foi
proposto transcrever o projeto V-ART desenvolvido em C++ para Java Android. A
importação de um personagem e suas animações através de um arquivo XML e formas
geométricas não retangulares não foram implementadas. Luzes e texturas foram transcritas
mas não estão funcionando corretamente.
A biblioteca desenvolvida diferencia-se dos trabalhos correlatos por possuir controle
exato de cada DOF das articulações dos personagens. O trabalho de Pereira (2010) também
foi desenvolvido utilizando a biblioteca OpenGL ES. É um aplicativo de importação de
personagens e suas animações, não disponibilizando edição do próprio personagem ou de sua
animação.
Catcake (2011) é um motor disponível para Windows, Linux Android com mais
funcionalidades, como detecção de colisões e reprodução de animações e sons.
O resultado dos testes demonstra que a biblioteca possui um desempenho bastante
satisfatório para o dispositivo utilizado. Com 128 objetos renderizados na tela, sendo cada um
com uma articulação com um grau de liberdade, ainda obteve-se a média de 27 quadros por
segundo, que é suficiente para o olho humano não perceber a troca de quadros. No teste de
desempenho com quantidade de DOFs, pode-se observar que mesmo aumentando a
quantidade de DOFs em 64 nodos, não houve impacto no desempenho.
Os cálculos de uso de memória demonstram que o aumento da quantidade de nodos ou
de DOFs formam progressões aritméticas. O consumo de memória demonstrou-se adequado,
considerando que 12 nodos ocupam apenas 11.238 bytes, ou 10,97 Kilo Bytes (KB). Seguindo
esta progressão, para montar a cena do teste de desempenho com 128 nodos, seriam utilizados
10.7634 bytes da memória, ou 105,11 KB. O dispositivo utilizado no desenvolvimento possui
512 Mega Bytes (MB) de Random Access Memory (RAM), portanto, a memória utilizado pelo
aplicativo é muito pequena, mesmo para dispositivos com menos RAM disponível.
O desenvolvimento para a plataforma Android demonstrou-se bastante intuitivo para
quem já está acostumado com o desenvolvimento em Java e com o Eclipse IDE. Deixou a
desejar apenas com relação ao simulador, que possui um desempenho baixo à nível de tornar-se
inviável.
48
4.1 EXTENSÕES
Como sugestões de extensões para a continuidade do presente trabalho, tem-se:
a) transcrever classes pertinentes do V-ART para utilizar um personagem humanoide;
b) transcrever classes para o desenho de formas geométricas além de formas
retangulares, como esferas, cilindros e triângulos;
c) utilizar a biblioteca OpenGL ES 2.0 para renderização da cena;
d) adicionar a importação de um arquivo XML que contenha personagens e suas
animações;
e) implementar o correto uso de luzes, cores e texturas.
49
REFERÊNCIAS BIBLIOGRÁFICAS
ANDROID DEVELOPERS. Android virtual devices. [S.l.], 2012a. Disponível em:
<http://developer.android.com/guide/developing/tools/avd.html>. Acesso em: 11 nov. 2010.
______. Installing the SDK. [S.l.], 2012b. Disponível em:
<http://developer.android.com/sdk/installing.html>. Acesso em: 02 nov. 2010.
AULAS FISIO. Anotações das Aulas de Fisioterapia: Biomecânica - graus de liberdade.
[S.l], 2012. Disponível em: <http://aulasfisio.blogspot.com.br/2008/09/graus-de-
liberdade.html> Acesso em: 21 jul. 2012.
BLACKBERRY. BlackBerry - smartphones. [S.l.], 2011. Disponível em:
<http://br.blackberry.com/ >. Acesso em: 30 out. 2011.
CATCAKE. An open source graphics engine. [S.l.], 2011. Disponível em:
<http://code.google.com/p/catcake>. Acesso em: 16 out. 2011.
DOF. In: WIKIPÉDIA, a enciclopédia livre. [S.l.]: Wikipedia Foundation, 2011. Disponível
em: <http://en.wikipedia.org/wiki/Degree_of_freedom_(mechanics)>. Acesso em: 21 jul.
2011.
GOOGLE. 3D with OpenGL. [S.l.], 2011a. Disponível em:
<http://developer.android.com/guide/topics/graphics/opengl.html>. Acesso em: 29 ago. 2011.
______. Tech specs - Nexus S. [S.l.], 2011b. Disponível em:
<http://www.google.com/nexus/#/tech-specs>. Acesso em: 13 set. 2011.
______. What is Android? [S.l.], 2011c. Disponível em:
<http://developer.android.com/guide/basics/what-is-android.html>. Acesso em: 29 ago. 2011.
GSM ARENA. Samsung I9000 Galaxy S - full phone specifications. [S.l.], 2012. Disponível
em: <http://www.gsmarena.com/samsung_i9000_galaxy_s-3115.php>. Acesso em: 29 abr.
2012.
IOS. Apple - iOS 5 - 200+ new features for iPad, iPhone, and iPod touch. [S.l.], 2011.
Disponível em: <http://www.apple.com/br/ios/>. Acesso em: 30 out. 2011.
KHRONOS GROUP. OpenGL ES - the standard for embedded acelerated 3D graphics.
[S.l.], 2011a. Disponível em: <http://www.khronos.org/opengles/>. Acesso em: 29 ago. 2011.
______. OpenGL ES 2_X. [S.l.], 2011b. Disponível em:
<http://www.khronos.org/api/opengles/2_X/>. Acesso em: 07 set. 2011.
50
MAVERIK. The advanced interfaces group. [S.l.], 2011. Disponível em:
<http://aig.cs.man.ac.uk/maverik/maverik.php>. Acesso em: 13 set. 2011.
MIDIAARTE. Especificação e controle de movimento. [S.l.], 2002. Disponível em:
<http://www.eba.ufmg.br/midiaarte/projetos/maluquinho/06.htm>. Acesso em: 07 set. 2011.
NINTENDO 3DS. Nintendo 3DS - official website at Nintendo. [S.l.], 2002. Disponível em:
<http://www.nintendo.com/3ds>. Acesso em: 30 out. 2011.
OPEN INVENTOR. [S.l.], 2011. Disponível em: <http://oss.sgi.com/projects/inventor/>.
Acesso em: 13 set. 2011.
PEREIRA, Felipe S. Visualizador de animação 3D com suporte ao formato FBX em
Objective-C++. 2010. 48 f. Trabalho de Conclusão de Curso (Bacharelado em Ciência da
Computação) - Centro de Ciências Exatas e Naturais, Universidade Regional de Blumenau,
Blumenau.
______. Visualizador de animação 3D com suporte ao formato de arquivos FBX em
Objective-C++. [S.l.], 2011. Disponível em:
<http://www.youtube.com/watch?v=QkgiL39KrB0>. Acesso em: 13 set. 2011.
PLIB. PLIB: a portable games library. [S.l.], 2011. Disponível em:
<http://plib.sourceforge.net/>. Acesso em: 13 set. 2011.
SHADER. In: WIKIPÉDIA, a enciclopédia livre. [S.l.]: Wikipedia Foundation, 2011.
Disponível em: <http://pt.wikipedia.org/wiki/OpenGL>. Acesso em: 18 set. 2011.
SISTEMA ARTICULAR. Articulações. [S.l], 2012. Disponível em:
<http://www.icb.ufmg.br/mor/anatoenf/sistema_articular.htm> Acesso em: 21 jul. 2012.
SYMBIAN. Symbian at Nokia. [S.l.], 2011. Disponível em: <http://symbian.nokia.com/>.
Acesso em: 30 out. 2011.
THALMANN, Nadia M.; THALMANN, Daniel. Computer animation theory and practice.
2nd ed. Tokyo: Springer-Verlag, 1990.
VART. V-ART: Virtual ARTiculation for virtual reality. [S.l.], 2011. Disponível em:
<http://vart.codeplex.com>. Acesso em: 28 ago. 2011.
VART DOCS. V-ART: VART - Dof class reference. [S.l.], 2012. Disponível em:
<http://algol.dcc.ufla.br/~bruno/v-art/docs/html/classVART_1_1Dof.html>. Acesso em: 30
maio 2012.
51
VPAT. Previous projects on computer graphics, visualization and interaction. [S.l.],
2011. Disponível em:
<https://wiki.inf.ufrgs.br/Previous_Projects_on_Computer_Graphics,_Visualization_and_Inte
raction>. Acesso em: 31 out. 2011.
VRJUGGLER. The VR Juggler suite. [S.l.], 2011. Disponível em:
<http://www.vrjuggler.org/>. Acesso em: 13 set. 2011.
52
APÊNDICE A – Cálculos de memória
O Quadro 11 demonstra os valores em bytes dos tipos primitivos da linguagem de
programação Java utilizados nos cálculos de uso de memória.
Tipo Tamanho em bytes
int 4
float 4
long 8
double 8
enum 4
pointer 4
byte 1
boolean 1 Quadro 11 - Memória ocupada pelos tipos primitivos em Java
O Quadro 12 apresenta as classes utilizadas na construção de uma cena, seus tamanhos
em memória e fórmulas utilizadas para obter o tamanho. O Quadro 12 utiliza o Quadro 11
para o tamanho dos tipos primitivos.
Classe Tamanho em bytes
Fórmula
Point4D 24 pointer + arraySize(float, 4)
Camera 168 pointer + 8 * float + enum + 3 * Point4D + stringSize(6)
Color 20 pointer + 4 * int
BoundingBox 197 pointer + Color + boolean + 6 * float + Point4D + arraySize(float, 24) + arraySize(byte, 20)
SceneNode 64 pointer + stringSize(6) + pointer
GraphicObj 399 2 * BoundingBox + boolean + enum
MeshObject 547 pointer + arraySize(float;24) + arraySize(Mesh;1)
Mesh 44 pointer + arraySize(byte;36)
Material 88 pointer + 4 * Color + float
Transform 200 SceneNode + 2 * arraySize(float;16)
Light 317 SceneNode + Point4D + 2 * float + Color + boolean + Transform
Scene 719 arraySize(Camera;1) + pointer + arraySize(Light;1) + pointer + Color + BoundingBox + boolean
Dof 276 pointer + 3 * float + 2 * Point4D + Transform + pointer + long
Joint 8 pointer * 2 Quadro 12 - Memória ocupada pelas classes da biblioteca
O Quadro 13 apresenta a fórmula que calcula o tamanho total de um cenário de acordo
com os parâmetros recebidos.
53
Quadro 13 - Fórmula de um cenário
![[FLISOL] Android Faixa Branca (Iniciando no Android) – 2013](https://img.document.onl/doc/110x75/5404d97c8d7f72a6768b48b2/flisol-android-faixa-branca-iniciando-no-android-2013.jpg)
