Nociones Básicas Sobre OGRE. Parte 1.

A partir de este momento, voy a comenzar con una pequeña introducción a este motor gráfico, para aquellos en programación que no hayan “trasteado” todavía mucho con el, y además, servirá también como introducción para los nuevos. Espero que lo encuentren interesante.

Para simplificar un poco este material, me voy a enfocar mas en la parte de las clases y métodos que tiene el motor, y voy a asumir lo siguiente:

1. Tienen OGRE compilado.
2. Saben como configurar un proyecto para OGRE (librerías y opciones de compilación)

Bueno, comencemos.

I. Como crear una ventana de Render e inicializar una escena: Las clases Root, RenderWindow, SceneManager, Camera y Viewport

En OGRE, la clase mas importante es Root, es el punto de inicio para cualquier aplicación en la que queramos utilizar este motor grafico, se encarga del acceso a los diferentes sistemas de render, administracion de las configuraciones guardadas, bitácora (log), y acceso a otras clases del sistema. Básicamente es el núcleo (raíz) del sistema para todas las clases y objetos diferentes que se utilizan en OGRE (cámaras, efectos, etc.)
Antes de poder realizar cualquier operacion en este motor, es necesario crear una instancia de Root de la siguiente manera:

mRoot = new Ogre::Root();

Una vez echo esto, es necesario seleccionar que sistema para Render utilizaremos (Open GL o Direct X) y crea una ventana de Render (RenderWindow) del tamaño que queramos para poder mostrar algo en pantalla. Podemos indicarle manualmente a OGRE que sistema utilizaremos por medio de los metodos mRoot->getAvailableRenderers(), mRoot->setRenderSystem(RenderSystem *system) y el tamaño y nombre de nuestra ventana por medio de mRoot->createRenderWindow(…). Sin embargo, esto puede ser un poco engorroso, sobre todo si queremos estar cambiando que render usaremos y las dimensiones de nuestra ventana. Pero teniendo en cuenta esto, los diseñadores de OGRE han dotado a la clase Root de algunas funciones extra para facilitarnos la vida, estas son mRoot->showConfigDialog(), que muestra una ventana de configuración (en windows), o le pregunta al usuario (en linux), para seleccionar que sistema utilizaremos y el tamaño de nuestra ventana de una pequeña lista de configuraciones, y después podemos crear automáticamente la ventana por medio del metodo mRoot->initialise(true). Esta función además devuelve un valor de true si aceptamos los valores en el cuadro, o false si cancelamos/cerramos el cuadro, así que podemos utilizar esto para cancelar la carga de la aplicación si lo deseamos. He aquí el código:

    if (!mRoot->showConfigDialog())
    {
        exit = true
    }

Ahora que ya tenemos una ventana de render, necesitamos elegir que tipo de escenario vamos a utilizar, esto debido a que según el tipo de escenario hay diferentes manejadores de escenario optimizados para los diferentes tipos de “geometría” y “objetos” que pongamos en el. En OGRE contamos con los siguientes:

ST_GENERIC
ST_EXTERIOR_CLOSE
ST_EXTERIOR_FAR
ST_EXTERIOR_REAL_FAR
ST_INTERIOR

Para la mayor parte de aplicaciones, el manejador ST_GENERIC nos servirá bien, los demás tienen aplicaciones mas especificas y por el momento para el propósito de este tutorial no los tocaremos. A continuación pongo el código que nos permite seleccionar el manejador:

    mSceneMgr = mRoot->createSceneManager(Ogre::ST_GENERIC);

El siguiente paso, será crear una cámara desde donde veremos la escena. Esto lo hacemos por medio del metodo mSceneMgr->createCamera(), después es necesario que la coloquemos en algún lugar y que apunte hacia algún lugar de la escena, además de definir el Near Clip Distance, que es la distancia que habrá de la pirámide de visión (frustum) a la pantalla, y el Far Clip Distance, que seria el horizonte de visión:

    mCamera = mSceneMgr->createCamera("CamaraPrincipal");
    mCamera->setPosition(Ogre::Vector3(0.0f, 0.0f, 500.0f));
    mCamera->lookAt(Ogre::Vector3(0.0f, 0.0f, 0.0f));
    mCamera->setNearClipDistance(5.0f);
    mCamera->setFarClipDistance(5000.0f);

Como pueden notar en el código de arriba, le hemos dado nombre a la Cámara, esto debido a que OGRE nos permite tener múltiples cámaras al mismo tiempo, pudiendo definir complejos sistemas que utilicen estas cámaras para obtener vistas diferentes de la escena, así que es necesario para diferenciar una cámara de otra.
Necesitamos agregar la cámara que acabamos de crear a la ventana de render. Para esto, vamos a crear un viewport enlazado a la cámara, con fondo de color negro:

    mViewport = mWindow->addViewport(mCamera);
    mViewport->setBackgroundColour(Ogre::ColourValue(0.0f, 0.0f, 0.0f));

Finalmente, debemos decirle a ogre que comienze el despliegue

mRoot->startRendering(); 

y poco después, que elimine mRoot cuando no lo necesitemos mas (para evitar fugas de memoria):

    delete mRoot;

y eso es todo, tendremos una primera aplicación básica, que no hace mucho mas de inicializar los sistemas, y desplegar una ventana en negro.

A continuación pongo un código de ejemplo que encapsula toda la funcionalidad que expliqué anteriormente dentro de una clase llamada OgreApp. Dentro de esta clase hay un método llamado go(), que será  llamado después de crear la instancia de la clase, y que realiza toda la secuencia de pasos necesaria para nuestra aplicación:

Archivo OgreTutorial1.h

#include "Ogre.h"

class OgreApp
{
public:

    Ogre::Root* mRoot;
    Ogre::RenderWindow* mWindow;
    Ogre::SceneManager* mSceneMgr;
    Ogre::Camera* mCamera;
    Ogre::Viewport* mViewport;
    bool exit;

    OgreApp()
    {
        exit = false;
        mRoot = NULL;
        mWindow = NULL;
    }

    ~OgreApp()
    {
        if (mRoot != NULL)
            delete mRoot;
    }

    void go()
    {
        createRoot();
        setupRenderSystem();
        if (exit == true)
            return;
        else
        {
            createRenderWindow();
            createScene();
            startRenderLoop();
        }
    }

    void createRoot()
    {
        // Crea el objeto root, la base de todo el sistema de OGRE
        mRoot = new Ogre::Root();
    }

    void setupRenderSystem()
    {
        // Mostrar cuadro de dialogo para elegir sistema de render
        // y resolucion de la ventana
        if (!mRoot->showConfigDialog())
        {
            exit = true;
        }
    }

    void createRenderWindow()
    {
        // Crea una ventana por defecto, con un titulo especificado
        mWindow = mRoot->initialise(true, "Mi Aplicacion con OGRE");
    }

    void createScene()
    {
        // Elegir manejador de escenario
        mSceneMgr = mRoot->createSceneManager(Ogre::ST_GENERIC);

        // Crear camara y posicionarla en el espacio
        mCamera = mSceneMgr->createCamera("CamaraPrincipal");
        mCamera->setPosition(Ogre::Vector3(0.0f, 0.0f, 500.0f));
        mCamera->lookAt(Ogre::Vector3(0.0f, 0.0f, 0.0f));
        mCamera->setNearClipDistance(5.0f);
        mCamera->setFarClipDistance(5000.0f);

        // Agregar camara al viewport
        mViewport = mWindow->addViewport(mCamera);
        mViewport->setBackgroundColour(Ogre::ColourValue(0.0f, 0.0f, 0.0f));

    }

    void startRenderLoop()
    {
        // Comenzar el despliegue
        mRoot->startRendering();
    }

};

Archivo OgreTutorial1.cpp

#include "OgreTutorial1.h"

#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
#define WIN32_LEAN_AND_MEAN
#include "windows.h"

INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT )
#else
int main()
#endif
{
    OgreApp* app = new OgreApp();
    app->go();
    delete app;

    return 0;
}

El código anterior tiene una falla, ¡No hay forma de salir de la aplicación, ni con Ctrl-C ni con ESC, más que matando el proceso! Esto es debido a que no hemos definido el mecanismo de entrada/salida por teclado todavía. En la siguiente entrega veremos algo sobre los FrameListener, que nos permitirán definir la manera para poder salir de nuestra aplicación y además definir un sistema básico para manejar el teclado y el ratón mediante la librería OIS.

Actualización 19/Jul/2008: He añadido los enlaces a las instrucciones a como compilar OGRE y configurar un proyecto. Además he actualizado el ejemplo para que funcione con Ogre 1.4.x (fue un cambio mínimo, una línea, pero de todas formas es importante).

Actualización 26/Jul/2008: He modificado el artículo original y el código fuente que originalmente había publicado, para que se pueda adaptar mejor al código que usaré en las siguientes lecciones .