Introdução
1. Elementos de Textura
2. Seleção via mouse
3. Download do Código Fonte
Conclusão

O objetivo desta etapa do projeto é incrementar a versão anterior(0.2), adicionando elementos de textura da biblioteca gráfica OpenGL. Além disso, o tiro no tabuleiro, que até então era feito via teclado, deve ser feito via mouse.

Dessa forma, este relatório será bem simples, consistindo de apenas 3 seções: a primeira, comenta os passos necessários para inserir elementos de textura no jogo; a segunda, expõe o método que foi usado para fazer a seleção dos quadrantes via mouse; e a terceira, disponibiliza o código fonte do jogo Batalha Naval.

Há diversas possibilidades de mapeamento de texturas em OpenGL, havendo funções para recursos simples até os mais sofisticados. No caso deste jogo, as texturas poderiam simular o céu, o mar, os navios, ou ainda os tiros nos quadrantes, sendo uma para água, no caso de um erro e, outra para o fogo, simbolizando um acerto.

Assim, optou-se por usar 3 tipos de texturas: uma para representar o oceano, como um todo, cobrindo toda a área do tabuleiro; outra para representar o fogo, que indicará os quadrantes acertados; e uma última para representar a água, simbolizando os quadrantes que receberam um tiro porém sem acertar nenhuma parte de navio.

Nesta etapa houve duas dificuldades: uma que envolveu uma maior complexidade para sua superação e outra mais simples. A mais complicada deve-se ao fato de OpenGL não trabalhar com os formatos de imagem mais utilizados, como bmp, jpg e png. Dessa forma, as funções que fazem o mapeamento de texturas em OpegnGL consideram, como parâmetro da função glTexImage2D(), uma matriz de pixels em formato interno RGB ou RGBA, deixando para o usuário a tarefa de ler uma imagem e obter essa matriz.

Para resolver este problema, o aluno Adler Cardoso indicou o site www.dca.ufrn.br/~ambj, no qual havia um exemplo de texturas em que o autor (Agostinho de Medeiros Brito Júnior) utiliza uma função que lê imagens com a extensão .RGB. Contudo, esta extensão não é suportada pelos principais softwares de foto, como Paint, Imaging e PhotoShop. Logo, foi preciso converter a textura que se tinha, a qual estava no formato BMP, para o formato RGB (extensão), usando o software 3D Max Studio.

A esta altura, o processo de texturização já funcionava corretamente, porém, o aluno Carlos Henrique indicou uma biblioteca que processa a leitura do formato BMP diretamente(loadimage.h) e, assim, optou-se por mudar essa leitura para tornar o código mais re-usável. Este encaminhamento mostrou-se o mais acertado principalmente após os testes com vários tipos de texturas, no formato BMP, que permitiram notar diferentes resultados e a conveniência de não demandar a conversão prévia.

A segunda dificuldade diz respeito ao fato de a textura alterar as cores dos navios, modificando-os por completo. Para resolver este problema, foi utilizado a função glTexEnvf(), a qual possui como último argumento um parâmetro que modifica os modos com que a textura interage com as superfícies da cena. Foram testados para este argumento os seguintes parâmetros: GL_DECAL, GL_REPLACE, GL_MODULATE, GL_BLEND, GL_ADD e GL_COMBINE, e desta forma, notou-se que GL_MODULATE era o que melhor mantinha as cores originais, logo, optou-se por ele.

Antes de mostrar algumas imagens do processo de texturização, é interessante também comentar que para o processo ser feito com êxito, é necessário que a imagem que representa a textura seja de ordem quadrática de pixels e, ainda, seja potência de 2. Segundo o Red Book, é aconselhável que essa ordem seja 64x64, 128x128, ou, no máximo, 256x256.

A seguir, são expostas algumas imagens do processo de texturização:

Figura 1 : Textura do oceano durante o período diurno

Figura 2 : Textura do oceano durante o período noturno

Figura 3 : Textura dos quadrantes de erro e acerto durante o dia

Figura 4 : Textura dos quadrantes de erro e acerto durante a noite

Para realizar a seleção via cursor, foi necessário primeiro, especificar o ponteiro da função que manipula o mouse em glutMouseFunc(), dentro do corpo da função display(). Depois disto, a seleção poderia ser feita de uma maneira bem simples, que consiste em pegar os valores passados para a função que manipula o mouse, que neste jogo, chama-se mouse(), e fazer um mapeamento entre os pixels e os quadrantes, passando o resultado para a função que realiza o tiro Atira(linha, coluna). Contudo, este método serve apenas para quando o tabuleiro não for rotacionado, pois caso contrário, os quadrantes clicados não correspondem aos atirados.

Assim, a grande dificuldade deste passo foi conseguir atirar nos quadrantes, mesmo com o tabuleiro rotacionado. Para resolver isso, inicialmente, usou-se a função gluUnProject(), a qual faz a projeção inversa em relação a matriz de projeção armazenada. Assim, os pontos da tela poderiam ser relacionados com os pontos tridimensionais e o problema seria resolvido. Contudo, tal método apresentou algumas imprecisões, até mesmo para quando o tabuleiro não possui uma grande inclinação. Como uma alternativa, tentou-se usar uma função de inversão de matrizes da biblioteca math.h. Mesmo assim, a imprecisão continuava.

A solução foi usar a função gluPickMatrix(), a qual define uma sub-área na tela centrada a partir do clique do mouse. Esta função trabalha definindo, antes de chamá-la, uma matriz de buffer, a qual é indicada através da função glSelectBuffer(), e serve para armazenar os identificadores pré-definidos. Estes elementos são aqueles em que se está interessado em identificar, que são definidos através dos comandos glLoadName() e glPushName(), que devem ser usados no modo GL_SELECT. No caso do jogo, cada quadrante corresponde a um identificador, indo de 00, até 99. É interessante dizer também que, antes de atribuir os valores aos identificadores, os comandos glInitNames() e glPushName(0) precisam ser chamados para uma inicialização da pilha.

Infelizmente, não foi possível ilustrar esse processo com telas capturadas, pois a tecla Print Screen não salva a posição do mouse na tela, logo, não daria para saber apenas pela imagem se o tiro foi dado via teclado ou cursor.

O código fonte do jogo possui apenas 1 arquivo, chamado bNaval_03.c, que deve ser compilado em um compilador C ou C++ das plataformas Windows/Linux/Unix. Para que a compilação não apresente nenhum problema, a biblioteca glut precisa estar instalada corretamente, ou seja, seus arquivos de extensão h, lib e dll devem ser compatíveis com o compilador e plataforma, além de estarem em uma pasta corretamente referenciada. Algumas informações de como instalar a biblioteca glut e também as demais bibliotecas OpenGL podem ser encontradas aqui.

Batalha Naval 0.3

Com o término desta terceira etapa do projeto foi possível adquirir maior experiência no manejo da biblioteca gráfica OpenGL, além de comprovar os aspectos teóricos ministrados nas aulas. Um ponto interessante a se destacar é a vantagem da biblioteca em realizar uma escala automática entre os vértices de textura e objeto, podendo-se mudar alguns parâmetros para lidar com imperfeições de mapeamento. Ainda foi possível observar que se pode utilizar várias camadas de textura, simplesmente as sobrepondo e ajustando parâmetros das função que realizam estas operações.

Além disso, uma das principais vantagens da textura, que é o aumento do realismo, foi observada na prática, pois com o uso de texturas têm-se praticamente um novo jogo. Não que este seja próximo de uma verdadeira batalha naval, mas está muito mais próximo do visual de um jogo comercial do que a versão anterior. Contudo, é necessário dizer que até então, o jogo rodava de maneira muito leve e, agora, ele já começa a mostrar-se um pouco pesado. Teoricamente, isso não deveria acontecer, pois trata-se de um jogo muito simples, todavia, poderia se comparar o benefício do custo computacional que está relacionado ao uso de texturas somente se modelar-se a cena com os mesmo aspectos visuais da textura, porém sem ela, o que logicamente, mostraria diferenças gritantes, pois é óbvio que uma cena sem texturas roda mais rápido do que uma com texturas.

De uma maneira geral, dado o término do projeto, foi possível aprender muitos recursos interessantes do OpenGL, como também constatar que falta ainda uma gama muito grande de conhecimentos, situando o conhecimento adquirido no nível básico de utilização da biblioteca. Um aspecto interessante e estimulante do projeto é que ficou evidenciado que não é preciso ser um artista gráfico para fazer um jogo, basta ter criatividade e conhecimentos de computação, que a estrutura do jogo pode ser definida. É claro que modelos geométricos de um artista sempre são bem vindos, porém, esta é apenas uma das muitas partes que compõem um jogo, sendo necessário também aprender a programar a lógica, o cenário, a iluminação e menus dos jogos, os quais pode-se pensar sem grandes efeitos.