Introduo ao Ogre3D

Maylson Gonalves @maylson

Outubro/2010 Belm, Par

ndice de Figuras
Figura 1 - Download do OGRE SDK ................................................................................... 7 Figura 2 - Diretrio para onde ser extrado o OGRE SDK ............................................... 8 Figura 3 - Andamento da extrao do OGRE SDK ............................................................ 8 Figura 4 - Contedo do diretrio de instalao do OGRE SDK ......................................... 9 Figura 5 - Criao da varivel de ambiente do OGRE ....................................................... 9 Figura 6 - Lista de variveis de ambiente, com a nova varivel criada .......................... 10 Figura 7 - Exemplos do OGRE SDK .................................................................................. 13 Figura 8 - Erro ao compilar o SampleBrowser ................................................................ 14 Figura 9 - Soluo do erro no Pre-Link Event.................................................................. 14 Figura 10 - Janela de configurao do Ogre3D ............................................................... 15 Figura 11 - Screenshot do SampleBrowser ..................................................................... 16 Figura 12 - Criao de um novo projeto ......................................................................... 17 Figura 13 - Adicionando um arquivo ao projeto ............................................................ 18 Figura 14 - Criando o arquivo Main.cpp na subpasta Source......................................... 18 Figura 15 - Configurao da guia General em modo Release ........................................ 19 Figura 16 - Configurao da guia C/C++ >>> General ..................................................... 20 Figura 17 - Configurao da guia Linker >>> General..................................................... 21 Figura 18 - Configurao da guia Linker >>> Input ......................................................... 21

Sumrio
ndice de Figuras ............................................................................................................... 2 Introduo ao Ogre3D ...................................................................................................... 5 Pr-requisitos ................................................................................................................ 5 Plataformas ................................................................................................................... 6 Instalao do Ambiente de Desenvolvimento ................................................................. 7 Estrutura de Diretrios do OGRE SDK ......................................................................... 10 bin ........................................................................................................................... 10 Docs ........................................................................................................................ 11 include .................................................................................................................... 11 lib ............................................................................................................................ 11 Samples................................................................................................................... 12 media ...................................................................................................................... 12 Compilando os Exemplos do OGRE............................................................................. 12 Criando um Projeto no VC++ ...................................................................................... 16 Inicializao do OGRE ..................................................................................................... 23 Root ........................................................................................................................ 23 plugins.cfg ............................................................................................................... 23 ogre.cfg ................................................................................................................... 24 Ogre.log .................................................................................................................. 26 Render Window ...................................................................................................... 26 Scene Manager ....................................................................................................... 27 Render Loop............................................................................................................ 29 Frame Listener ........................................................................................................ 30 Main Rendering Loop ............................................................................................. 31 Gerenciamento dos Recursos de Media ........................................................................ 33 Gerenciamento de Recursos na Prtica ................................................................. 33 Localizao dos Recursos........................................................................................ 34 Inicializao dos Recursos ...................................................................................... 35 Descarregamento de Recursos ............................................................................... 36 Dispositivos de Entrada .................................................................................................. 37 3

Biblioteca de Input.................................................................................................. 37 Input Manager e Input Listener .............................................................................. 37 Materials ......................................................................................................................... 43 Scene Management ........................................................................................................ 43 Ferramentas de Produtividade ....................................................................................... 43 Animao ........................................................................................................................ 43 GUI com SdkTrays ........................................................................................................... 43 Estudo de Caso ............................................................................................................... 43 Hot tips ........................................................................................................................... 44 Dvidas comuns.............................................................................................................. 44 Exportao com o Blender ............................................................................................. 44

Introduo ao Ogre3D
OGRE (Object Oriented Graphics Rendering Engine) um motor de renderizao grfica em tempo real, multiplataforma, escrito em C++ e de cdigo aberto, construdo para abstrair as especificidades das APIs (Application Interface Programming) de renderizao grfica de baixo nvel, como o DirectX e o OpenGL. O OGRE mantido por um pequeno grupo de desenvolvedores que trabalham no ncleo do motor, mas que tambm recebe contribuies de diversos usurios. O OGRE tambm pode ser utilizado em outras linguagens de programao, como Java, C# e Python, atravs de wrappers construdos pela comunidade, ou seja, no suportados oficialmente pela equipe de desenvolvimento do OGRE, estando em diversos graus de estabilidade e completude em relao ao OGRE oficial. Um erro comum relacionado ao OGRE devido a sua qualidade como Motor de Jogos ou Game Engine. O OGRE no , nem nunca teve a pretenso de ser uma plataforma de desenvolvimento de jogos completa, sendo, ao invs disso, apenas uma plataforma de renderizao grfica, podendo ser utilizada em diversas aplicaes de computao grfica, inclusive games. Uma pergunta comum nos fruns do OGRE : Como eu rodo o OGRE?. Bem, voc no roda. OGRE no um programa. No existe um executvel do OGRE. O OGRE um SDK (Software Development Kit), o que significa que deve ser utilizado para desenvolver software.

Pr-requisitos
Este curso destinado iniciantes em Ogre3D e em computao grfica em geral, interessados em utilizar grficos 3D acelerados por hardware em seus games e/ou aplicaes. Apesar de ser um curso para iniciantes, alguns pr-requisitos devem ser cumpridos, como por exemplo, ser familiar com ISO Standard C++ e C++ STL, uma vez que este curso utilizar a API em C++ nativa do OGRE, e todos os cdigos e exemplos estaro implementados em C++. Por exemplo, se voc no entender o cdigo abaixo:

for (std::vector<int>::iterator it = m_myVec.begin(); it != m_MyVec.end(); it++) { //Loop code here; }

ento voc deve revisitar seus conceitos bsicos de C++, pois iterar atravs de um container STL uma tarefa comum em programas C++, de modo que voc ter uma aprendizado mais confortvel se entender o bsico. Alm disso, necessrio possuir uma cpia e se sentir hbil para utilizar o Microsoft Visual C++ .Net 2008 SP1. necessrio tambm que os drivers mais atuais da placa de vdeo do computador de desenvolvimento estejam instalados e funcionando corretamente.

Plataformas
O desenvolvimento original do OGRE foi feito em Windows 32-bit. Esta ainda a principal plataforma de desenvolvimento para o OGRE, embora isso no signifique que outras plataformas so desconsideradas. O time de desenvolvedores do OGRE tem um responsvel exclusivo para tratar da compatibilidade do OGRE com o Linux. Assim como existe um encarregado exclusivo para Mac OS X, outro para iPhone/iPod etc. Todas essas plataformas so igualmente suportadas a partir da mesma base de cdigo. Como OGRE tem suporte nativo ao OpenGL, possvel utilizar o OGRE em qualquer plataforma na qual exista suporte acelerao por hardware em OpenGL, como o Solaris da Sun. Entretanto, o ncleo de desenvolvedores do OGRE no suporta diretamente plataforma no-Linux/UNIX, sendo qualquer port desta natureza apenas esforo da comunidade.

Instalao do Ambiente de Desenvolvimento

Para ter um ambiente de desenvolvimento funcional, voc precisa ter o OGRE SDK e uma IDE (Integrated Development Environment). Neste curso usaremos o Visual C++ .Net 2008 SP1. O mtodo mais simples de obter esse ambiente seguindo os passos abaixo. 1. Fazer o download do OGRE SDK correto, de acordo com a IDE a ser utilizada; 2. Configurar sua IDE com os caminhos corretos para o OGRE SDK; 3. Compilar os exemplos do OGRE, garantindo que seu ambiente configurado. Para efetuar o download do instalador do OGRE SDK, acesse a pgina de downloads do OGRE: http://www.ogre3d.org/download/sdk. Escolha o OGRE 1.7.2 SDK for Visual C++ .Net 2008 (32-bit).

Figura 1 - Download do OGRE SDK

Ao executar o instalador, ser necessrio informar o caminho para onde o SDK ser extrado. Indique o caminho do diretrio raiz do Windows, C:\.

Figura 2 - Diretrio para onde ser extrado o OGRE SDK

Acompanhe o andamento da extrao e fique atento para quaisquer erros no processo, que podem surgir por problemas de permisso de escrita no diretrio, por exemplo.

Figura 3 - Andamento da extrao do OGRE SDK

Aps o final da operao de extrao, o seu diretrio do OGRE SDK estar como na Figura 4.

Figura 4 - Contedo do diretrio de instalao do OGRE SDK

Agora preciso criar uma varivel de ambiente que faa referncia ao diretrio do OGRE SDK. V ao Painel de Controle >>> Sistema >>> Configuraes Avanadas do Sistema >>> Propriedades do Sistema. Clique no boto Variveis de Ambiente.... Na janela que abrir, clique no boto Novo. Por fins de padronizao, nomeie a varivel de ambiente como OGRE_HOME, indicando o diretrio do OGRE SDK no campo Valor da Varivel. Clique em OK, e pronto. A nova varivel ir aparecer na lista de variveis.

Figura 5 - Criao da varivel de ambiente do OGRE

Figura 6 - Lista de variveis de ambiente, com a nova varivel criada

Essa varivel extensivamente utilizada nos exemplos do OGRE. Ela ser til para localizar a e para apropriadamente definir os diretrios de headers e de libraries do OGRE, de modo a no haver preocupao relativa ao diretrio onde o OGRE foi instalado. Ela tambm ser bastante utilizada nos exemplos deste curso.

Estrutura de Diretrios do OGRE SDK

Na Figura 4 podemos ver o contedo do diretrio do OGRE SDK. Vamos analisar os itens mais importantes para o prosseguimento deste curso.

bin

Esta pasta contm as DLLs padro do OGRE SDK OGRE e OIS (Object Oriented Input System, biblioteca de input oficial do OGRE, embora seja um projeto separado). 10

As DLLs dessas bibliotecas existem tanto na pasta release quanto na pasta debug, e cada uma contm seus respectivos tipos de DLL: a pasta debug contm DLLs nootimizadas que incorporam informaes de debug, muito teis ao fazer o debugging de aplicaes baseadas no OGRE. A pasta release contm DLLs otimizadas e enxutas (no sentido de no possurem qualquer informao para debugging), as quais so utilizadas para distribuir o aplicativo baseado no OGRE.

Docs

Esta pasta contm as referncias da API na forma CHM (Compiled Help), alm do Manual online do OGRE no formato HTML. A referncia da API gerada a partir do cdigo atual, utilizando uma ferramenta chamada doxygen, a qual realiza um parse nos headers do OGRE e cria referncias em hyperlinks a partir de seus contedos e marcaes especiais no cdigo-fonte. bastante til para descobrir quais classes e mtodos esto disponveis na API do OGRE, alm de conter uma breve descrio de uso de cada classe. ainda mais til se j houver familiaridade com a API e precisar apenas de uma rpida referncia. O Manual um sumrio condensado e conciso e condensado das caractersticas e utilizao de algum grande subsistema do OGRE, bem como uma discusso a respeito do uso de algumas caractersticas avanadas do OGRE. O Manual escrito e mantido pela equipe de desenvolvimento do OGRE, e serve como um bom complemento para as referncias da API quando for necessria uma fonte rpida fonte de informao sobre uma particular caracterstica do OGRE.

include

Esta pasta contm os headers do OGRE, os quais sero referenciados no seu cdigo, bem como os headers da OIS. Esta pasta deve ser referenciada na configurao de qualquer projeto que utilize o OGRE.

lib

Esta pasta contm as bibliotecas de importao do OGRE e da OIS, necessrias para linkar as DLLs da pasta bin. Cada DLL tem uma correspondente .lib: *_d.lib para *_d.dll e release *.lib para *.dll. Esta pasta deve ser referenciada na configurao de qualquer projeto que utilize o OGRE.

11

Samples

Esta pasta contm os exemplos do OGRE, cada exemplo destacando uma caracterstica em particular do OGRE. Os exemplos so fornecidos com cdigo-fonte e podem ser facilmente compilados.

media

Esta pasta contm todos os materials, textures, meshes, etc., que os exemplos do OGRE requerem para sua execuo. Os subdiretrios desta pasta podem ser uma tima referncia para aprender sobre a operao de vrios sistemas do OGRE (especialmente scripts de material e o sistema de efeitos de partcula).

Compilando os Exemplos do OGRE

Compilar os exemplos do OGRE uma tima maneira de validar o seu ambiente de desenvolvimento. Alm disso, os exemplos permitem analisar o uso e implementao de diversos recursos do OGRE. Para compil-los, v ao diretrio do OGRE SDK, onde voc encontrar o arquivo OGRE.sln. Ao abrir este arquivo, voc ver algo semelhante Figura 7. No Solution Explorer, voc pode ver cada exemplo separadamente. Estes exemplos foram implementados de forma que, ao serem compilados, ser criada uma DLL para cada exemplo (Sample_BezierPatch.dll, Sample_BSP.dll,.., Sample_Water.dll). Ao final da lista de projetos no Solution Explorer, encontramos o SampleBrowser. Este projeto ser compilado na forma de um arquivo executvel (SampleBrowser.exe), e este ser responsvel por carregar as DLLs de cada exemplo do OGRE SDK. Para compilar toda a Solution, no centro-superior da janela do VC++, selecione o modo Release (o padro ao abrir pela primeira vez o modo Debug). Em seguida, clique no menu Build >>> Build Solution (ou aperte F7).

12

Figura 7 - Exemplos do OGRE SDK

Caso o VC++ relate a ocorrncia do erro mostrado na Figura 8, no se preocupe. Esse erro devido a ausncia do programa CMake no seu computador. Sua instalao no necessria, no entanto, para remover o erro, no Solution Explorer, selecione o projeto SampleBrowser e acesse o menu Project >>> Properties. Em Configuration, selecione Release, na rvore lateral, selecione Build Events >>> Pre-Link Event, conforme a Figura 9. Na direita, deixe o item Command Line em branco. Clique em Aplicar e OK. Aperte F7 para compilar a Solution novamente.

13

Figura 8 - Erro ao compilar o SampleBrowser

Figura 9 - Soluo do erro no Pre-Link Event

Se tudo correu normalmente, acesse o diretrio do OGRE SDK, v para a subpasta bin\Release e execute o SampleBrowser.exe. Voc ir ver a janela mostrada na Figura 10.

14

Para o SampleBrowser, essa janela ser exibida apenas na primeira vez em que este for executado. Nela possvel escolher o subsistema de renderizao (DirectX ou OpenGL) e configurar opes como Full Screen, Video Mode etc. A Figura 11 mostra a janela do SampleBrowser com as opes Video Mode (800 x 600) e Full Screen (No). As informaes sobre a configurao escolhida sero armazenadas no arquivo de texto ogre.cfg, a ser armazenado no Diretrio de Documentos do Usurio, na subpasta Ogre\Cthugha.

Figura 10 - Janela de configurao do Ogre3D

15

Figura 11 - Screenshot do SampleBrowser

Criando um Projeto no VC++

Este curso introdutrio engloba a criao de um framework base para rapidamente desenvolver aplicativos com o OGRE. Dessa forma, necessrio aprender a criar e configurar corretamente um projeto que utilize o OGRE. Existem algumas ferramentas, como o OgreAppWizard, que facilitam este processo, mas sempre importante conhecer os procedimentos. Para criar um projeto novo no VC++, clique no menu File >>> New >>> Project...; Em Project Types, selecione General. Em Templates, selecione Empty Project, como mostrado na Figura 12. Em Location, insira o diretrio onde o projeto ser armazenado, no exemplo, o diretrio C:\MyProjects. Em Name, digite OgreFramework. O campo Solution Name ser automaticamente preenchido. Marque a opo Create directory for solution (assim, ser criada uma pasta dentro do diretrio C:\MyProjects, com o nome do projeto). Clique em OK. 16

Figura 12 - Criao de um novo projeto

Uma vez que o projeto foi criado, ser necessrio configur-lo para fazer uso do OGRE. Mas, antes, adicione um arquivo de extenso .cpp ao projeto (esse passo importante para habilitar algumas configuraes do projeto). Para criar o arquivo, no Solution Explorer, clique com o boto direito do mouse no projeto OgreFramework (logo abaixo de Solution OgreFramework). Em seguida clique em Add >>> New Item..., como mostrado na Figura 13. Na janela que aparecer (Figura 14), em Categories selecione Code, em Templates selecione C++ file (.cpp). Em Name digite Main.cpp. Atente para o fato de que o campo Location j aparece preenchido no diretrio do projeto, no entanto, por padronizao deste curso, todos os cdigos-fontes (arquivos .h e .cpp) do projeto ficaro em uma subpasta chamada Source. Crie a subpasta e referencie-a no campo Location, como mostrado na Figura 9. Em seguida clique em OK. O arquivo Main.cpp dever aparecer no Solution Explorer, dentro do filtro Source. Ainda no adicione qualquer cdigo a este arquivo. Ns prximos captulos vamos fazer as implementaes e a estrutura do framework base.

17

Figura 13 - Adicionando um arquivo ao projeto

Figura 14 - Criando o arquivo Main.cpp na subpasta Source

18

Agora podemos configurar o projeto apropriadamente. O termo Configurar o projeto significa, em outras palavras, dizer ao VC++ onde ele deve procurar os headers do OGRE, onde ele deve procurar as libs do OGRE, quais libs do OGRE ele deve utilizar, onde ele deve gerar o executvel, qual nome ele deve dar ao executvel, onde ele deve gerar os arquivos intermedirios etc. Sem que voc o ajude, o VC++ no pode ajudar voc. Lembrando que necessrio configurar o projeto duas vezes: uma para o modo Release, outra para o modo Debug. Entender a diferena e o propsito dos modos de compilao Release e Debug pode lhe poupar muitas dores de cabea. PASSO I: Clique no menu Project >>> Properties. Na janela que aparecer (Figura 15), em Configuration selecione o item Release. PASSO II: Na rvore lateral, no item Configuration Properties, selecione o item General. Na direita, os itens Output Directory (diretrio onde ser gerado o executvel) e Intermediate Directory (diretrio onde sero gerados os arquivos intermedirios) precisam ser preenchidos conforme abaixo: Para o campo Output Directory: Para o campo Intermediate Directory: $(SolutionDir)\Bin\$(ConfigurationName) $(SolutionDir)\Obj\$(ConfigurationName)

Figura 15 - Configurao da guia General em modo Release

19

PASSO III: Agora, na rvore lateral, selecione o item C/C++ >>> General (Figura 16). Na direita, em Additional Include Directories, voc precisar referenciar os diretrios onde esto localizados os headers do OGRE e do BOOST (biblioteca utilizada pelo OGRE). Clique no boto ... para adicionar cada diretrio separadamente. Os diretrios a serem adicionados so: $(OGRE_HOME)\include\OGRE $(OGRE_HOME)\boost_1_44

Figura 16 - Configurao da guia C/C++ >>> General

PASSO IV: Na rvore lateral, selecione o item Linker >>> General (Figura 17). Na direita, em Additional Library Directories, voc precisar referenciar os diretrios onde esto localizados os arquivos .lib do OGRE e do BOOST. Clique no boto ... para adicionar cada diretrio separadamente. Os diretrios a serem adicionados so: $(OGRE_HOME)\lib\release $(OGRE_HOME)\lboost_1_44\lib

20

Figura 17 - Configurao da guia Linker >>> General

PASSO V: Na rvore lateral, selecione o item Linker >>> Input (Figura 18). Na direita, em Additional Dependencies, voc precisar referenciar os arquivos .lib do OGRE. Apenas digite OgreMain.lib, pois o nico .lib necessrio em nossos primeiros testes.

Figura 18 - Configurao da guia Linker >>> Input

21

Aps isso, clique em Aplicar para finalizar a configurao do modo Release. Agora necessrio configurar o modo Debug, que muito semelhante ao modo Release. Para fazer isso, preciso repetir os 5 passos (um pouco modificados). No PASSO I, ao invs de selecionar o item Release, selecione o item Debug. Em seguida repita os PASSOS II e III. No PASSO IV, substitua $(OGRE_HOME)\lib\release por $(OGRE_HOME)\lib\debug. No PASSO V, substitua OgreMain.lib por OgreMain_d.lib. Aps isso, clique em Aplicar, em seguida clique em OK. Pronto.

22

Inicializao do OGRE
Agora que temos o OGRE devidamente instalado e funcional, e j sabemos com configurar um projeto corretamente para utilizar o OGRE, faremos um abatimento geral sobre a inicializao do OGRE. A inicializao aqui mostrada segue apenas as estruturas bsicas de um programa OGRE, no se preocupando com outros detalhes da implementao, de modo que vamos apenas utilizar enxertos de cdigo a fim de ilustrar as explicaes. O corpo do cdigo do framework base pode ser encontrado em http://www.waveit.com.br/IntroOgre3D/aula01.rar. Faa o download do cdigo e adicione-o ao seu projeto. Se voc criou o projeto corretamente, esse cdigo dever compilar sem erros. Vamos ento inicializao da engine!

Root

A primeira coisa a se fazer em qualquer aplicao OGRE criar uma instancia do Root. Voc deve fazer isso antes de chamar qualquer outra operao do OGRE (exceto para o LogManager, embora este no seja abortado neste curso introdutrio). O construtor do Root recebe algumas strings opcionais como parmetro, todas so nomes de arquivos.

Ogre::Root *mRoot = new Ogre::Root(plugins.cfg,ogre.cfg,ogre.log);

plugins.cfg

Um plug-in do OGRE qualquer cdigo modular (.dll no Windows, .so no Linux) que implementa uma das interfaces de plug-in, como SceneManager ou RenderSystem. O arquivo plugins.cfg contm uma lista de plug-ins que o OGRE carregar em sua inicializao, bem como a localizao destes.

23

# Define plugin folder PluginFolder=. # Define plugins Plugin=RenderSystem_Direct3D9 Plugin=RenderSystem_GL # Plugin=RenderSystem_GLES Plugin=Plugin_ParticleFX

A diretiva PluginFolder diz ao OGRE onde procurar pelos plug-ins listados no arquivo. A forma como esse caminho interpretado, fica a seu cargo: se voc utilizar um caminho absoluto, OGRE ir procurar apenas neste diretrio. Se voc utilizar um caminho relativo (i.e., um caminho que no inicia com / ou \), ento o OGRE buscar no caminho relativo ao diretrio atual do executvel. A diretiva PluginFolder especificada em nosso arquivo de exemplo diz ao OGRE para procurar pelos plug-ins no diretrio atual do executvel (.). Perceba que linhas que comeam com # so tratadas como comentrios em arquivos de configurao do OGRE. O restante do arquivo contm a lista de plug-ins que voc deseja que o OGRE carregue. Perceba que as extenses dos plug-ins no so inseridas; isto proposital, e lhe permite utilizar o mesmo arquivo de configurao em mltiplas plataformas, sem ter que lidar com convenes de nomes de arquivos (embora o Linux seja bem flexvel nesse aspecto, no se importando com a extenso que voc d ao arquivo). Os primeiros dois plug-ins listados anteriormente so implementaes de render systems (DirectX e OpenGL). Voc no precisa incluir todos eles em seu programa; no fim, voc precisa de apenas um render system.

ogre.cfg

O OGRE fornece um meio simples de definir as opes bsicas de renderizao atravs de uma janela com GUI (Graphical User Interface) nativa, como mostrado na Figura 10. Essa janela de configurao responsvel por permitir ao usurio modificar parmetros da renderizao, como por exemplo, Full Screen (Yes ou No), FSAA (Full Screen Anti-Aliasing, i.e., nvel de serrilhado das imagens), Video-Mode (resoluo da tela) etc. Para exibir essa janela de configurao:
bool resposta = mRoot->showConfigDialog();

24

O mtodo showConfigDialog retorna true ou false dependendo se o usurio clicou no boto OK ou no boto Cancelar. Voc deve considerar terminar a aplicao caso o usurio clique no boto Cancelar. Utilizar a janela de configurao do OGRE significa tratar automaticamente das definies do render system escolhido, podendo modific-los na prpria janela da configurao. O que o tudo isso tem a ver com o arquivo ogre.cfg? essa janela de configurao que gera esse arquivo. Claro que voc tambm pode criar esse arquivo voc mesmo abrindo o editor de textos, e se voc estiver usando outros recursos mais manuais, voc sequer precisa ter esse arquivo de configurao, mas, por agora, vamos apenas olhar o que esse arquivo contm.
Render System=Direct3D9 Rendering Subsystem [Direct3D9 Rendering Subsystem] Allow NVPerfHUD=No FSAA=0 Floating-point mode=Fastest Full Screen=No Rendering Device=Monitor-1-NVIDIA GeForce GTS 250 Resource Creation Policy=Create on all devices VSync=No VSync Interval=1 Video Mode=800 x 600 @ 32-bit colour sRGB Gamma Conversion=No [OpenGL Rendering Subsystem] Colour Depth=32 Display Frequency=100 FSAA=0 Full Screen=Yes RTT Preferred Mode=FBO VSync=No VSync Interval=1 Video Mode=1024 x 768 sRGB Gamma Conversion=No

Perceba que estas opes acima correspondem s opes mostradas na janela de configurao. Estes valores variam de computador para computador. Embora este arquivo no seja perfeitamente compreensvel e intuitivo para ns, humanos, ele foi realmente planejado para ser lido pela mquina, e embora seja possvel defini-los mo, provavelmente melhor deixar a sua criao e edio a cargo da janela de configurao do OGRE. O OGRE tambm nos fornece um mtodo para carregar o arquivo de configurao existente (i.e., ogre.cfg). 25

if (!mRoot->restoreConfig()) mRoot->showConfigDialog();

Esta seqncia de operao muito comum quando utilizamos o arquivo ogre.cfg. Se o mtodo restoreConfig() falhar, ento no existe o arquivo ogre.cfg, e a a janela de configurao , ento, exibida. Quando o usurio clicar em OK, as definies sero salvas num recm-criado, de nome ogre.cfg. Utilizando o mtodo restoreConfig(), voc evita ter de forar os usurios do aplicativo a verem a janela de configurao toda vez que executarem o programa. Voc tambm pode salvar as definies atuais do OGRE para o arquivo ogre.cfg a qualquer momento, com o mtodo saveConfig(). mRoot->saveConfig();

Ogre.log

O OGRE fornece ainda logs de diagnostico e excees utilizando sua classe de gerenciamento de logs. Registros de logs so teis para obter detalhes a respeito de uma falha ou erro na mquina do usurio, sem precisar perguntar a este por detalhes sobre o seu ambiente de execuo. A sada de log gerada pelo OGRE contm todos os eventos, bem como dados sobre a inicializao, estados e informaes sobre a capacidade da mquina em questo, sendo este arquivo gerado a partir de cada execuo do programa. Essa sada enviada para um arquivo de texto simples; o ogre.log. O nome deste arquivo definido no momento da criao do Root.

Render Window

A qualquer ponto, aps o render system ter sido selecionado (neste exemplo, ocorre quando o usurio seleciona e configura o render system na janela de configurao e clica em OK), voc pode chamar o mtodo initialise(), da classe Root:

26

mRoot->initialise(true, "OgreFramework"); Ogre::RenderWindow *mRenderWindow = mRoot->getAutoCreatedWindow();

Ou simplesmente:
Ogre::RenderWindow *mRenderWindow = mRoot->initialise(true, "OgreFramework");

A primeira linha ir fazer com que o Root complete sua inicializao e crie uma janela de renderizao com as definies que o usurio selecionou na janela de configurao. A string OgreFramework ser o ttulo desta janela. O segundo parmetro no obrigatrio e, caso voc no informe ttulo algum, o padro OGRE Render Window ser utilizado. O primeiro parmetro obrigatrio, ele diz ao OGRE se ele deve criar automaticamente a janela de renderizao; para facilitar a compreenso nesta parte do curso, vamos apenas dizer ao OGRE para que crie nossa janela de renderizao. A segunda linha obtm o ponteiro para a instancia do RenderWindow. O render window somente uma parte da renderizao da cena. Ele o canvas, a superfcie na qual o OGRE renderiza seu contedo. O OGRE precisa de pelo menos uma cmera para capturar quadros da sua cena 3D, e um ou mais viewports, os quais so regies sobre a superfcie de renderizao (como o render window) na qual a cmera revela seu contedo.

Scene Manager

No vamos nos aprofundar muito no Scene Manager por agora, uma vez que vamos falar dele com mais detalhes adiante. Entretanto, com o propsito de manter este captulo coeso (j que mencionamos o Scene Manager tantas vezes), necessrio que voc saiba pelo menos o bsico sobre a criao do Scene Manager para utiliz-lo em seu cdigo. Ok. Antes de utilizar a instancia de um Scene Manager, voc deve criar uma.
Ogre::SceneManager* mSceneMgr = mRoot->createSceneManager(Ogre::ST_GENERIC, "MySceneManager");

27

Quando o OGRE carrega seus plug-ins, entre esses plug-ins pode haver vrias implementaes de scene manager, como discutido anteriormente. Cada uma dessas implementaes ir se auto-registrar junto ao OGRE como um tipo particular de scene manager: ST_GENERIC: Implementao mnima de um scene manager, no otimizado para qualquer tipo de cena ou estrutura. Muito til para cenas minimamente complexas (como as cenas onde existe apenas GUI). ST_INTERIOR: Implementao otimizada para renderizar interiores e cenas potencialmente densas, do tipo quarto fechado. ST_EXTERIOR_CLOSE: Implementao otimizada para renderizar cenas exteriores (outdoor scenes) com visibilidade at distancias prximas ou mdias. ST_EXTERIOR_FAR: Anacronismo para retro-compatibilidade entre verses do OGRE, pouco ou no mais utilizado. Utilize ST_EXTERIOR_CLOSE ou ST_EXTERIOR_REAL_FAR ao invs. ST_EXTERIOR_REAL_FAR: Implementao tpica para mundos do tipo paged. Mundo paged geralmente so enormes, possivelmente planetas inteiros.

No exemplo dado, criamos um scene manager do tipo ST_GENERIC, uma vez que no tnhamos nenhuma cena especfica para renderizar. Voc aprender mais sobre as classes SceneManager do OGRE mais adiante; por agora, suficiente saber que elas funcionam como uma fbrica (pois implementam o Design Pattern Factory) para os mais diversos tipos diferentes de objetos que existem numa cena 3D, incluindo cmeras. De modo a criar uma nova cmera para renderizar sua cena 3D, voc deve chamar o mtodo createCamera() na interface SceneManager:
Ogre::Camera *mCamera = mSceneMgr->createCamera("MyCamera"); mCamera->setNearClipDistance(1); mCamera->setFarClipDistance(1000); mCamera ->setAspectRatio(Ogre::Real(1.333333));

Neste exemplo, mSceneMgr um ponteiro para uma instncia vlida do um SceneManager. A classe Camera tem muitas propriedades que podem ser ajustadas, e, claro, mtodos para ajust-las. 28

O cdigo anterior demonstra o bsico que voc ir precisar para uma aplicao OGRE mnima. Ele define o aspect ratio equivalente a um display de 4:3 (como a maioria dos monitores CRT e alguns LCDs non-widescreen). Esse valor pode ser ajustado ou redefinido a qualque momento, e usualmente definido como a razo entre a altura e comprimento do viewport (tal como fizemos aqui, visto que 4/3 aproximadamente igual a 1.33333). O cdigo mostrado tambm define os valores das distancias do near clip plane e do far clip plane. Aqui utilizamos adotamos nosso padro de 1 e 1000, mas voc pode utilizar qualquer um que quiser, to logo a razo entre far e near esteja prxima de 1000, ou menos, para evitar problema de z-fighting. Posteriormente, vamos aprender como manipular a cmera de modos mais complexos, mas por agora, j suficiente para o propsito de criar uma viewport em nossa janela de renderizao.
Ogre::Viewport *mViewport = mRenderWindow->addViewport(mCamera); mViewport->setBackgroundColour(Ogre::ColourValue(0, 0, 0));

O cdigo acima cria um novo viewport no render window que criamos quando chamamos o mtodo initialise() anteriormente no Root. Esse cdigo tambm define a cor do background do viewport para preto.

Render Loop

O modo mais simples de pedir ao OGRE a tarefa de renderizar sua cena invocando o mtodo startRendering() no Root:
mRoot->startRendering();

Isso far com que o OGRE renderize sua cena eternamente em loop, no importando que contedo voc tenha em sua cena. Esse loop continuar existindo mesmo que voc feche a janela de renderizao criada utilizando (por exemplo, clicando no boto x, no canto direito das janelas dos aplicativos Windows), ou quando um frame listener devidamente registrado retorna false. Um mtodo alternativo para terminar o loop de renderizao chamando o mtodo

29

queueEndRendering() do Root, em qualquer lugar no cdigo, embora seja mais comum simplesmente retornar false a partir de algum frame listener.

Frame Listener

Pra incio de conversa, Frame listeners so o nico meio pela qual voc pode invocar seu prprio cdigo durante o Render Loop do OGRE quando estiver utilizando o mtodo startRendering(). Um frame listener simplesmente uma classe que implementa a interface FrameListener, atuando como um callback que permite ao OGRE invocar o seu cdigo no incio, durante ou ao fim do processamento de cada frame. O Exemplo abaixo mostra como criar um frame listener. No framework base, a classe Application um frame listener.
class myFrameListener : public Ogre::FrameListener { public: bool frameStarted (const Ogre::FrameEvent &evt); bool frameEnded (const Ogre::FrameEvent &evt); }; bool myFrameListener::frameStarted(const Ogre::FrameEvent &evt) { // aqui voc pode fazer algo antes do frame ser renderizado return true; } bool myFrameListener::frameEnded(const Ogre::FrameEvent &evt) { // aqui voc pode fazer algo aps o frame ser renderizado return true; } MyFrameListener myListener; // No esquea que voc precisa adicionar um frame listener // ANTES de chamar o mtodo startRendering()!!! // Assumindo que voc j criou o Ogre::Root mRoot->addFrameListener(myListener); mRoot->startRendering();

30

A implementao do mtodo frameStarted() ser chamada antes do OGRE invocar o pipeline de renderizao. Geralmente, o mtodo frameEnded() menos utilizado, sendo til quando voc precisa destruir algum objeto a cada frame, e chamado aps o OGRE completar a renderizao do frame. Geralmente, durante cada frame. Voc deve processar eventos de entrada da HID (Human Interface Device, como teclado, mouse, joystick, WiiMote, Kinect etc). Dependendo do evento ocorrido, voc pode programar um modelo 3D se mova e/ou rotacione, pode fazer a cmera se mover ou girar, pode fazer um personagem andar ou o que quiser. No importando que evento seja, ele ocorre durante um ou ambos os mtodos de callback do FrameListener.

Main Rendering Loop

Uma tpica aplicao OGRE ir renderizar os frames um aps o outro, sem cessar (a menos que voc interrompa, claro). Vimos anteriormente o mtodo para invocar o render loop do OGRE: startRendering(). Entretanto, esse mtodo apenas inicia um pequeno loop que invoca outro mtodo: renderOneFrame(). A existncia deste ltimo mtodo importante por diversos motivos. Por exemplo, voc pode querer incorporar o OGRE em uma aplicao j existente ou em algum framework (o nosso caso, alis), onde seria complicado utilizar o mtodo startRendering(). importante resaltar que voc ainda pode utilizar as classes FrameListener com o mtodo renderOneFrame(). O mtodo renderOneFrame() , na verdade, o mtodo que notifica qualquer frame listener que esteja registrado junto ao Root. Em nosso framework base, utilizamos o mtodo renderOneFrame() juntamente com um frame listener, que a classe Application, assim, sempre que o mtodo renderOneFrame() chamado, ele notifica a classe Application que por sua vez executa o mtodo frameRenderingQueued(), o qual , em palavras simples, um intermedirio entre os mtodos frameStarted() e frameEnded() discutidos anteriormente . Abaixo temos um pequeno exemplo que objetiva lhe mostrar como voc pode implementar seu prprio render loop manual, e onde exatamente ele estaria situado no fluxo do seu cdigo.

31

// // // //

Faz tudo o que fizemos at agora a respeito da inicializao do OGRE: cria o Root, carrega plug-ins, cria o render window, scene manager, cmera e viewport, alm de colocar alguma coisa na cena.

bool keepRendering = true; while (keepRendering) { // processa eventos da rede em eventos do aplicativo // processa eventos de input em eventos do aplicativo // renderiza o prximo frame mRoot->renderOneFrame(); // // // // if } // Deleta objetos criados para liberar memria // Ento, finaliza o OGRE delete mRoot; verifica se deve sair do loop Nota: NextMessageInQueue() completamente fictcio sendo utilizado aqui apenas com fins ilustrativos Isso no existe no OGRE (NextMessageInQueue() == QUIT) keepRendering = false;

32

Gerenciamento dos Recursos de Media

Temos razes muito boas para utilizar o sistema de gerenciamento de recursos do OGRE ao invs de simplesmente carregar os recursos a partir de um arquivo no disco rgido quando requisitado. O primeiro velocidade: o acesso ao disco muito lento quando comparado ao acesso memria, de modo que no queremos exacerbar um j apertado tempo do frame carregando qualquer coisa do disco. Alm disso, no somente mais rpido ter dados carregados (potencialmente comprimidos), descompactados, e prontos para uso na memria, como tambm mais eficiente descarreg-los quando no forem mais necessrios, e traz-los de volte caso sejam necessrios novamente. Por fim, com o sistema de gerenciamento de recursos do OGRE, no precisamos carregar na memria, um por um, cada recurso que a aplicao possa precisar.

Gerenciamento de Recursos na Prtica

Abaixo temos uma cpia do arquivo resources.cfg que acompanha o OGRE SDK. Este arquivo utilizado pelo SampleBrowser para indicar a localizao dos recursos.
# Resources required by the sample browser and most samples. [Essential] Zip=../../media/packs/SdkTrays.zip FileSystem=../../media/thumbnails # Common sample resources needed by many of the samples. # Rarely used resources should be separately loaded by the # samples which require them. [Popular] FileSystem=../../media/fonts FileSystem=../../media/materials/programs FileSystem=../../media/materials/scripts FileSystem=../../media/materials/textures FileSystem=../../media/materials/textures/nvidia FileSystem=../../media/models FileSystem=../../media/particle FileSystem=../../media/DeferredShadingMedia Zip=../../media/packs/cubemap.zip Zip=../../media/packs/cubemapsJS.zip Zip=../../media/packs/dragon.zip Zip=../../media/packs/fresneldemo.zip Zip=../../media/packs/ogretestmap.zip Zip=../../media/packs/ogredance.zip

33

Zip=../../media/packs/Sinbad.zip Zip=../../media/packs/skybox.zip [General] FileSystem=../../media

Este arquivo praticamente auto-explicativo. Trs grupos de recursos so declarados e preenchidos: Essential, Popular e General. O grupo General sempre existe independente de ter sido declarado ou no. As definies de FileSystem e Zip descrevem o tipo de arquivo: FileSystem indica um recurso do tipo que baseado numa localizao no sistema de arquivos, enquanto que a definio Zip indica que o recurso baseado num arquivo compactado (do tipo .zip padro).

Localizao dos Recursos

Uma pergunta comum nos fruns Como posso definir a localizao de um recurso sem utilizar o resources.cfg?. Vejamos ento a implementao do mtodo addResources() da classe Manager, que l o arquivo resources.cfg mostrado anteriormente.
Ogre::ConfigFile cf; cf.load("resources.cfg"); Ogre::ConfigFile::SectionIterator seci =cf.getSectionIterator(); Ogre::String secName, typeName, archName; Ogre::ResourceGroupManager *rgm = Ogre::ResourceGroupManager::getSingletonPtr(); Ogre::ConfigFile::SettingsMultiMap *settings; while (seci.hasMoreElements()) { secName = seci.peekNextKey(); Settings = seci.getNext(); Ogre::ConfigFile::SettingsMultiMap::iterator i; for (i = settings->begin(); i != settings->end(); ++i) { typeName = i->first; archName = i->second; rgm->addResourceLocation(archName, typeName, secName); } }

34

Este cdigo simplesmente itera sobre cada seo no arquivo (neste caso, as sees so tambm os nomes dos grupos: Essential, Popular e General), e para cada seo, itera cada par de nome/valor. Para cada par de nome/valor, chamado o mtodo addResourceLocation() do ResourceGroupManager. O primeiro mtodo a ser observado o addResourceLocation(). Pode ser mais fcil observar a analogia entre o cdigo e o arquivo de configurao, no exemplo hard-coded abaixo.
Ogre::ResourceGroupManager *rgm = Ogre::ResourceGroupManager::getSingletonPtr(); rgm->addResourceLocation( "../../media/packs/SdkTrays.zip", "Zip", "Essential"); "../../media", "FileSystem", "General"); "../../media/fonts", "FileSystem", "General");

rgm->addResourceLocation(

rgm->addResourceLocation(

// e assim por diante, para o resto dos caminhos no arquivo

Perceba que todos os exemplos esto utilizando caminhos relativos. O OGRE no tem qualquer problema com caminhos absolutos, porm, se voc utiliz-los, seu programa correr o risco de no funcionar em outra mquina que no seja a sua, uma vez que voc no poder garantir que todos os computadores estaro organizados da mesma forma que o seu. Ento, faa um favor a si mesmo e utilize caminhos relativos para localizar seus recursos.

Inicializao dos Recursos

Uma vez que voc tenha definido a localizao dos seus recursos, voc ter que inicializa-los antes de utiliz-los na aplicao ( por isso que temos o mtodo loadResources() na classe Application do framework base). Voc deve tambm ter criado pelo menos um RenderWindow antes de tentar inicializar seus recursos, uma vez que fazer o parser dos scripts, poder criar recursos que utilizam a GPU, os quais requerem um contexto de renderizao para que venham a existir.

35

Ogre::ResourceGroupManager *rgm = Ogre::ResourceGroupManager::getSingletonPtr(); // initialize all of the previously defined resource groups rgm->initialiseAllResourceGroups(); // or, alternately, initialize the defined resource groups // one at a time rgm->initialiseResourceGroup("General"); rgm->initialiseResourceGroup("Essential"); rgm->initialiseResourceGroup("Popular");

No cdigo acima, o primeiro exemplo inicializa todos os grupos que ainda no foram inicializados. J o segundo exemplo inicializa apenas os grupos especificados, um de cada vez.

Descarregamento de Recursos

Voc pode descarregar um recurso (individualmente ou por grupos) da memria qualquer momento; se o recurso estiver referenciado em outro lugar no seu cdigo quando voc descarreg-lo, ele ser recarregado na prxima vez que for utilizado. O OGRE, ento, ir preveni-lo de desacrregar permanentemente um recurso que ainda esteja em uso, de modo a salv-lo de uma situao potencialmente ruim (pelo menos em termos de recursos relacionados a aplicaes 3D). O cdigo abaixo mostra como descarregar um grupo de recursos atravs da interface ResourceGroupManager:
Ogre::ResourceGroupManager *rgm = Ogre::ResourceGroupManager::getSingletonPtr(); rgm->unloadResourceGroup("Popular", true); rgm->unloadUnreferencedResourcesInGroup("Popular", true);

Como j mencionado, a interface carrega e descarrega recursos de um nico grupo a cada vez. Este cdigo apenas descarrega os recursos da memria; ele no remove as instancias desses recursos. O mtodo unloadUnreferencedResourcesInGroup() ir descarregar somente os recursos para os quais no existe qualquer referncia.

36

Dispositivos de Entrada
Neste captulo, iremos estudar como se d a utilizao da biblioteca OIS (Object Oriented Input System) em conjunto com o Framework base. O Framework elaborado neste curso tem uma arquitetura flexvel, de modo a suportar futuras expanses ao uso de dispositivos no-convencionais, como o Wiimote, Kinect, Dispositivos Hpticos, Joysticks etc. Por agora, vamos nos limitar aos dois dispositivos mais comuns: Mouse e Teclado.

Biblioteca de Input

A OIS uma biblioteca open-source, multiplataforma, que suporta diversos dispositivos de interface com o ser humano, como mouse e teclado (suporta outros dispositivos tambm, no abordados neste curso). Para integrar a OIS no Framework base, basta incluir no seu projeto (Additional Include Directories, no VC++) o diretrio $(OGRE_HOME)\include\. Nas bibliotecas a serem linkadas (Additional Dependencies), inclua a lib OIS.lib. Adicione os arquivos InputManager.cpp e InputManager.h ao seu projeto (arquivos enviados por email). Como o propsito deste curso no abordar a uma biblioteca de input, e sim uma biblioteca de renderizao, no entraremos nos detalhes da OIS. Por agora, basta saber que o InputManager funcionar para o framework como uma caixa-preta, onde iremos apenas utilizar seus mtodos.

Input Manager e Input Listener

A OIS utiliza bastante o Design Pattern Observer (ou Listener) o qual permite que uma classe seja notificada sempre que determinados eventos ocorrerem. No nosso caso, desejamos que o Manager seja notificado pela OIS sempre que ocorrerem os seguintes eventos: Tecla pressionada; Tecla liberada; Mouse movido; Boto do mouse pressionado; Boto do mouse liberado. 37

Como o intuito do Framework fazer com que o programa seja escrito na camada Application, fizemos com que a tarefa de lidar diretamente com a OIS fique a cargo do Manager, atravs de um subsistema chamado de Input Manager. Assim, a classe Manager ser o Listener de eventos gerados pelo mouse e teclado. O Manager poder, ento, notificar a classe Application a respeito desses eventos. Para isso devemos fazer com que o Manager herde as classes OIS::MouseListener e OIS::KeyListener. Assim, no Manager.h, faa

#include InputManager.h

class Manager : public OIS::MouseListener, public OIS::KeyListener { // cdigo anterior do Manager; };

Aps fazer do Manager o nosso Input Listener, devemos herdar e implementar alguns mtodos pure virtuals das classes OIS::MouseListener e OIS::KeyListener. A declarao da assinatura destes mtodos deve ser feita na Manager.h. Esses mtodos sero chamados sempre que o evento correspondente acontecer.

protected: // Private methods inherited from OIS. virtual bool mouseMoved (const OIS::MouseEvent &arg); virtual bool mousePressed (const OIS::MouseEvent &arg, OIS::MouseButtonID id); virtual bool mouseReleased (const OIS::MouseEvent &arg, OIS::MouseButtonID id); virtual bool keyPressed (const OIS::KeyEvent &arg); virtual bool keyReleased (const OIS::KeyEvent &arg);

Adicionalmente, na classe Manager, voc pode criar um atributo-ponteiro para a classe Input Manager. Dessa forma fica mais fcil acessar sua instancia (quando estiver declarada, obviamente). Ou, ao invs, voc poderia acessar sua instancia 38

diretamente atravs de seu mtodo Singleton (a classe Input Manager implementa o Design Pattern Singleton). Para criar o atributo ponteiro, apenas faa:
InputManager *mInputMgr;

Agora precisamos criar obter uma instancia vlida do Input Manager, registrar o Manager como um Input Listener e por ltimo, porm no menos importante, escutar por eventos a cada frame. Para isso, no mtodo setup(), em qualquer lugar aps a criao do Render Window, faa:

01 02 03 04 05 06 07 08 09

mInputMgr = new InputManager(); mInputMgr->initialise(mRenderWindow, true); mInputMgr->setWindowExtents (mRenderWindow->getHeight(), mRenderWindow->getWidth()); mInputMgr->addKeyListener(this, "MyKeyListener"); mInputMgr->addMouseListener(this, "MyMouseListener");

Na linha 01, criada a instncia do Input Manager. A linha seguinte inicializa o subsistema, passando como parmetro o Render Window (pois este representa a janela na qual os eventos sero recebidos); o segundo parmetro um valor boolean, onde se for verdadeiro, o aplicativo mantm (ou seja, no oculta) o mouse nativo do sistema operacional. Se for falso, o mouse nativo ocultado, podendo ceder espao a um mouse com cone personalizado, como veremos no captulo GUI com SdkTrays. Na linha 04 definida a rea til na qual os eventos sero recebidos. As linhas 08 e 09 registram o Manager (ponteiro this) como um Key Listener e Mouse Listener, respectivamente. Agora necessrio implementar os mtodos que foram herdados. Perceba que o cdigo abaixo mostra a implementao de cada mtodo, e veja tambm que automaticamente chamamos o evento correspondente na classe Application (embora os mtodos correspondentes na Application s sero implementados nos prximos passos).

39

01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

bool Manager::mouseMoved(const OIS::MouseEvent &arg) { return mApp->mouseMoved(arg); } bool Manager::mousePressed(const OIS::MouseEvent &arg, OIS::MouseButtonID id) { return mApp->mousePressed(arg, id); } bool Manager::mouseReleased(const OIS::MouseEvent &arg, OIS::MouseButtonID id) { return mApp->mouseReleased(arg, id); } bool Manager::keyPressed(const OIS::KeyEvent &arg) { return mApp->keyPressed(arg); } bool Manager::keyReleased(const OIS::KeyEvent &arg) { return mApp->keyReleased(arg); }

Aps implementar estes mtodos, para finalizar a integrao do Input Manager com o Manager, precisamos: Escutar os dispositivos a cada frame; Redimensionar a rea vlida para o mouse, quando a janela for redimensionada; Deletar o Input Manager ao finalizar o Aplicativo.

importante ressaltar que a OIS no utiliza threads ou qualquer outro tipo de mgica para escutar os dispositivos. Sendo assim, necessrio verificar os estados do mouse e do teclado a cada instante. O melhor modo de fazer isso escutando-os a cada frame (este o modo de entrada buffered, caso voc resolva fazer suas prprias pesquisas no assunto). No mtodo update(), coloque:
mInputMgr->capture();

40

Para redimensionar a rea de atuao do mouse ao redimensionar a janela, no mtodo WindowResized(), adicione:
mInputMgr->setWindowExtents(rw->getWidth(), rw->getHeight());

No mtodo shutdown(), aps deletar o mApp, adicione:

if (mInputMgr)->capture(); delete mInputMgr;

Aps isso, basta implementar o mtodos correspondentes na Application. A declarao da assinatura destes mtodos deve ser feita na Application.h. Esses mtodos sero chamados atravs do Manager, sempre que o evento correspondente acontecer.

public: bool mouseMoved (const OIS::MouseEvent &arg); bool mousePressed (const OIS::MouseEvent &arg, OIS::MouseButtonID id); bool mouseReleased (const OIS::MouseEvent &arg, OIS::MouseButtonID id); bool keyPressed (const OIS::KeyEvent &arg); bool keyReleased (const OIS::KeyEvent &arg);

No Application.cpp, esses mtodos sero utilizados para responder a aes do mouse e do teclado. Abaixo temos um exemplo de implementao.

01 02 03 04 05 06 07 08 09 10

bool Application::mouseMoved(const OIS::MouseEvent &arg) { return true; } bool Application::mousePressed(const OIS::MouseEvent &arg, OIS::MouseButtonID id) { return true; }

41

11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

bool Application::mouseReleased(const OIS::MouseEvent &arg, OIS::MouseButtonID id) { return true; } bool Application::keyPressed(const OIS::KeyEvent &arg) { return true; } bool Application::keyReleased(const OIS::KeyEvent &arg) { return true; }

42

Materials
TODO.

Scene Management
TODO.

Ferramentas de Produtividade
TODO.

Animao
TODO.

GUI com SdkTrays

TODO.

Estudo de Caso
TODO.

43

Hot tips
TODO.

Dvidas comuns
TODO.

Exportao com o Blender

TODO.

44