SPLASH SCREEN,
CONFIGURAÇÕES DA OGRE,
SCENEMANAGER
E CÂMERA

Splash Screen

O projeto começa a ser executado a partir do arquivo main.c, nele estão os includes básicos da ogre(Ogre.h e OgreException.h) além do windows.h para o uso de algumas funções do windows. O arquivo Inicializa.h é da classe Inicializa a qual definiremos as configurações da ogre, além das malhas e outros elementos que iremos utilizar.

#include "Inicializa.h"
#include "Ogre.h"
#include "OgreException.h"

#define WIN32_LEAN_AND_MEAN
#include "windows.h"

#include "stdafx.h"
#include "Splash.h"

No projeto foi adicionada uma classe CSplash para que o programa tenha uma splash screen, que é aquela tela que aparece quando o programa é aberto, isso é opcional. Os arquivos stdafx.h e Splash.h são os arquivos para a isso.

INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT )
{
   //adiciona a tela de abertura
   CSplash splash;
   splash.SetBitmap(TEXT("..\\..\\media\\materials\\textures\\iraonline2.bmp"));
   //define a cor da transparencia
   //splash.SetTransparentColor(RGB(128, 128, 128));
   splash.SetTransparentColor(RGB(255, 255, 255));
   splash.ShowSplash();

   //tempo q fica na tela
   Sleep(4000);

   //para a tela de abertura
   splash.CloseSplash(); 

Depois de criado o objeto "splash" usamos o método "SetBitmap()" para definir a imagem, que deve ser no formato bitmap(.bmp). "SetTransparentColor()" é utilizado para determinar a cor que será considerada tranparente, no código a cor que está transparente é a branca.

Com a função "Sleep()" estabele o tempo que a imagem ficará na tela em milisegundos, caso queira que ela não apareça, enquanto você estiver desenvolvendo o seu programa, basta colocar o tempo como zero ou comente todo o trecho de código do Splash Screen.

Configurações da Ogre

   try
   {
      iInicializa.Vai();
   }
   catch( Ogre::Exception& e )
   {
      catch( Ogre::Exception& e )
   {
      MessageBox( NULL, e.getFullDescription().c_str(), "An exception has occured!", 
	  		MB_OK | MB_ICONERROR | MB_TASKMODAL);
   }
   }
   return 0;
}

Esse trecho de código começa a execução da Ogre, através do método "Vai()" da classe Inicializa que chamará os outros. O restante do código acima é executado caso aconteça algum erro.

As classes do projeto foram dividas em arquivos, em um deles estão definidas as variáveis(atributos), includes e nomes dos métodos da classe(arquivos .h) e no outro está a implementação da classe propriamente dita(arquivos .cpp).

#include "AplicationListener.h"

using namespace Ogre;

Na classe Inicializa que cuida da configuração e declaração das malhas a serem utilizadas no jogo, incluimos no arquivo "Inicializa.h", o include "AplicationListener.h" porque nesta classe está o loop do jogo, a qual será explicado futuramente.

A linha "using namespace Ogre;" é utilizada para evitarmos repetições da palavra Ogre sempre que fizermos referência a algum membro de sua biblioteca. Por exemplo na definição de uma entidade, deveriamos declarar da seguinte forma:

Ogre::Entity

E usando o recurso do namespace podemos declarar usando somente a palavra Entity.

bool Inicializa::Vai(void)
{

   Configura();
     
   CarregaMalhas(); 

   aplicationListener = new AplicationListener(root, window, camera, scene_mgr);
   root->addFrameListener(aplicationListener);

   root->startRendering();

   return true;
}

Passando para o arquivo Inicializa.cpp, o método "Vai()" irá invocar outros métodos e iniciar a renderização, um deles é o "Configura()". Ao contrário dos tutoriais e exemplos da Ogre não será utilizada a classe ExampleApplication no projeto, dessa forma não aparecerá a tela de configuração da Ogre, onde define-se por exemplo a resolução da tela, isso será feito em código no método "Configura()".

bool Inicializa::Configura()
 { 

 //lê os arquivos de configuração
   root = new Root("plugins.cfg","display.cfg","log.txt");

O root é o ponto de início da Ogre, ele é criado antes de qualquer outro elemento. Nessa linha também passamos os arquivos de configuração que serão utilizados no programa, eles estão na pasta onde está o executável do programa. O arquivo "plugins.cfg" contém os plugins a serem usados e "log.txt" conterá as informações de execução, caso o programa pare de repente sem nenhum motivo aparente, é importante que este arquivo seja verificado para encontrar o problema.

 //leitura do arquivo onde estao os arquivos usados no programa
 Ogre::ConfigFile cf;
 cf.load("resources.cfg"); 

O arquivo "resources.cfg" contém os diretórios onde estão os modelos, fontes, scripts, texturas entre outros elementos que irão fazer parte do jogo.

 //Inicio dos comandos para a leitura de todos caminhos para os arquivos
 Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator();

 Ogre::String sec_name, type_name, arch_name;
 while (seci.hasMoreElements())
 {
   sec_name = seci.peekNextKey();
   Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext();
   Ogre::ConfigFile::SettingsMultiMap::iterator i;
   for (i = settings->begin(); i != settings->end(); ++i)
   {
   type_name = i->first;
   arch_name = i->second;
   Ogre::ResourceGroupManager::getSingleton().addResourceLocation(
   arch_name, type_name, sec_name);
   }
 }

O trecho acima de código irá ler todas as linhas do arquivo "resources.cfg" para serem usadas no jogo.

 //procura do sistema de renderização
 RenderSystemList *rs_list = root->getAvailableRenderers();
 int c = 0;
 bool foundit = false;
 RenderSystem *selectedRenderSystem = 0;
 while(c < (int) rs_list->size())
 {
    selectedRenderSystem = rs_list->at(c);
    String rname = selectedRenderSystem->getName();
    //if(rname.compare("OpenGL Rendering Subsystem")==0)
    if(rname.compare("Direct3D9 Rendering Subsystem")==0)
    {
       foundit = true;
       break;
    }
    c++; // <-- oh how clever
 }
 //se nao encontrou o sistema de renderização
 if(!foundit) return 0;

Procura pelo sistema de renderização, aqui é feita a escolha entre OpenGL e DirectX, basta descomentar uma das linhas abaixo, de acordo com o sistema que escolher.

 //configurando o sistema de renderização
 selectedRenderSystem->setConfigOption("Full Screen","No");
 selectedRenderSystem->setConfigOption("Video Mode","800 x 600 @ 32-bit colour");

No trecho acima é escolhido se o jogo rodará em tela cheia(Full Screen), a resolução da tela além de escolher a qualidade da cor, 16 ou 32 bits. Se escolher 16 bits por exemplo, defina esse mesmo valor nas configurações de video do windows, caso contrário poderá ter problemas de execução.

 //cria a janela da renderização
 window = root->initialise(true,"IRAonline");

A linha cria a janela onde será renderizada as imagens, o primeiro parâmetro determina se a janela será automaticamente criada e o segundo o título da janela. Observe que a janela e alguns outros elementos como o SceneManager(Gerenciador da cena) são criados apartir do root.

//cria o gerente da cena
 scene_mgr = root->createSceneManager(Ogre::ST_EXTERIOR_CLOSE, "ExampleSMInstance");

O SceneManager conterá todos os elementos que irão fazer parte do ambiente 3D, como modelos, luzes, partículas, etc. Todas as informações destes elementos serão guardados e manipulados pelo SceneManager. Existem vários tipos de SceneManagers, entre eles estão:

Para informações mais detalhadas visite a seguinte página do wiki da Ogre.

//cria uma camera
 camera = scene_mgr->createCamera("PlayerCam");
 //distancia a qual a camera começa a renderizar
 camera->setNearClipDistance(5);

A câmera permite que os elementos que compõem a cena sejam visto, e possui um comportamento semelhante ao um SceneNode(Nó da cena), que será tratado mais a frente. A função "createCamera()" cria uma câmera associada a um SceneNode. O parâmetro é o nome dado a câmera, que deve ser único, para um acesso posterior através do gerenciador de cena através da função "getCamera()", como no exemplo:

scene_mgr->getCamera("PlayerCam");

Através da função "setNearClipDistance()" é determinada a distância minima apartir da câmera em que a cena será renderizada.

//cria um viewport
 vp = window->addViewport(camera);

 //define as dimensões da janela que a camera ira renderizar
   camera->setAspectRatio(Real(vp->getActualWidth()) / Real(vp->getActualHeight()));

O Viewport é a área da janela em que a câmera associada ao viewport irá renderizar suas imagens. Isso é muito útil em jogos em que é necessário dividir a tela entre dois jogadores, como em Neef For Speed ou Top Gear(figura abaixo) em que um viewport associado a uma câmera mostra as imagens do jogador 1 enquanto que um outro viewport associado a uma outra câmera mostra as imagens do jogador 2.

Italo Mendes
italo.ribeiro@gmail.com