Ogre Developer

Novo console brasileiro

2010-02-01T14:52:00.001-08:00

Olá galera, os brasileiros estão entrando na onda da construção de consoles e isso é muito bom. Após a iniciativa da Tec Toy com o console Zeebo, agora vem chegando o Zipper.

O projeto: O Zipper foi idealizado em 20 de outubro de 2008 por Marcelo Antônio Oliveira Santos incialmente com o nome de PGC (PC Game console) e teve que ser cancelado por motivos tecnicos. Mais tarde, em 8 de janeiro de 2010 o projeto foi reativado, desta vez com o nome de Zipper. Desta vez o console além de ganhar um nome diferente, foi modificado para atualizar a sua proposta que agora passava a estar ultrapassada.

De início o console deixou de ser de 128 bits e passou a ser de apenas 64 bits, essa mudança foi necessária para que o Zipper pudesse atingir sua principal meta, agora era de criar um console totalmente produzido no Brasil e que fosse além de leve e compacto, algo barato e que cada pessoa de baixa renda possa ter em casa. Usando o microcontrolador ATmega644 da Atmel essa meta para o console se torna mais fácil uma vez que este componente pode ser usado como GPU, CPU, Processador e memória economizando espaço e gasto com outras peças e tendo um ótimo rendimento tanto quando ao Custo x Benefício quanto no Tamanho x Capacidade.

Assim o console consegue atingir a qualidade gráfica de um SNES original com a praticidade de um video game portatil como o PSP, tecnologia totalmente brasileira e custo igual ao de um console pirateado isso para a primeira versão do console. O objetivo da equipe de produção é de atingir uma qualidade de 128 bits igual como a proposta no início, usando a tecnogia wirelles e outras tecnologias muito avançadas presentes no ramo atualmente, claro que isso para a versão final.

Como se não bastase a ousadia destes brasileitos que estão produzindo o console, sabe-se que já na primeira versão, o Zipper contará com joystick com forma nova e revolucionaria para evitar lesões e problemas causados por alguns destes joysticks atuais e também que o console contará com um super design inovador e muito bonito.

Mais informações sobre o projeto: http://zipper.noads.biz/

Iniciante 03 - Lights e Shadows [Tutorial]

2009-10-19T10:27:00.000-07:00

Olá pessoal, td bem com vocês?
Bom neste tutorial iremos aprender a manipular sombras e luzes com ogre 3d, algumas pessoas me pediram para dar exemplos praticos durante as aulas e acaterei o pedido dessas pessoas apartir deste tutorial.
Antes de começar a falar sobre luzes e sombras eu vou ensinar como incializar o ogre pela classe de exemplos que o ogre disponibiliza, porém esta classe é limitada e serve apenas para demostrações e portanto servirá para o nosso tutorial mais tarde eu ensinarei como iniciar o ogre manualmente, o que não nos é necessario por enquanto.
Voltando ao que interessa eu vou supor que você esteja usando o visual c++ express edition e que tenha lido meu tutorial de como instalar e configurar uma aplicação para ogre 3d em visual c++ (aqui). Crie um novo projeto e configure-o para rodar com ogre 3d, no arquivo main.cpp adicione o código :

#include "Ogre.h"
#include "ExampleApplication.h"

class SampleApp : public ExampleApplication
{

public:
SampleApp()
{}

protected:

void createScene(void)
{
Entity* ent = mSceneMgr->createEntity("robot","robot.mesh");
SceneNode* node = mSceneMgr->getRootSceneNode()->createChildSceneNode("robotnode");
node->attachObject(ent);
}

};

int main(int argc, char **argv)
{
SampleApp app;
app.go();
return 0;
}

Supondo também que você leu o tutorial sobre entities e scene nodes você deve saber que as linhas 15, 16 e 17 criam e atacham uma entidade a um node. O resto é responsavel pela incialização pela classe de exemplo, como não precisamos mais que esta classe se você quiser fazer algum teste apenas modifique a função createScene(void).

Agora vamos realmente falar sobras luzes e as sombras:

A luz é um elemento fundamental em jogos 3d, é ela que define o estado do nível, ela pode dar um ar mais "Dark" quanto um ar mais "Light". No ogre 3d as luzes podem ser de três tipos:

Point - Luz que ilumina em todas as direções, no struct de luzes do ogre é representada por LT_POINT.
Spotlight - Esse tipo de luz é otimo para criar luzes com direção definida com curto alcance com por exemplo uma lanterna ou farol de carro, no ogre é representada por LT_SPOTLIGHT.
Directional - Esse tipo de luz serve para criar luzes com certa direção e de longo alcance e é muito utilizada para simular a luz do sol ou da lua, no ogre representada por LT_DIRECTIONAL.

Genericamente uma luz no ogre é cria pela função createLight(name) pelo objeto do scene manager onde name é o nome da luz a ser criada.
Agora vamos a parte prática, adicione na função createScene(void) o código seguinte:
Light* light0 = mSceneMgr->createLight("Light0");
light0->setType(Light::LT_POINT);
light0->setPosition(Vector3(0,1500,0));
A função createLight() como já vimos cria a luz, o método setType() é responsavel por definir o tipo da luz nesse caso Point e setPosition() define posição da luz no mundo 3d.
Agora adicione isso:
light0->setDiffuseColour(0.0, 0.0, 1.0);
light0->setSpecularColour(0.0, 0.0, 1.0);
Nesse caso nós alteramos a cor de reflexão difusa e especular da nossa luz. As luzes directional e spot light funcionam quase desta forma, não vou exemplifica-las aqui mas você pode testar as seguintes funções na sua luz (sempre mudando o tipo):

Para Directional:

light0->setType(Light::LT_DIRECTIONAL); //define o tipo da luz pra directional
light0->setDirection(Vector3(0,-1,1)); //define a direção pra -1 no eixo y e 1 no eixo \

Para SpotLight:

light0->setType(Light::LT_SPOTLIGHT); //define o tipo da luz pra spotlight
light0->setDirection(Vector3(-1,-1,0)); //define a direção pra -1 no eixo x e -1 no eixo y
light0->setSpotLightRange(Degree(70),Degree(150)); //determina o raio do emisor ou do inicio como 70 graus e o raio do receptor ou final em 150 graus.

Sobre luz é só isso. Agora que ja estudamos luz e ja temos uma luz padrão no nosso jogo, nos podemos estudar as sombras, então vamos lá:
Sombras são elementos que aumentão o realismo de um jogo, mas para isso requerem mais processamento gráfico, daí em computadores sem placas/adaptadores de video o jogo usando tecnicas avançadas de shadow pode travar constatemente. O ogre possui 6 tipos de sombra mas alguns não são muito usados por isso vamos estudar apenas os principais que são 3:

Modulative Texture Shadows - são sombras borradas e sem muito realismo, na verdade é o tipo de sombra mais simples no ogre e nele é representado por SHADOWTYPE_TEXTUTE_MODULATIVE.
Modulative Stencil Shadows - é um tipo de sombra bem definido de mais qualidade, algumas pessoas dizem que é o meio termo de sobras no ogre mas particulamente eu acho que esse é o melhor tipo, este é representado por SHADOWTYPE_TEXTURE_STENCIL.
Aditive Stecil Shadows - esse metodo cria uma sombra para cada light na cena, por isso é considera por muitos o melhor tipo no ogre 3d, neste é representada por SHADOWTYPE_ADITIVE_STENCIL.

O método da sombra é definido pela função setShadowTechinique(Type) do objeto Scene Manager onde Type deve ser um dos tipos anteriores, já quando você quiser que um objeto receba as sombras você deve chamar a função setCastShadow(bool) do objeto (entity, light, etc) onde bool deve ser true ou false indicando se deve ou não receber a sombra ou não. Agora vamos ao exemplo prático, adicione o seguinte código depois do metodo de criação da luz:
light0->setCastShadow(true);
mSceneMgr->setShadowTechinique(SHADOWTYPE_TEXTURE_STENCIL);
Plane plane(Vector3::UNIT_Y, 0);
MeshManager::getSingleton().createPlane("ground",ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,plane,1500,1500,0,0,true,1,5,5,Vector3::UNIT_Z);
Entity *entPlano = mSceneMgr->createEntity("chao","ground");
SceneNode *nodePlano = mSceneMgr->getRootSceneNode()->createChildSceneNode("chaoNode");
nodePlano->attachObject(entPlano);
entPlano->setMaterialName("Examples/Rockwall");
ent->setCastShadow(true);

Não se preocupe com os codigos das linhas 3 à 7, eles apenas criam um chão a qual vai receber as sombras para nós podermos visualiza-la. Assim finalizamos nossa aula de hoje, compile o código e teste as sombras e a iluminação, até a próxima!

Iniciante 02 - Entity e SceneNode [Tutorial]

2009-10-06T16:17:00.000-07:00

Olá, como vão vocês?

Bom nesta aula iremos falar sobre os dois objetos, acho que, mais utilizados quando trabalhamos com ogre 3d, são eles a entity e o scene node. Em primeiro lugar vamos entender como uma engine mostra um objeto na tela. Para exibir um objeto na tela é carregado um arquivo que contem as informações sobre verticies, malha e textura, esses comandos são carregados pela engine e execultados fazendo com que ele seja exibido, no ogre 3d não é tão diferente, nele os objetos 3d são compostos por três parte principais: entity, scene node e skeleton.

A entity (entidade) é a parte do objeto que armazena as informações da malha, é essa que o ogre vai exibir na tela, por outro lado o scene node (nó de cena) é a parte desse objeto que armazena as informações do tamanho, posição e varias outras coisas.

Um exemplo de entidade pode ser uma casa, uma arvore, um personagem... Outros objetos que parecem ser entidades como luzes, camera, particulas são na verdade um tipo de nó de cena.
As entidades são criadas pela função createEntity do método SceneManager onde seu primeiro parâmetro é o nome da entidade e o segundo o nome da malha a ser usada, essa no ogre 3d possue o formato .mesh e pode ser convertida com os principais modeladores como o 3d studio max e blender com exportadores disponibilizados na pagina do ogre 3d.

Por exemplo se eu quiser cria uma entidade com o nome robo usando a malha robot.mesh basta eu usar: Ogre::Entity* ent1 = mSceneMgr->createEntity("robo","robot.mesh"); onde mSceneMgr é o meu objeto do metodo Scene Manager. Neste caso o arquivo de malha robot.mesh deve estar contido no nosso resource group que estudaremos adiante, ainda sim se este objeto for animado, isto é, possuir um esqueleto (bones), ao exportar o seu arquivo além do .mesh será criado um chamado .skeleton este possui as informações sobre os bones e a animação da entidades, lembrando que este é carregado automaticamente ao criar uma entidade.

Os Scene Nodes são como disse anteriormente ponteiros que armazenam posição, tamanho e outra informações sobre a entidade, na verdade esse conceito é um pouco limitado visto que o Scene Node também suporta outros objetos além de entidades como cameras, luzes, particulas e até mesmo outro scene node. Para ser criado um Scene Node dever ser "filho" ou "child" de outro scene node, ao criar-se um objeto para o metodo Scene Manager um scene node padrão é criado e ele pode ser retornado pela função getRootSceneNode() do metodo Scene Manager, e para criar um scene node filho utiliza-se a função creatChildSceneNode() do método Scene Node. Você deve estar confuso, para entender melhor vejamos o exemplo abaixo que cria um Scene Node filho do scene node principal:
Ogre::SceneNode* node = mSceneMgr->getRootSceneNode()->createChildSceneNode("nome");
Como é possivel perceber todo scene node de ser filho de outro, todos os scene nodes que não necessitem necessariamente ser filho de outro deve ser criado como filho do scene node principal. É possível também criar um filho pra um scene node que é filho de outro e por ai vai, mas não necessitamos disso por enquanto, apenas precisamos saber o basico sobre eles.

Para uma entidade poder ser totalmente criada devemos relacionar ela a um scene node, caso contrario ela não vai ser inciada e portanto não aparecerá na tela. Agora precisamos de uma informação muito importante, se os scene nodes vão armazenar os dados da entidade, como relacionamos um ao outro? Sempre que quiser-mos relacionar um scene node a outro objeto usamos a função attachObject() do método Scene Node, neste caso para que a entidade do nosso exemplo pudesse aparecer teriamos que relaciona-la a o nosso objeto node para isso faria-mos:
node->attachObject(ent1);

Por hoje é só, agora nós ja podemos criar entidades e exibi-las na tela. Sintetisando tudo temos:

Entity (Entidade) - Parte do objeto 3d que cuida da malha.
Scene Node - Armazena os dados do objeto relacionado a ele.
Tendo que mSceneMgr é um objeto do método Scene Manager: mSceneMgr->createEntity("nome","arquivo_da_mesh.mesh") cria uma entidade
mSceneMgr->getRootSceneNode()->createSceneNode("nome") cria um scene node nome filho do scene node principal.
Tendo que mNode é um objeto contendo um scene node filho do scene node principal e mEnt um objeto contendo uma entidade:
mNode->attachObject(mEnt); relaciona a entidade mEnt ao scene node mNode.

Até a próxima!

Iniciante 01 - Conceitos básicos [Tutorial]

2009-09-17T15:46:00.001-07:00

Olá pessoal, tudo bem?

Bom, na nossa primeira aula do módulo inciante vamos aprender sobre os principais conceitos do ogre 3D que iremos trabalhar nas próximas aulas e aprender a configurar aplicações com ogre. É importante resaltar que o Ogre 3D não é um game engine, na verdade Ogre 3D é uma abreviação de Open Source 3D Graphics Engine que em nosso idioma quer dizer Engine Gráfica 3D de Código Aberto, ou seja, fica evidente que o Ogre 3D é um Render Engine. E o que isso quer dizer? Quer dizer que o Ogre é reponsavel pela parte visual do seu jogo, em outra palavras é o Ogre que vai mostrar a parte de video do jogo na tela, desta forma a parte física, input, gui, net e outras funções devem ser implementadas pelo programador.
Essa engine tem uma forma muito interresante de organizar, listar, exibir e criar objetos visuais: Através dos Scene Mangers ou Gerenciadores de Cena. Como dito anteriormente Scene Manager é a classe no ogre que manipula todo e qualquer objeto visual do seu jogo. Um scene manager é criado pela função:
Ogre::Root::createSceneManager(Ogre::String& typename)
Onde typename é o tipo de scene manager que você deseja criar, existem basicamente quatro tipo de scene manager, são eles:

ST_EXTERIOR_CLOSE: Usado em jogos que se passam, em sua maior parte, em ambientes abertos e não muito extensos.
ST_EXTERIOR_FAR: Esse deve-se usar para jogos de ambientes abertos e extensos.
ST_EXTERIOR_REAL_FAR: Deve-se usar esse em casos especiais, onde o ambiente é aberto e gigantesto como nos mundos do MMORPG. Mas nesse caso deve-se usar um plugin especial o Paging Scene Manager(PLSM2), ele é específico para a criação deste scene manager pois tem a funções necessárias para fragmentar seu mapa e blocos menores e carregar de acordo com a posiçã do player assim como em GTA e Lineage II.
ST_INTERIOR: Esse é usado na criação de mapas pequenos e fechados, e usa a tecnoligia BSP.

Bom agora que conhecemos a principal classe do Ogre 3D e seus conceitos, vamos aprender as configurações que todos os seus projetos usando o Ogre 3D devem obrigatoriamente usar.
Ao criar um projeto a qual queira usar o ogre de preferência crie um projeto do tipo console application pois você poderá ver a execução das funções do ogre e notificar a ocorrência de algum erro. Depois de criado você deve especificar caminhos onde existem arquivos que "informaram" à IDE que estamos usando o ogre, para isso siga esses passos:

Clique com o botão direito do mouse sobre no nome do seu projeto e depois escola a opção Properties.
Em Configuration escolha o método de compilação do seu projeto (release e debug).
Em Genaral procure a opção Output Directory, se escolheu release ponha "bin\release", se debug "bin\debug".
Em Debugging procure a opção Working Directory, coloque "bin\release" ou "bin\debug" a depender do que escolheu no passo 2.
Em C\C++ ache a opção Additional Include Directories e depois de clicar nela clique nos ... que aparecem ao lado, clique na pastinha e adicione esse diretório: "$(OGRE_HOME)\include" e depois com o mesmo processo adicione esse: "$(OGRE_HOME)\samples\include". Dê ok e volte à tela Properties.
Clique em uma pequena setinha ao lado de Linker e no submenu escolha General nesta ache a opção Additional Library Directories e clique nos ...., clicando na pastinha adicione o diretório "$(OGREVC_HOME)\lib". Dê ok e volte à tela Propeties.
Ainda no submenu de Linker, escolha Input e na opção Additional Dependencies adicione as blibliotecas "OgreMain.lib" e "OIS.lib" se escolheu release e "OgreMain_d.lib" e "OIS_d.lib" de debug.

Pronto seu projeto está configurado para rodar usando o Ogre 3D.

Por hoje é só! Sintetisando rápidamente o que foi aprendido hoje:
- Conceitos Básicos do Ogre 3D
- Configurando projetos com Ogre 3D

Até a próxima!

JokemPo Demo [Game]

2009-08-15T04:19:00.000-07:00

Oi galera tudo bem? Estou passando por aqui para deixar o link de download deste joguinho de pedra, papel e tesoura que eu começei a fazer neste final de semana, os graficos não ficaram muito bons já que meu talento com edição de imagens é quase nenhum :P

Bom é isso ai, tenham todos uma boa semana, divertam-se com o joguinho e até nossa proxima postagem...

Link do download [Binário]

Link do download [Source]

Instalando Ogre 3D + Visual C++

2009-08-15T04:13:00.000-07:00

Oi pessoal, estava aqui esses dias estudando ogre é me surgiu a necessidade de usar a engine de fisica PhysX que só funciona no VC++ por isso tive que começar a usa-lo obrigadamente, disse no tutorial passado que só iriamos usar o Code::Blocks aqui, mas não estejam a vontade pra escolher a IDE que achar melhor. Ensino a vocês nesse tutorial a instalar o Ogre 3D com o Visual C++ 2008.

Não é muito diferente, primeiro teremos que baixar o Ogre SDK para Visual C++, vá no na pagina de download da Ogre e escolha OGRE 1.6.2 SDK for Visual C++ .Net 2008 (9.0), depois execute o arquivo e siga os passos do assistente de instalação.

Agora temos que baixar o Visual C++ 2008, que pode ser encontrado no site da Microsoft ou Baixaki, após baixar execute o arquivo e siga os passos do instalador, não selecione nenhum pacote extra, e depois o instalador vai baixar o VC++ e instalar no seu computador...

Só isso? Não. Depois disso tudo teremos agora que instalar o directx_jun2007_redist para evitar problemas com execução e distorções na execução de nossos programas.

Pronto agora o Ogre está pronto para trabalhar com o Visual C++ 2008, se quiser pode parar por aqui mas se quiser testar o funcionamento do Ogre continue.

Abra o VC++, para isso Menu Iniciar->todos os programas->Microsoft Visual C++ 2008 Express Edition->Microsoft Visual C++ 2008 Express Edition.exe. Vá em File->New->Project, em Win32 escolha Win32 Console Application, ponha um nome no seu projeto e desmarque a caixa Create directory for solution:

Um assistente se abrirá, vá em Next, marque Empty project e desmarque Precompiled Header, clique em Finish.

Clique com o botão direito sobre o nome do seu projeto e depois em Properties, na nova janela clique em Debugging e em Work Directory ponha $(SolutionDir)$(ConfigurationName), clique em Ok:

Isso fará com que o VC++ execute o arquivo compilado corretamente, agora vamos adicionar o arquivo principal responsavel por inciar o programa. Procure e clique no botão , na nova janela escolha C++ file (.cpp) e mude o nome para main.cpp, clique em add:

Agora adicione o seguinte codigo a esse arquivo:

#include "Ogre.h"
#include "ExampleApplication.h"

class SampleApp : public ExampleApplication
{
public:
SampleApp()
{}

protected:

void createScene(void)
{
mSceneMgr->setSkyBox(true, "Examples/CloudyNoonSkyBox");

Light* myLight = mSceneMgr->createLight("Light0");
myLight->setType(Light::LT_POINT);
myLight->setPosition(0, 40, 0);
myLight->setDiffuseColour(1, 1, 1);
myLight->setSpecularColour(1, 1, 1);
}
};

int main(int argc, char **argv)
{
SampleApp app;

app.go();

return 0;
}

Esse codigo cria uma classe baseada no projeto de exemplo do Ogre e inicia o aplicativo sem nenhuma preocupação para o usuario, mas por outro lado possui algumas limitações porém como é apenas um teste não há problema, no proximo tutorial ensinarei como fazer isso. A função createScene é programada pelo usuario, nela nós criamos um ceú e uma luz, não se preocupe com os códigos nós os estudaremos mais adiante.

Agora vai em Project>Properties ou aperte Alt+F7, em Configuration selecione Debug, escolha General e mude o Output Directory para $(OGRE_HOME)\bin\Debug. Selecione Debugging e mude Working Directory para $(OGRE_HOME)\bin\Debug.

Selecione C/C++ e em Additional Include Directories coloque "$(OGRE_HOME)\samples\refappinclude";"$(OGRE_HOME)\samples\include";"$(OGRE_HOME)\include".

Em Linker selecione General, em Additional Library Directories coloque "$(OGRE_HOME)\lib". Agora em Input mude Additional Dependencies para OgreMain_d.lib OIS_d.lib e clique em Ok.

Pronto, agora basta apertar F5 no seu teclado e o programa será compilado e inciará automaticamente, se ocorrer o seguinte erro: "Este aplicativo não pôde ser iniciado porque não foi encontrado d3dx9_38.dll. A reinstalação do aplicativo pode corrigir o problema" aconselho que baixe esse arquivo e o descompacte, vá até a pasta onde instalou o OgreSDK na pasta bin e depois em Debug copie o arquivo que você baixou para ela. Se ainda não conseguiu executar o programa mande um email para marcelo_liliu@hotmail.com com sua dúvida.

Se quiser você pode fazer download do projeto pronto aqui. Até a próxima.

Instalando Ogre 3D + MinGW + Code::Blocks

2009-08-15T04:10:00.000-07:00

Oi pessoal, tudo bem com vocês? Bom esse é o nosso segundo contato e nele estarei ensinando o basico do basico: Instalar o Ogre 3D.

O Ogre 3D será responsavel por rendeninzar a tela de nossa aplicação. Para podermos usar o Ogre nós precisaremos de uma IDE e um compilador, você pode usar diversas aplicações para isso mas para meus tutoriais eu estarei usando Ogre 3D + MinGW + Code::Blocks como Render, compilador e IDE respectivamente.

Primeiros vamos baixar o compilador, vamos usar a versão 5.1.4 do MinGW que pode ser encontrada aqui. Depois de baixar o compilador, execute o arquivo. Dê Next, depois clica em I Agree, então aparecerá um tela onde você deve selecionar as seguintes opções MinGW base tools, g++ compiler e MinGW Make qualquer outra opção que estiver marcada, você desmarca e só deixa essas 3. Ele irá baixar os pacotes e depois instalar o compilador.

Depois de instalado temos que baixar o IDE, Code::Blocks. Usaremos a versão svn do code::blocks, não consegui acha-la no site oficial mas você pode baixa-la nesse link. Depois que baixar descompacta ele no teu disco local (aqui é C:/)

E agora por ultimo vamos baixar o Ogre, bom ele está disponivel em 2 versões o SDK e o source, neste tutorial usarei o Ogre SDK 1.61 (clique aqui para baixar). Depois que baixar, abra o execultavel e siga o wizard para instala-lo.

Agora vá na pasta onde você extraiu o Code::Blocks e execute o arquivo codeblocks.exe deve aparecer a seguinte tela:

[/caption]

Selecione GNU GCC Compiler e clique em Ok. Pronto o Ogre 3D já está devidamente instalado e configurado, essa proxima parte é opcional, nela verificaremos se o ogre está funcionando se não quiser testar pode parar por aqui.

Vá em File > New > Project, e seleciona Console Application.

Clica em Go, Next, seleciona C++ e dá Next.

Em Project Title põe o nome do projeto (pode ser teste), clica em Next e depois Finish.

Agora clica nesse botão: ou digita F9 no teclado. Esse botão compila e executa o arquivo, se aparecer uma tela preta com o seguinte texto: Hello world! Process returned 0 (0x0) execution time : 0.421 s Press any key to continue. Siginifica que está tudo funcionando corretamente.

Bom Pessoal é só isso, até a próxima,
Até mais.

Bem Vindos ao blog Ogre Developer

2009-08-15T04:09:00.000-07:00

Oi pessoal tudo bem? Bom, eu estarei postando aqui neste blog minha experiências com o Ogre 3D e disponibilizando tutoriais, open-sources e etc.

Minha iniciativa de fazer este blog é justamente por que estou começando no ogre e tenho muita dificuldade em achar material em português então quero dividir minhas dificuldades, duvidas e conquistas no Ogre 3D com vocês. Espero que vocês fiquem a vontade para tirar duvidas e comentar meus posts.

É só isso, então até a proxima galera!