 |
1. Introdução: Uma visão geral
Basicamente, idéia do projeto foi a criação de uma ferramenta, um programa, que representasse um modelo do Sistema Solar. Este modelo deverá possuir uma maneira simples para o usuário visualizar o Sistema Solar, assim como permitir que ele interaja com ele. Tanto a visualização quanto a interação devem ser simples e claras para o usuário, facilitando o entendimento e aprendizado do sistema.
Também foi pensada a possibilidade de exibição de informações sobre o sistema e também sobre seus componentes. Estas acabaram sendo implementadas na forma de informações sobre os planetas do sistema. Estas informações são exibidas apenas com uma solicitação do usuário, deixando-o com uma interface limpa, do contrário certamente prejudicaria a visualização do modelo. Maiores detalhes são comentados na seção de Implementação abaixo.
Também foi pensada a possibilidade de exibição de informações sobre o sistema ou sobre os componentes deste.
Estas acabaram sendo implementadas na forma de informações sobre os planetas do sistema. Estas informações são
exibidas apenas com uma solicitação do usuário, evitando o excesso de informações na tela, o que certamente
prejudicaria a visualização do modelo. Maiores detalhes são comentados na seção de Implementação abaixo.
2. Implementação: Ferramentas utilizadas
O programa foi concebido para rodar sob a plataforma windows.A linguagem utilizada foi A C++ com a API gráfica OpenGL e a IDE Dev-C++
Foram utilizados, basicamente, 2 tipos de elementos:
- Corpo celestial: Representa um corpo celestial qualquer, o que engloba o Sol, todos os planetas e as luas do sistema. Este elemento é representado pela classe CPlaneta.
- Sistema Solar: Representa o Sistema Solar em si. Este elemento possui diversos atributos
que são utilizados para manipulação do sistema.
Este elemento é representado pela classe CSistemaSolar.
3. Implementação: As etapas
1º Etapa:
A primeira etapa foi a criação das classes a serem utilizadas no programa. A primeira classe feita foi a CPlaneta.
Esta classe possui os diversos atributos que são necessários para a representação de um corpo celestial. Como exemplo
podem ser citados o raio, a velocidade de rotação em torno de seu eixo e na órbita, o nome do corpo, a textura utilizada,
entre outros.
Os métodos interessantes de serem citados desta classe são o método Desenha() e DesenhaOrbita().
Como o próprio nome diz, são os métodos que desenham o corpo na tela. O método Desenha é o maior e certamente mais
importante da classe. Ele faz toda a atualização da posição do corpo no espaço e o desenha na tela.
Este método faz a atualização tanto do corpo ao qual ele pertence, quanto de todos os corpos "filhos" deste.
Estes corpos chamados "filhos" são todos aqueles que são dependentes do corpo "pai", todos que giram em torno deste.
O sistema todo é baseado neste conceito, onde temos o Sol como o pai, e todos os planetas como filhos dele. Diversos planetas
possuem luas, que por sua vez são filhas destes planetas. Portanto a chamada da função Desenha é feita apenas uma vez, para o corpo
que representa o Sol. Com esta chamada todos os filhos serão atualizados.
A função DesenhaOrbita funciona basicamente da mesma maneira, exceto que ela desenha as órbitas dos corpos e não os corpos.
A órbita desenhada é a linha que representa o movimento que o corpo faz ao redor do corpo de seu pai. Esta facilita bastante a
visualização da distância, posição, velocidade, e outros atributos dos planetas.
A outra classe feita foi a classe CSistemaSolar. Como dito anteriormente, esta classe representa o
sistema em si. Ela possui atributos como o corpo atualmente selecionado (é possível a seleção de
corpos clicando com o mouse), os modificadores de escala, os indicadores das posições do mouse, entre outros.
2º Etapa:
A próxima etapa foi a criação do esqueleto do programa principal, que utiliza as classes citadas acima. Este
está no arquivo de nome Principal.cpp. Inicialmente foi criado o Sol e alguns planetas ao seu redor, sem levar
em conta nenhum dado real destes planetas.
Esta foi uma fase praticamente de teste das classes feitas na primeira etapa. Após vários teste e tentativas,
tudo acabou funcionando corretamente. Os planetas estavam sendo exibidos corretamente, girando em torno de seu
eixo e em sua órbita, com suas respectivas texturas, assim como as órbitas estavam sendo desenhadas corretamente.
Após as classes estarem testadas e funcionando corretamente, foi iniciada a etapa número 3.
3º Etapa:
Tendo em mãos um pequeno sistema já funcionando corretamente, foi iniciada uma etapa de implementação
de uma parte do sistema de interação com o usuário, a navegação pelo sistema.
Inicialmente foram definidos os métodos que seriam utilizados para a navegação. Era desejado
que tanto o teclado quanto o mouse pudessem ser utilizados. Foram definidas as teclas e botões e suas
respectivas funções e então foi iniciada a implementação.
Primeiro foram tratados os movimentos de translação (ir para a frente, para trás, para os lados, etc) feito
através do teclado. Foram tratados os eventos do teclado chamando as funções que realizam as translações
dependendo da tecla pressionada. Asseguir foi implementado o movimento de rotação feito através do teclado.
Este sistema de rotação é bastante semelhante ao de translação, com apenas alguns detalhes diferentes.
A parte mais complicada desta etapa foi a implementação do movimento de rotação utilizando o mouse.
Foram pensados alguns métodos de ser feito este movimento, porém nenhum acabava sendo simples e
eficiente como desejávamos. O método escolhido (descrito na seção 4.Utilizando o programa) acabou
sendo talvez o mais fácil de utilizar.
Definido como seria tratado o movimento do mouse, foi iniciada a implementação. Não foi nada tão
complexo mas com certeza não é tão simples como o tratamento do teclado. Para o mouse devem ser
armazenadas as posições em que ele estava quando foi clicado, qual botão foi clicado, quando ele
foi solto, etc. Após finalizada a implementação o resultado foi bastante satisfatório, trazendo uma
boa interatividade com o uso do mouse.
4º Etapa:
A quarta etapa foi outra etapa de interação com o usuário, a de exibição das informações sobre os corpos.
Assim como na parte de navegação, primeiro foi definido o modo em que as informações seriam solicitadas
e exibidas e então partiu-se para a implementação. O método escolhido pode ser visto em 4. Utilizando o programa.
Para fazer com que os corpos e órbitas na tela fossem "clicáveis" foi necessário um bom tempo de consulta
no Google :). Foram encontrados alguns bons exemplos que levaram à implementação do sistema que utilizamos agora,
que é bastante funcional.
Tendo uma maneira de clicar no objetos na tela, foi implementado o sistema de seleção dos corpos e órbitas, ou seja,
a mudança de cor da órbita ao ser selecionada, o cubo ao redor do corpo selecionado, a exibição da janela de informações,
e todos os outros passos necessários.
Assim que tudo estava funcionando corretamente, foi criado o arquivo contendo as informações a serem exibidas (Dados.h)
e nele foram inseridas as informações mais relevantes sobre o Sol e os planetas do sistema.
5º Etapa:
A quinta etapa consistiu em tornar o sistema mais real, mais parecido com o Sistema Solar como ele realmente é.
Para esta etapa foram criados o Sol e os 9 planetas que o rodeiam. Para todos foram inseridos dados reais, como raio,
velocidade de rotação, distância da órbita, etc.
Obviamente o modelo deve ser representado milhares de vezes melhor que o sistema real, e para isso foi realizada
a próxima etapa.
6º Etapa:
Para representar os corpos de uma maneira fácil de visualização e identificação na tela, foram criadas as escalas.
Foram criadas 3 escalas diferentes:
- Tamanho: uma escala para redução do tamanho real do raio dos corpos
- Distância: uma escala para redução da distância entre os corpos no sistema
- Velocidade: uma escala para redução da velocidade de rotação dos corpos em seu eixo e na órbita
Fica claro que com uma escala diferente para o tamanho e a distância entre os corpos, não haverá
uma equivalência real entre estas duas grandezas no sistema. Porém foi testada a utilização de apenas uma escala,
mas o sistema acabava ficando ou com corpos ínfimos para as distâncias ficarem visíveis, ou com corpos de tamanhos
satisfatórios porém distâncias enormes que não possibilitavam a fácil visualização de todos os corpos.
Depois de criado o sistema de escalas, foi criado um modo de exibí-las ao usuário. Para isso foi
feito um menu no canto direito superior da tela que exibe as três escalas com seus valores atuais.
Então partimos para mais uma etapa de interação com o usuário.
7º Etapa:
A interação com o usuário nesta etapa consiste na possibilidade de mudança das 3 escalas existentes.
Foi definida a forma com que as escalas seriam alteradas e então foi iniciada a implementação. Foi um processo
bastante simples, visto que o sistema de escala já estava feito, então bastava tratar os eventos do teclado
e modificar os valores das escalas conforme a tecla pressionada. Também foi feito o método de atualização
do menu que exibe as escalas para que ele possa exibir o valor exato da escala atual e também qual
escala está selecionada para modificação.
Essas mudanças de escala permitem que o usuário deixe o sistema mais agradável para visualização daquilo que
ele busca, o que as torna uma parte importante da interação com o usuário neste sistema.
8º Etapa:
A oitava, e última, etapa foi a etapa dos ajustes finais no programa. Entre os ajustes finais
estão a definição visual das janelas exibidas (de informações e das escalas), a colocação
da Lua ao redor da Terra, a definição das texturas corretas para os planetas, outros
diversos ajustes visuais e algumas mudanças para melhora do código.
Esta etapa foi uma etapa mais simples de ser feita porém não menos demorada. Tendo todo
o código pronto e funcionando os últimos ajustes eram fáceis de fazer. Esta etapa, porém, precisou
de um grande espaço de tempo para ser feita. Os ajustes visuais são normalmente demorados
assim como a definição das texturas para cada planeta. Finalizada esta etapa, o programa
ficou completo e pronto para o uso ;).
Ps: Obviamente o programa não estava completamente pronto. Fazer uma representação do Sistema
Solar 100% completa e correta é praticamente impossível, tendo em mente a enormidade
que o sistema representa e inclusive por ele possuir muitos elementos ainda desconhecidos
ou não bem definidos. Porém finalizamos o programa assim que os objetivos definidos
foram alcaçados.
4. Utilizando o programa
Nesta seção será explicado como utilizar o programa, os comandos e funções existentes,
os itens que podem ser vistos na tela, etc. Não será explicado aqui como compilar ou rodar
o programa, mas sim como utilizá-lo partindo do princípio de que ele já está em execução.
As janelas:
O primeiro item a ser explicado são as janelas existentes no programa. Logo ao iniciá-lo, você
verá a grande janela principal do programa (onde estão os planetas, órbitas, etc) e uma
pequena janela ou menu na parte superior direita da tela, que é a janela de escalas.
Além destas janelas existe também a janela de informações que é exibida na parte esquerda
superior da tela quando um corpo é selecionado.
A janela principal é a grande janela do programa onde estão todos os componentes deste. Não
há muito o que explicar sobre esta.
A janela de escalas contém a descrição das escalas que estão sendo usadas atualmente no
programa. Existem 3 escalas: tamanho, distância e velocidade. A escala de tamanho indica
a correspondência entre o tamanho dos corpos na tela e no sistema real; a escala de distância
indica a correspondência entre a distância entre os corpos na tela e no sistema real; e a
escala de velocidade determina a relação entre a velocidade do tempo na tela e no sistema
real. O item marcado em amarelo é aquele que está selecionado para alterações.
Nesta janela há ainda o indicador da velocidade do movimento. Este correponde à velocidade
com que é feito o movimento da camera no sistema, utilizando as teclas de navegação
que serão descritas mais adiante.
A outra janela existente é a janela de informações. Esta janela aparece assim que um
corpo é selecionado na tela. Como o nome diz, ela é utilizada para exibir as informações
do corpo selecionado. Para fechá-la basta clicar em cima dela com o botão esquerdo do mouse.
Os comandos do teclado:
Existem diversos comandos que utilizam o teclado. Eles serão explicados utilizando a tabela
abaixo, que contém a tecla a ser pressionada e o comando que ela realiza. Estes comandos
estão divididos em 3 grupos: movimentação, rotação e outros.
|
Movimentação
|
| W |
|
Movimenta a camera para a frente |
| S |
|
Movimenta a camera para trás |
| A |
|
Movimenta a camera para a esquerda |
| D |
|
Movimenta a camera para a direita |
| Q |
|
Movimenta a camera para cima |
| E |
|
Movimenta a camera para baixo |
| |
|
Rotação
|
| I |
|
Gira a camera para a frente em torno do eixo x |
| K |
|
Gira a camera para trás em torno do eixo x |
| J |
|
Gira a camera para a esquerda em torno do eixo y |
| L |
|
Gira a camera para a direita em torno do eixo y |
| U |
|
Gira a camera no sentido horário |
| O |
|
Gira a camera no sentido anti-horário |
|
|
Outros
|
| F |
|
Liga/Desliga o modo em tela cheia (padrão: desligado) |
| T |
|
Liga/Desliga a exibição do nome dos corpos sobre eles (padrão: desligado) |
| . |
|
Liga/Desliga a exibição da órbitas (padrão: ligado) |
| Z |
|
Seleciona a escala dos tamanhos para modificação |
| X |
|
Seleciona a escala das distâncias para modificação |
| C |
|
Seleciona a escala da velocidade para modificação |
| + |
|
Aumenta a escala selecionada atualmente |
| - |
|
Dimunui a escala selecionada atualmente |
| N |
|
Diminui a velocidade do movimento da camera em 0.1 |
| M |
|
Aumenta a velocidade do movimento da camera em 0.1 |
| 1 |
|
Altera as escalas de tamanho e distância para um padrão pré-definido |
| 2 |
|
Altera as escalas de tamanho e distância para um segundo padrão pré-definido |
Utilizando o mouse:
O mouse pode ser utilizado para 2 propósitos no programa: selecionar os corpos ou
rotacionar a tela.
A seleção dos corpos é feita clicando, com o botão esquerdo, sobre ele ou sobre sua órbita.
Assim que um corpo
for selecionado, será exibida sua janela de informações, sua órbita ficará destacada em
azul e será colocado um cubo ao redor do corpo. Para fechar a janela de informações basta clicar
sobre ela. Para retirar a seleção de um corpo, basta clicar sobre outro corpo ou sobre um lugar
qualquer no espaço.
A rotação na tela é feita utilizando o botão direito do mouse. Pressione com o botão direito
do mouse em algum local da tela e arraste-o para outra posição, sem soltar o mouse. Conforme
a posição para qual o mouse foi arrastado, será definida a direção de rotação.
A velocidade da rotação é definida pela distância do mouse onde ele foi clicado
e para onde ele foi arrastado. Se, por exemplo, o mouse foi arrastado por x pixels e
neste caso a velocidade do movimento for y, então se ele for arrastado por qualquer
número de pixels maior que x, a velocidade será maior que y e a camera será
rotacionada mais rapidamente. A rotação só para de ser feita assim que o botão do mouse
for solto.
5. Screenshots: Algumas imagens do programa
1. Imagem do programa em seu estado inicial
2. Vista "de cima" do sistema. É possível observar as órbitas de todos os planetas
e, em destaque, a órbita e o planeta Saturno, que está selecionado.
3. Vista bastante aproximada do Sol, exibindo a Terra selecionada e
a janela de informações à esquerda.
4. Imagem da maioria dos planetas exibindo o nome
de cada um acima deles.
5. Plutão de perto com suas informações sendo exibidas no
menu à esquerda.
6. Conclusões
O desenvolvimento desta ferramenta foi muito gratificante para todos nós. Primeiramente pela oportunidade de nos familiarizarmos com o uso da biblioteca gráfica OpenGL e suas funções, o que nos permitiu expor nossa criatividade no decorrer do desenvolvimento da aplicação, assimilar um novo paradigma, além de nos proporcionar um desafio para a resolução de problemas que até então não imaginávamos ter que superar.
Em segundo lugar, não menos importante, tivemos a oportunidade de aprofundar nosso conhecimento em relação ao Sistema Solar. O desenvolvimento de uma ferramenta de fácil manipulação e que contenha informações importantes, mesmo que básicas, sobre os corpos celestes que a ele pertencem, será de grande utilidade para pessoas que assim como nós, possuem interesse pela astronomia.
Concluindo, a oportunidade de programar um sistema cujo resultado é gráfico e não apenas composto de letras e números foi de enorme satisfação para nós.
7. Referências
|
|
