FEEC - Unicamp

Jogo Tiro Ao Alvo - Etapa 4 - Final

 

Introdução:

Nesta terceira e última versão, foram aplicadas as texturas e feitas algumas pequenas correções.

Para manter o requisito de destaque para o alvo, ao invés de mudar a cor do prédio, foi colocada uma marcação na textura do piso onde se ele se encontra. Como a noite o piso não pode ser visualizado totalmente, o prédio ficará com as janelas todas acesas.

Foram feitas as seguintes melhorias/correções e funcionalidades:

- Aplicação de texturas em todos os objetos da cena
- Remoção de objetos desnecessários
- Remoção de métodos e arquivos fonte desnecessários
- Rearranjo da iluminação (diurna e noturna)
- Seleção correta do projétil. Agora, uma vez escolhido, só poderá ser mudado após ele ter completado seu trajeto.
- Adição de um gramado e bancos de concreto no cenário
 

sobe

Funcionamento

Para atender aos novos requisitos de texturização, foram criados novos métodos e alterados alguns já existentes na classe CGameCore. Os principais são:

Novos:

- ShowModelData ()         - Exibe na tela dados do arquivo de modelos:
Exibe na tela as características do modelo tais como nome dos objetos, ID da textura, mapeamento, etc.

Este método apenas chama o método de mesmo nome da classe CAux (ex CEngine). É um método auxiliar para a fase de desenvolvimento/debug para verificar alguns dados dos objetos presentes no arquivo tais como se o objeto está preparado para receber texturas, se está mapeado, etc. além do respectivo nome.

Um detalhe: o mapa de texturas foi criado no próprio 3D Studio seguindo os modelos conhecidos de mapa de texturas: Plano, Cilíndrico e Esférico. Para os edifícios, foi escolhido o mapa Plano. Para o projétil, o Cilíndrico. Caso não tivesse sido criado no 3D Studio, o mapa seria informado ao OpenGL através da função glTexCoord2f() que informa os limites max/min da textura na respectiva coordenada (s,t) de acordo com os max/min do objeto que irá receber a textura. Esse processo é que se chama mapeamento de texturas.

- LoadTextures () / AssignTextures()   - Carrega as texturas do jogo:
Faz a carga de todas as texturas para a biblioteca OpenGL.

LoadTextures() faz a leitura enquanto que AssingTextures() faz a atribuição. O procedimento para a carga de uma textura no OpenGL é o seguinte:

1. Utilizar uma função para ler uma imagem e convertê-la para bitmap (no nosso caso, utilizamos uma função da biblioteca de funções auxiliares do OpenGL - auxDIBImageLoad ()). No jogo, esta função foi encapsulada pelo método LoadBMP () (classe CAux) e utilizada pelo método LoadTextures ()

2. Solicitar ao OpenGL para iniciar um vetor de ID de texturas através da chamada de glGenTextures (). No jogo, esta função inicia o vetor com MAX_NUM_TEXTURES entradas.

3. Chamar a função glBindTexture () para informar no contexto do OpenGL essa textura.

4. Uma vez informado, chama-se glTexImage2D () que faz a passagem dos dados da imagem (lida conforme descrição acima) para o OpenGL.

5. Finalmente, fazer uso das técnicas de mapeamento de texturas através da função glTexParameteri (). Esta função oferece diversos modos de relacionamento entre o mapa de coordenadas das texturas (s, t) com o mapa de coordenadas dos objetos.

Para facilitar o uso dessa seqüência, LoadTexture() deve ser alterado a cada nova textura aplicada. Adiciona-se a linha correspondente à leitura do arquivo BMP da textura e adiciona-se a chamada de AssignTextures() para o ID correspondente.

- FlushTextures ()    - Libera memoria usada na carga das texturas
Como a chamada de LoadTexture() faz alocação dinâmica, foi criado esse método para liberar a memória utilizada quando necessário.

OBS: Chamar glEnable(GL_TEXTURE_2D) no início para uso dessas função descritas.

Alterados:

- InitLighting ()
Uso de luzes cinza/branca e não mais colorida já que estão sendo usadas texturas. Por causa do gramado, foi adicionada uma nova luz para iluminar a região.

- CreateScenario () / DrawPlane () / DrawBomb ()
Para utilizar as texturas, basta chamar glBindTexture () com o ID da textura desejada antes da chamada de DrawObject(). A chamada de glBindTexture () informa ao OpenGL que as instruções seguintes de desenho de polígonos deverão ser feitas utilizando a textura escolhida.
No caso de objetos que não devem ficar "no escuro", um material "self-illuminated" foi escolhido.

Screenshots:


Fig. 1: Vista em perspectiva (default) durante o dia

 


Fig. 2: Vista em perspectiva durante a noite. A textura do
prédio alvo é trocada para uma com janelas brancas
para simular luzes.
 


Fig. 3: Vista distante do cenário com o gramado aparecendo
 


Fig. 4: Vista superior com a marca vermelha ao redor do alvo.
 



Fig. 5: Vista detalhada do gramado

 

Fig. 6: Vista detalhada do projétil

 


 

 

Downloads:

- Código fonte (para Microsoft C++ Visual Studio 6.0)
- Executável

 


Conclusão:

Através do projeto, foi possível por em prática alguns dos tópicos dados em aula como transformações geométricas, cor, iluminação e texturização utilizando uma biblioteca de médio nível  como o OpenGL.

Além da modelagem geométrica dos objetos, outro grande esforço durante a elaboração do jogo está na modelagem de comportamentos da natureza como quedas livres, colisões e outras características que não foram exploradas nesse jogo como efeitos de partículas, fumaça, iluminação volumétrica entre outros.

Foi possível entender como funciona o processo de texturização tanto do lado de código quanto do lado "artístico" no qual o realismo da cena está muito ligado com a qualidade da textura.

sobe

Bibliografia:

- http://www.dca.fee.unicamp.br/courses/IA725/1s2006/calender.html - Notas de aula da disciplina
- http://www.dcc.ufla.br/~bruno/aulas/cg/monte-mor/index.htm
- http://www.dca.fee.unicamp.br/courses/EA978/1s2003/proj/p1task5.html#demo
- http://pyopengl.sourceforge.net/documentation/manual/index.html - Manual de OpenGL
- http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/ - Manual de OpenGL

sobe

 

Início