• Nuevos y mas potentes compiladores de scripts
• Geometry shaders en OpenGL
• Antialiasing en texturas renderizadas, así como en ventanas
• Corrección de gamma  sRGB
• Soporte para Alpha to coverage support
• Un nuevo SceneManager, ”Portal Connected Zone’
• Soporte para Shador Map Parallel-Split
• Generación mejorada de tangente
• Máscaras de fundido Skeletal
• Nuevas opciones de carga en segundo plano
• Soporte para asignación de memoria (allocators) personalizada.

Existen más cambios que puedes revisar en: http://ogre.svn.sourceforge.net/viewvc/ogre/branches/v1-6/Docs/ChangeLog.html

Notas de migración: http://www.ogre3d.org/wiki/index.php/ShoggothNotes#Porting_notes

Página de descarga:

http://www.ogre3d.org/index.php?option=com_content&task=view&id=406&Itemid=149

Lo prometido es deuda, veremos ahora como realizar la entrada por medio de teclado y ratón usando la librería OIS. He decidido separar esta entrega en dos partes, entrada Unbuffered y entrada Buffered, esto para que no sea una lección muy larga, y porque también la forma en que se implementa una y otra es un poco diferente.

En la entrada Unbuffered se revisa constantemente el estado del teclado o ratón para verificar si hemos pulsado o no una tecla o botón. Si llegáramos a realizar alguna acción mientras no estamos revisando el teclado o ratón, ésta acción se pierde ya que no se guarda. Esto por lo general no afecta ya que la lectura se realiza varias veces por segundo, tantas como cuadros (Frame) realice nuestra aplicación.

Por el contrario, en la entrada Buffered, los eventos se reciben por medio de un mecanismo de llamadas (callback). Esto significa que cada vez que pulsamos una tecla o un botón del ratón, este evento se guarda en un área de memoria llamada buffer de eventos, de donde posteriormente son enviados a nuestra aplicación, y de esa forma nunca perdemos ninguna acción que realicemos.

Lo mas común es utilizar entrada Buffered para los menús y GUI’s de nuestra aplicación, y la entrada Unbuffered para todo lo demás, aunque eso también dependerá del tipo de cosas que queramos hacer. Recomiendo que prueben los dos, y decidan cual se adapta mejor a la tarea..

Ya que sabemos esto, ahora si podemos proceder a realizar el código para la captura de eventos por teclado y ratón. Para esto utilizaremos tres clases de OIS, InputManager, Keyboard y Mouse. La clase InputManager nos permite inicializar el sistema de entrada, diciéndole sobre que ventana queremos hacer la captura de eventos, para esto, necesitamos pasarle un “HANDLE” a la ventana, este handle lo vamos a obtener por medio de RenderWindow::getCustomAttribute(). Para que OIS acepte este handle, necesitamos convertirlo a un formato llamado OIS::ParamList. Es un poco difícil de explicar, así que mejor pongo a continuación el código completo que necesitamos para crear el InputManager.

size_t windowHnd;
OIS::ParamList pl;

// Obtenemos el handle a la ventana de render
mWindow->getCustomAttribute("WINDOW", &windowHnd);

// Convertimos el handle en un ParamList
std::ostringstream windowHndStr;
windowHndStr << windowHnd;
pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));

// Creamos nuestro Input Manager
mInputManager = OIS::InputManager::createInputSystem(pl);

Una vez creado nuestro InputManager, lo utilizaremos para crear los objetos mKeyboard y mMouse, que nos permitirán manejar el teclado y ratón respectivamente. El primer parametro representa el tipo de dispositivo, y el segundo parametro sera true para modo buffered, y false para unbuffered. Debemos hacer ademas una conversion (cast) para el tipo de entrada:

mKeyboard =  static_cast<ois::keyboard  *> (mInputManager->createInputObject(OIS::OISKeyboard, this->bufferedInput));
mMouse = static_cast<ois::mouse  *> (mInputManager->createInputObject(OIS::OISMouse, this->bufferedInput));

Listo! con esto ya hemos creado los objetos necesarios para capturar la entrada. Ahora, cada vez que necesitemos hacer la captura, debemos de llamar al método capture de los objetos Keyboard y Mouse, este codigo lo podemos poner en nuestro método FrameStarted():

mKeyboard->capture();
mMouse->capture();

Ahora, para saber que si pulsamos una tecla y cual fue, llamamos al método mKeyboard->isKeyDown(), en este ejemplo, vamos a comprobar si la tecla pulsada es ESC con el siguiente código:

if (mKeyboard->isKeyDown(OIS::KC_ESCAPE) == true)

Los códigos de teclado comienzan con KC_, para las teclas de cursor, su códigos serían:

1. Izquierda = KC_LEFT
2. Derecha = KC_RIGHT
3. Arriba = KC_UP
4. Abajo= KC_DOWN;

La mayoría de códigos son auto explicativos, Si quieres saber el resto de códigos de teclado, puedes verlos en el archivo OISKeyboard.h.

Para saber el estado del ratón, utilizamos el método mMouse->getMouseState(), que nos devuelve información sobre que botón del ratón hemos pulsado, y en que posición de la pantalla nos encontramos. En este caso queremos saber si hemos pulsado el botón izquierdo del ratón, podemos usar esta información directamente:

if (mMouse->getMouseState().buttonDown(OIS::MB_Left))

O podemos usar una variable intermedia para leer la información:

OIS::MouseState ms = mMouse->getMouseState();
if (ms.buttonDown(OIS::MB_Left))

Finalmente, antes de salir de nuestra aplicación, debemos destruir todo el sistema de entrada que hemos creado, esto lo hacemos con el siguiente código:

mInputManager->destroyInputObject(mKeyboard);
mInputManager->destroyInputObject(mMouse);
OIS::InputManager::destroyInputSystem(mInputManager);

Ahora, con esta información, vamos a modificar el código de la lección pasada para que podamos salir de nuestra aplicación cuando pulsemos ESC o el botón izquierdo del ratón. Añadiremos 4 variables a nuestra clase, mInputManager, mKeyboard, mMouse, y bufferedInput, esta última para que guardemos la elección de si queremos utilizar el modo buffered o el unbuffered.

También crearemos 5 métodos, primero initInputSystem(), en donde pondremos la inicialización del InputManager, luego initAllInputs(), que llamara a 2 métodos más initKeyboardInputs() e initMouseInputs(), que es donde crearemos los objetos que se encargaran del manejo de la entrada,  captureAllDevices(), en donde llamaremos a los métodos capture de los objetos mkeyboard y mMoiuse, eliminaremos el código en FrameStarted() que cerraba la aplicación pasados 3 segundos y agregaremos ahora la condición para salir del programa con ESC o botón izquierdo del ratón, y también agregaremos el código para destruir el sistema de entrada al finalizar la aplicación. A continuación les dejo el código completo con comentarios:

OgreTutorial3.H

#include "Ogre.h"
#include "OIS\OIS.h"

class OgreApp : Ogre::FrameListener
{
public:

    Ogre::Root* mRoot;
    Ogre::RenderWindow* mWindow;
    Ogre::SceneManager* mSceneMgr;
    Ogre::Camera* mCamera;
    Ogre::Viewport* mViewport;
    OIS::InputManager* mInputManager;
    OIS::Keyboard* mKeyboard;
    OIS::Mouse* mMouse;
    bool exit;
    bool bufferedInput;

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

    ~OgreApp()
    {
        if (mWindow != NULL)
        {
            if (mInputManager != NULL)
            {
                mInputManager->destroyInputObject(mKeyboard);
                mInputManager->destroyInputObject(mMouse);
                OIS::InputManager::destroyInputSystem(mInputManager);
                mInputManager = NULL;
            }
        }

        if (mRoot != NULL)
            delete mRoot;
    }

    void go()
    {
        createRoot();
        setupRenderSystem();
        if (exit == true)
            return;
        else
        {
            createRenderWindow();
            initInputSystem(false);
            initAllInputs();
            initEventHandlers();
            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 initInputSystem(bool bufferedMode)
    {
        size_t windowHnd;
        OIS::ParamList pl;

        Ogre::LogManager::getSingleton().logMessage("*** Iniciando OIS ***");
        bufferedInput = bufferedMode;
        // Obtenemos el handle a la ventana de render
        mWindow->getCustomAttribute("WINDOW", &windowHnd);

        // Convertimos el handle en un ParamList
        std::ostringstream windowHndStr;
        windowHndStr << windowHnd;
        pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));

        // Creamos nuestro Input Manager
        mInputManager = OIS::InputManager::createInputSystem(pl);

    }

    void initAllInputs()
    {
        initKeyboardInputs();
        initMouseInputs();
    }

    void initEventHandlers()
    {
        mRoot->addFrameListener(this);
    }

    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();
    }

    bool frameStarted(const Ogre::FrameEvent &evt)
    {
        // Capturamos la entrada
        captureAllDevices();

        // Comprobamos si pulsamos la tecla ESC
        if (mKeyboard->isKeyDown(OIS::KC_ESCAPE) == true)
            exit = true;

        // Comprobamos si pulsamos el boton izquierdo del raton
        OIS::MouseState ms = mMouse->getMouseState();
        if (ms.buttonDown(OIS::MB_Left))
            exit = true;

        if (exit == true)
            return false;
        else
            return true;
    }

    bool frameEnded(const Ogre::FrameEvent &evt)
    {
        return true;
    }

    void initKeyboardInputs()
    {
        Ogre::LogManager::getSingleton().logMessage("*** Iniciando entrada por teclado (Keyboard) ***");
        mKeyboard =  static_cast<OIS::Keyboard*> (mInputManager->createInputObject(OIS::OISKeyboard, this->bufferedInput));
    }

    void initMouseInputs()
    {
        Ogre::LogManager::getSingleton().logMessage("*** Iniciando entrada por raton (Mouse) ***");
        mMouse = static_cast<OIS::Mouse*> (mInputManager->createInputObject(OIS::OISMouse, this->bufferedInput));
    }

    void captureAllDevices()
    {
        if (mKeyboard != NULL)
        {
            mKeyboard->capture();
        }

        if (mMouse != NULL)
        {
            mMouse->capture();
        }

    }

};

OgreTutorial3.cpp

#include "OgreTutorial3.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;
}

En la siguiente entrega veremos como implementar el sistema de entrada Buffered. Por el momento es todo. Espero sus comentarios.

Actualización 13/Oct/2008: Modificado OIS::MouseButtonID::MB_Left por OIS::MB_Left para evitar un error de compilación en Linux.

Para aquellos que están en mi misma situación, se que esto les será de mucha utilidad. Pongo a su disposición la documentación de OGRE y OgreNewt compilada en formato CHM, disfrútenla y por favor, hagan un buen uso de ella

http://rapidshare.com/files/138069568/OgreAPIReference-1.4.9.chm

http://rapidshare.com/files/138075400/OgreNewtAPIReference.chm

Por allá me verán aportando mi granito de Arena,

Enlace: http://ogreros.forogeneral.es/board/index.php

Página de descargas:

http://www.emule-project.net/home/perl/general.cgi?l=17&rm=download

En esta lección veremos cómo podemos reaccionar a eventos en tiempo de ejecución dentro de OGRE, lo que nos permitirá salir de la aplicación o interactuar por medio del teclado / ratón. Para ello utilizaremos dos clases que vienen incorporadas dentro de esta librería: FrameListener y FrameEvent.

Pero, ¿Qué es un FrameListener? A continuación pongo la definición tal cual viene en la API (traducida, claro):

Un “listener” (oyente) es una interfaz diseñada para ser llamada cuando ocurren ciertos eventos. Esta clase (FrameListener) define la interfaz que se relaciona a eventos de cuadros (frame).

Lo anterior significa que si yo defino un FrameListener, mi aplicación sería capaz de realizar acciones entre cuadro y cuadro. Lo más común es utilizarlo para la captura de eventos de teclado y ratón, o para actualizar el movimiento y la posición de los diferentes objetos ya sea manualmente, o también por medio de alguna biblioteca de simulación de físicas, aunque no está limitado a esas tareas. Siempre que  tengamos alguna acción que queramos realizar en cada cuadro, entonces debemos utilizar un FrameListener.

La clase FrameListener contiene 2 métodos virtuales, frameStarted() y frameEnded(). El método frameStarted() es llamado al inicio del cuadro, antes de hacer la actualización de la escena, y el método frameEnded() es llamado después de haber hecho la actualización de la escena y antes de actualizar el siguiente cuadro. Ambos métodos regresan un valor boolean, que le indica al motor gráfico si debe seguir actualizando, o salir del ciclo de actualización (render). Si no re-definimos estos métodos, el valor por defecto es true, o sea, seguir actualizando.

Los métodos frameStarted() y frameListener() tienen además un parámetro de tipo FrameEvent. Este FrameEvent no es mas que una estructura que contiene información acerca del evento, básicamente el tiempo transcurrido (en segundos) desde el último evento (timeSinceLastEvent) y el tiempo transcurrido desde el último cuadro (timeSinceLastFrame). La diferencia entre uno y otro valor es que el primero nos cuenta el tiempo que ha pasado de frameStarted() a framEnded() y viceversa, y el otro el tiempo de frame a frame, o sea de frameStarted() a frameStarted() y de frameEnded() a frameEnded().

Una vez que hemos definido una clase para que sea nuestro FrameListener, necesitamos “registrarla” para que OGRE sepa de su existencia, esto lo hacemos mediante el método addFrameListener() de nuestra clase Root. OGRE además nos permite el uso  de múltiples FrameListener si así lo deseamos, pero cada uno que definamos siempre debemos recordar utilizar addFrameListener() para registrarlo y poderlo utilizar. Muchos programadores separan la lógica de su programa en varios FrameListener, pero nosotros, por simplicidad de esta lección, utilizaremos solo uno.

Con esta información, ya podemos hacerle una mejora a nuestro programa que nos permita salir pasados 3 segundos.

Para empezar, modificamos la definición de la clase de nuestra lección anterior (OgreTutorial1.h) de forma que nos quede de la siguiente manera:

class OgreApp : Ogre::FrameListener

Después añadimos la siguiente variable a nuestra clase, que nos permitirá contar el tiempo que ha transcurrido

Ogre::Real mTime; 

Añadimos además el siguiente método a nuestra clase, que nos permitirá registrar nuestro FrameListener()

    void initEventHandlers()
    {
        mRoot->addFrameListener(this);
    }

Utilizamos el puntero this ya que la clase de nuestra aplicación es a su vez nuestro FrameListener, pero como mencionaba antes, es posible hacerlo en una clase separada, en cuyo caso, podríamos hacer algo como lo siguiente:

fl = new MiFrameListener();
mRoot->addFrameListener(fl);

Definimos nuestros métodos frameStarted() y frameEnded(), y vamos a agregar el código para que pasados 3 segundos, salga de la aplicación. Para esto, vamos a cambiar nuestra variable exit a true si es que han pasado mas de 3 segundos, y como mencionamos antes, necesitamos que regrese un valor de false para indicar que no queremos que siga actualizando el despliegue. En este caso haremos la comprobación al inicio del cuadro, pero podríamos hacerlo al final si lo deseáramos, esto ya dependerá de lo que queramos y necesitemos hacer en nuestra aplicación.

    bool frameStarted(const Ogre::FrameEvent &evt)
    {
        // Incrementamos nuestro contador de tiempo
        mTime += evt.timeSinceLastFrame;

        // Verificamos si han pasado mas de 3 segundos y salimos
        if (mTime > 3)
            exit = true;

        if (exit == true)
            return false;
        else
            return true;
    }

    bool frameEnded(const Ogre::FrameEvent &evt)
    {
        return true;
    }

Finalmente vamos a añadir 2 líneas nada mas, initEventHandlers(); dentro del método Go(), antes de crear nuestra escena para registrar nuestro FrameListener, y mTime = 0 dentro de createScene(), para que el contador de tiempo comience de cero.

A continuación pongo el código completo.

OgreTutorial2.h

#include "Ogre.h"

class OgreApp : Ogre::FrameListener
{
public:

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

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

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

    void go()
    {
        createRoot();
        setupRenderSystem();
        if (exit == true)
            return;
        else
        {
            createRenderWindow();
            initEventHandlers();
            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 initEventHandlers()
    {
        mRoot->addFrameListener(this);
    }

    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));

        // Inicializando el contador de tiempo.
        mTime = 0;

    }

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

    bool frameStarted(const Ogre::FrameEvent &evt)
    {
        // Incrementamos nuestro contador de tiempo
        mTime += evt.timeSinceLastFrame;

        // Verificamos si han pasado mas de 3 segundos y salimos
        if (mTime > 3)
            exit = true;

        if (exit == true)
            return false;
        else
            return true;
    }

    bool frameEnded(const Ogre::FrameEvent &evt)
    {
        return true;
    }

};

OgreTutorial2.cpp

#include "OgreTutorial2.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;
}

Ahora, si ejecutan esta aplicación verán que termina sola pasados 3 segundos, ya no necesitamos matar el proceso.

Por el momento es todo. Dejaremos para la siguiente lección el uso de OIS para la entrada por teclado, ya que es algo extenso y complejo, y no quiero alargar mucho este tema. Espero sus comentarios.

Para empezar, creamos un nuevo proyecto con Visual Studio, aquí tenemos dos opciones, podemos crear una aplicación de consola o un proyecto win32, recomiendo una aplicación win32 si es que estas comenzando a utilizar este motor gráfico. El otro modo (consola) puede sernos útil para la depuración, ya que aparecerá información en la ventana de consola sobre la carga de OGRE, pero aunque no tengamos la salida por consola, podemos revisar el archivo ogre.log, que contiene toda esa información y nos puede en determinado momento indicar que parte esta fallando de nuestro programa. Si queremos cambiar de aplicación win32 a aplicación de consola y viceversa en un proyecto ya creado, podemos irnos a “proyecto /`propiedades / propiedades de configuración / vinculador / sistema / susbsistema”

Cualquiera que sea la opción que elijamos, lo siguiente será decirle que queremos un proyecto vacío.

Una vez que hayamos creado el proyecto, lo siguiente será configurarlo para que podamos compilar un proyecto.

Nos vamos al menú “Proyecto / Propiedades” (alt-F7) y luego en el cuadro de dialogo que se abre, nos vamos a  “propiedades de configuración / depuración /directorio de trabajo” y ahí le diremos cual es el directorio de nuestro archivo ejecutable. Esto es muy importante para que podamos depurar/ejecutar desde dentro de Visual Studio, pues de otra forma nos marcaría error a la hora de querer ejecutarlo.

En ese mismo cuadro, nos vamos a “c++/ general /Directorios de inclusión adicionales” y ahí pondremos los directorios include de OGRE separados por comas, en mi caso, ya que utilizo la versión source de OGRE, son los siguientes:

C:\ogre\OgreMain\include;C:\ogre\Dependencies\include

Si además piensas utilizar CEGUI (una librería para diseñar GUIS que se acopla muy bien con OGRE, tienes que añadir el siguiente:

C:\ogre\Samples\Common\CEGUIRenderer\include

Si piensas hacer los tutoriales básicos del OGRE Wiki, necesitarás añadir además de los anteriores:

C:\ogre\Samples\Common\include

Si utilizas el SDK, los directorios son un poco diferentes, verifica cuáles son en tu caso.

Lo siguiente es configurar los directorios en donde se encuentran las librerías (bibliotecas) , esto es en la opción “vinculador / general / directorios de bibliotecas adicionales” :

C:\ogre\lib;C:\ogre\Dependencies\lib\Release

Si vas a usar la versión Debug de las dependencias de OGRE, cambia Release por Debug

y por ultimo añadimos los nombres de las librerías que vamos a utilizar, esto lo hacemos en “vinculador / entrada / dependencias adicionales”, pero en este caso, a diferencia de los directorios, deben ir separadas con espacios.

Para el modo Release:

OgreMain.lib OIS.lib

Para el modo Debug:

OgreMain_d.lib OIS_d.lib

Si pensamos utilizar CEGUI, añadimos además:

Modo Release: OgreGUIRenderer.lib CEGUIBase.lib

Modo Debug: OgreGUIRenderer_d.lib CEGUIBase_d.lib

Después (copiamos) los archivos resources.cfg y plugins.cfg al directorio de nuestro ejecutable, que se encuentran dentro de la carpeta \ogre\Samples\Common\bin\Release y también copiamos todos los archivos dll que se encuentran en esa carpeta:

CEGUIBase.dll
CEGUIExpatParser.dll
CEGUIFalagardWRBase.dll
cg.dll
OgreGUIRenderer.dll
OgreMain.dll
OIS.dll
Plugin_BSPSceneManager.dll
Plugin_CgProgramManager.dll
Plugin_OctreeSceneManager.dll
Plugin_ParticleFX.dll
RenderSystem_Direct3D9.dll
RenderSystem_GL.dll

También necesitamos modificar el archivo resources.cfg para que pueda encontrar los archivos de recursos (modelos, texturas, shaders, etc.) este archivo es un simple archivo de texto que podemos abrir con el bloc de notas o cualquier otro editor de texto, y vamos a sustituir los path relativos por path absolutos para evitarnos de problemas de que no encuentre algún archivo de recursos, en mi caso sustituí todos los “../../../” por “C:/ogre/Samples/” quedándome el contenido así:

# Resource locations to be added to the 'boostrap' path
# This also contains the minimum you need to use the Ogre example framework
[Bootstrap]
Zip=C:/ogre/Samples/Media/packs/OgreCore.zip

# Resource locations to be added to the default path
[General]
FileSystem=C:/ogre/Samples/Media
FileSystem=C:/ogre/Samples/Media/fonts
FileSystem=C:/ogre/Samples/Media/materials/programs
FileSystem=C:/ogre/Samples/Media/materials/scripts
FileSystem=C:/ogre/Samples/Media/materials/textures
FileSystem=C:/ogre/Samples/Media/models
FileSystem=C:/ogre/Samples/Media/overlays
FileSystem=C:/ogre/Samples/Media/particle
FileSystem=C:/ogre/Samples/Media/gui
FileSystem=C:/ogre/Samples/Media/DeferredShadingMedia
Zip=C:/ogre/Samples/Media/packs/cubemap.zip
Zip=C:/ogre/Samples/Media/packs/cubemapsJS.zip
Zip=C:/ogre/Samples/Media/packs/dragon.zip
Zip=C:/ogre/Samples/Media/packs/fresneldemo.zip
Zip=C:/ogre/Samples/Media/packs/ogretestmap.zip
Zip=C:/ogre/Samples/Media/packs/skybox.zip

Finalmente añadimos un archivo nuevo a nuestro proyecto de Visual Studio con la opción “Agregar Nuevo elemento / Archivo C++”. este archivo deberá tener una estructura parecida a la siguiente:

#include <Ogre.h>
// Las siguientes lineas solo las necesitas para los Tutoriales del Wiki
// una vez que hayas aprendido lo basico, se recomienda crear tu propio Framework
#include <ExampleApplication.h>
#include <ExampleFrameListener.h>

#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
#define WIN32_LEAN_AND_MEAN
#include "windows.h"
INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT )
//Si utilizas el modo consola, cambia la linea anterior por la siguiente
//int main(int argc, char **argv)
#endif
{
	return 0;
}

Y listo! Finalmente tenemos configurado un proyecto para utilizar OGRE.

Como comentario final, recomiendo trabajar con la versión Release de OGRE, ya que la versión Debug es mas lenta, y generalmente no la necesitaremos, a menos que queramos depurar dentro del código fuente de OGRE, pero esto no significa que no podamos depurar nuestro programa, aun lo podemos hacer, solo que si hay un error interno en OGRE, no podremos encontrar la línea exacta de este, pero este caso es raro, por lo general, si hay algún error es por parte nuestra y no del código de OGRE .

Nota: Si no les aparece el directorio del ejecutable para que copien las dll y los archivos de configuración de OGRE, y que además puedan indicar el directorio de trabajo para la depuración, hagan una compilación (generar solución) para que el directorio sea creado, y entonces si podrán hacerlo. O creen el directorio manualmente.

Sigue leyendo el artículo para ver la guía completa

1. Descarga los paquetes necesarios de la siguiente dirección, en la parte que dice Current Stable, son dos paquetes, Ogre Source For Windows y  Visual C++ .NET 2008 precompiled dependencies:

http://www.ogre3d.org/index.php?option=com_content&task=view&id=412&Itemid=132

Enlaces directos en caso de que no sepas cual bajar

http://downloads.sourceforge.net/ogre/ogre-v1-6-0.zip

http://downloads.sourceforge.net/ogre/OgreDependencies_VC9_Eihort_20080203.zip

2. Descomprimir los archivos descargados anteriormente en tu disco duro, el archivo de dependencias debes descomprimirlo en la misma carpeta en que se encuentre OGRE

3. Descarga e instala Direct X SDK 9.0 en su ultima versión de la siguiente dirección (esto solamente si piensas utilizar el Render para Direct X, OpenGL no lo necesita, es una descarga grande, como 400 MB:

http://msdn.microsoft.com/directx

Por lo regular al instalar DirectX se configura automáticamente, en caso de no ser así, quizás tengamos que añadir manualmente los directorios manualmente, podemos verificarlo en el menú Herramientas/ Opciones/ Proyectos y soluciones/ Directorios de Visual C++

Archivos de inclusión:

C:\Archivos de programa\Microsoft DirectX SDK (March 2008)\Include

Archivos de biblioteca:

C:\Archivos de programa\Microsoft DirectX SDK (March 2008)\Lib\x86

Si no aparece lo anterior, debemos añadirlo, el nombre del directorio puede cambiar ligeramente según la versión de DirectX SDK que hayan descargado, en mi caso, tengo la de marzo del 2008.

4. Abre el archivo ogre\Ogre_vc9.sln en visual Studio 2008,

5. Compilamos finalmente la solución, con Generar/Generar Solucion (F7), un detalle, recomiendo que compiles en modo release, a menos que necesites depurar el código fuente de OGRE, cosa que no recomiendo mucho ya que la ejecución será mas lenta.

Espero que esta información les sea de utilidad

Actualizado 10/Nov/2008: Actualizado los enlaces y las instrucciones, para utilizar la versión más reciente de OGRE (1.6.x), además de aclarar específicamente que debes descomprimir los archivos de OGRE, para aquellos que no lo pudieron deducir

Freetype 2.3.5
Cg 2.0
FreeImage 3.10.0

Si quieres una lista completa de las correcciones que incluye esta versión de mantenimiento, visita la página de noticias de OGRE. Que esperas para descargarlo

Visual Studio Express 2008