O Irrlicht, para quem não conhece, é uma engine 3D robusta, leve e (até certo ponto) fácil de aprender e programar, sendo por isso, muitas vezes, comparada às melhores engines proprietárias dos mercado de jogos. Ah, e é claro, o Irrlicht é muito melhor que essas “enginezinhas” pagas por aí porque ele é 100% software livre!

Logotipo do Irrlicht

Se quiser saber mais do que o Irrlicht pode fazer clique aqui, dê uma olhada na lista de funcionalidades, depois abra uma IDE e volte aqui no blog para começar a aprender de uma vez por todas! ;-)

Eu vou utilizar aqui o Irrlicht 1.8. Para instalá-lo no Fedora:

Terminal
# yum install irrlicht18 irrlicht18-devel

Para outros sistemas, a wiki deve ajudar.

Bom, vamos à parte legal (o código :) ). O Irrlicht foi criado inicialmente para ser utilizado com a linguagem C++, mas já existem bindings para várias outras (p. ex.: Python, Java, Ruby, Pascal, .NET, Delphi, Lua, …). Eu prefiro C++ mesmo, então é com ela que eu vou mostrar os exemplos aqui.

Como qualquer aplicativo em C++, precisamos de uma função main():

// Tudo o que é necessário do Irrlicht está nesse aquivo
#include <irrlicht.h>

// Outros includes necessários
#include <iostream>

// Esses são os namespaces mais usados do Irrlicht e para facilitar
// o trabalho vamos colocá-los aqui
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace gui;

// Uma função main() como qualquer outra, nenhuma novidade aqui
int main(int argc, char *argv[])
{
    // Cria um "device", que é responsável por criar a janela de renderização
    // Os parâmetros passados para esse método do Irrlicht normalmente são encontrados
    // nas telas de configuração dos jogos, mas aqui eu vou deixar fixo (hard-coded)
    // por enquanto.
    IrrlichtDevice *device = createDevice(
        EDT_OPENGL,  // driver de vídeo a ser utilizado, eu prefiro o OpenGL
        dimension2d<u32>(640, 480), // tamanho da janela (largura = 640 e altura = 480)
        16,          // bits de cores a ser utilizado (deixei 16 só para testar),
        false,       // fullscreen? para jogar é legal, mas pra programar nem um pouco
        false,       // stencilbuffer? não vamos utilizar sombras ainda, é desnecessário
        false,       // vsync? mesma coisa, por enquanto não vamos utilizar
        NULL         // IEventReceiver, vamos utilizar mais adiante para receber eventos
    );

    // Validações nunca são demais
    if (device == NULL) {
        std::cerr << "Não foi possível inicializar o Irrlicht" << std::endl;
        return EXIT_FAILURE;
    }

    // Obtém referências diretas para alguns objetos muito acessados
    IVideoDriver  *driver = device->getVideoDriver();
    ISceneManager *scnmgr = device->getSceneManager();

    // Esse é o loop principal, ou seja, o aplicativo ficará dentro
    // desse while até que a janela seja fechada.
    while (device->run()) {
        driver->beginScene(true, true, SColor(255.0f,100.0f,100.0f,140.0f));
        scnmgr->drawAll();
        driver->endScene();
    }

    // Libera a memória alocada pelo aplicativo:
    // - para TODOS os objetos criados utilizando algum método do Irrlicht que
    //   começa com "create" você realmente DEVE utilizar o método drop();
    // - quanto aos outros objetos do Irrlicht: simplesmente esqueça, não é sua
    //   responsabilidade deletá-los;
    // - quanto aos seus objetos alocados dinamicamente, esses você deve deletar.
    device->drop();

    return EXIT_SUCCESS;
}

O que fizemos até agora foi só criar uma tela azul (essa pelo menos é uma tela azul do bem). Antes de continuar, vamos testar (assim você já encontra possíveis erros no código e também já vê como se compila o arquivo linkando com a biblioteca do Irrlicht). No Linux, isso é tão simples quanto:

Terminal
$ g++ exemplo.cpp -oexemplo -I/usr/include/irrlicht18 -lIrrlicht18$ ./exemplo

Se você conseguiu compilar, parabéns, agora você já conhece como criar 0,005% de um jogo. Caso contrário, revise o código e o comando acima (dependendo do sistema, os diretórios onde se encontram o irrlicht.h e a biblioteca dinâmica podem ser diferentes). Qualquer dúvida, deixe um comentário.

Agora chegamos na parte que (eu acho) é a mais chata: design. Não adianta nada nós criarmos o código do jogo se não tivermos nada nele. Na minha opinião de programador, criar toda a inteligência artificial dos personagens do jogo é milhares (ou milhões) de vezes mais fácil que criar os personagens. Um designer obviamente irá pensar completamente o oposto.

E já vou adiantando também que essa é uma área da qual eu (ainda) não entendo absolutamente nada. Mas como eu já disse antes, o Irrlicht é software livre, então eu posso e vou utilizar os modelos dos exemplos do site do Irrlicht.

O Irrlicht reconhece muitos formatos de modelos 3D, que podem ser carregados facilmente. A lista completa é extensa, mas você pode ver aqui. Quer uma lista resumida?

.3ds .smf .b3d .csm .dae .xml .dmf .x .mdl .irrMesh .lwo .obj .ms3d .my3d .oct .mesh .lmts .bsp .md2 .md3 .ply .stl

Eu vou utilizar, nesse exemplo, o modelo dwarf. Para continuar, você precisa baixar os dois arquivos a seguir e salvar na mesma pasta onde se encontra o arquivo que estamos editando (exemplo.cpp). BAIXAR: modelo e textura.

Tendo os dois arquivos salvos, agora só precisamos carregar o modelo na cena e aplicar a textura. Isso é feito logo antes do loop principal (while (device->run() {…}).

    // carrega o modelo do arquivo dwarf.x
    IAnimatedMesh *mesh = scnmgr->getMesh("./dwarf.x");
    if (mesh == NULL) {
        std::cerr << "Não foi possível carregar o modelo." << std::endl;
        device->drop();
        return EXIT_FAILURE;
    }

    // adiciona o modelo carregado à cena
    IAnimatedMeshSceneNode *node = scnmgr->addAnimatedMeshSceneNode(mesh);
    if (node) {
        // define uma animação predefinida do modelo para ser executada
        node->setMD2Animation(scene::EMAT_STAND);
        // carrega a textura dwarf.jpg que será aplicada ao modeolo
        node->setMaterialTexture(0, driver->getTexture("./dwarf.jpg"));
    }

    // adiciona uma luz na posição (15,-25,0) com a cor (1,0.6,0.7,1) e raio 500
    scnmgr->addLightSceneNode(0, vector3df(15.0f,-25.0f,0.0f), SColorf(1.0f, 0.6f, 0.7f, 1.0f), 500.0f);

    // adiciona a câmera na posição (-10,50,-90) voltada para (10,10,30)
    scnmgr->addCameraSceneNode(0, vector3df(-10.0f,50.0f,-90.0f), vector3df(10.0f,10.0f,30.0f));

Compile e execute com o mesmo comando utilizado anteriormente.

Et voilà! Temos o nosso anão esbravejando e brandindo seu machado :)

Exemplo renderizado no Irrlicht

Espero que essa introdução básica seja útil para quem pensa em desenvolver aplicativos utilizando o Irrlicht no futuro, como eu mesmo que ainda estou aprendendo. Bons estudos!

Com as tags → 

One Response to Brincando com o Irrlicht

  1. Raul José Chaves disse:

    Cara muito massa esse exemplo, o início é sempre o mais cruel e tu ajudou um monte, wlw

Plataforma Wordpress 3.8 (GPLv2)
Tema PageLines Lite Improved (GPLv3)
Hospedado por OpenShift by RedHat
Domínio registrado pela Neep Host
Creative Commons Attribution-ShareAlike License
Copyleft © 2014 Eduardo Weiland
Utilize um leitor de QR Code para acessar o blog no seu celular:
21
%d blogueiros gostam disto: