OGRE Versión 1.

1 Introducción
OGRE (Object Oriented Graphics Engine) [1] es un motor de gráficos en 3D
multiplataforma que permite ejecutar aplicaciones 3D en diferentes sistemas
operativos con independencia del la biblioteca gráfica que se utilice. Permite
ejecutarse bajo DirectX o bien OpenGL. Está desarrollado bajo licencia LGPL por
lo que no se tiene que pagar por su uso y además existe una comunidad que
incluye numerosas módulos para diversas como para el soporte de sonido y física.
A diferencia de los motores de videojuegos, no está orientado a un tipo de
videojuegos en los que el usuario puede cambiar determinados personajes o
realizar limitados cambios en la codificación mediante la inclusión de una serie de
script (Multiverse [4]). Es básicamente una biblioteca que permite utilizar
OpenGL y DirectX a alto nivel permitiendo crear aplicaciones de modo sencillo,
además incluye ciertas facilidades como son la gestión del entorno mediante
escenas o la carga de modelos 3D desarrollados en programas de modelado.
Existen bibliotecas en más lenguajes como JMonkeyEngine [3] que permite
realizar un trabajo similar en java.
Existen otras bibliotecas que facilitan la carga de modelos 3D como es el
SDK del formato de intercambio FBX [2], no obstante, el uso de dichas
bibliotecas requiere de gran conocimiento de las mismas y además es necesario
realizar una gestión de las escenas, animaciones y representación de los modelos
de modo manual. Estas bibliotecas se limitan a facilitar el acceso a la información
de los modelos, pero todo el proceso de animación y renderizado debe hacerse
modo manual, por ello, es bastante complejo poder realizar un videojuego
limitándose a este tipo de bibliotecas. El trabajo que puedas realizar en un mes
con este tipo de bibliotecas se puede llevar a cabo en dos o tres días mediante
Ogre.

1
 J.M. Corchado, JF. De Paz
Versión 1.1

2 Entorno
El entorno que se va a utilizar para el desarrollo es Visual Studio 2008, en caso de
querer utilizar un entorno diferente, en la página
http://www.ogre3d.org/wiki/index.php/Installing_An_SDK [5], se tiene una
amplia descripción de para la instalación en diversos entornos.
En la sección de descargas de Ogre [1], se tiene el SDK disponible, se
selecciona prebuilt y a continuación se descarga la versión para el entorno que se
vaya a usar. Particularmente, la seleccionada ha sido OGRE 1.6.4 SDK for Visual
C++ .Net 2008 (9.0) [6]. Hay que fijarse en la versión si no se quieren tener
problemas al abrir los proyectos. Se descarga y se procede a instalar, no tiene
complicaciones.
En la página
http://www.ogre3d.org/wiki/index.php/The_Complete_Blanks_Guide_To_Using_
The_OGRE_SDK_AppWizard [7], se describe paso a paso la integración del
entorno con el SDK. Básicamente, lo único que hay que hacer es descargarse el
wizard de http://sourceforge.net/projects/ogreconglo/files/ [8], descomprimirlo y
ejecutar el js de la versión de visual studio que se disponga, particularmente
VC9_setup.js. Si se ejecuta este script bajo Windows Vista, abrir la consola en
modo administrador y escribir el comando. En XP se puede ejecutar con doble
clic.
Una vez instalado ya se dispone de la opción en el visual studio para crear
un proyecto Ogre tal y como se puede ver en la siguiente figura (Fig. 1).

Fig. 1. Proyecto Ogre

2
 OGRE Versión 1.1

3 Visión global de Ogre

En este apartado se va a realizar una visión global de Ogre mostrando el
funcionamiento del sistema de manera general y sus principales clases.
3.1 Root
Esta clase contiene el nodo raíz que almacena toda la información de las escenas.
Cuando se instancia esta clase, se inicia se inicia Ogre y cuando se destruye se
libera toda la información almacenada en la escena liberando de dicha tarea al
programador. Proporciona el punto de acceso a Ogre haciendo de fachada para
facilitar el uso. De esta clase van a colgar las escenas y las entidades que se
encuentran en ellas.
3.2 Recursos
Los objetos de las escenas se gestionan mediante ResourceGroupManager, esta
clase se encarga de localizar los objetos e iniciarlos. Los objetos usados en Ogre
son los siguientes:
 Mesh: Ogre permite importar modelos 3D a partir de ficheros. La
extensión de los ficheros suele ser .mesh y ya incorporan la animación
de los personajes. Los modelos se pueden cargar con el programa show
mesh para sí poder verlos sin necesidad de cargarlos en un programa
https://sourceforge.net/projects/showmesh/ [9] o bien usar CEGui
Mesh Viewer [10] que se puede descargar de la propia página de Ogre
http://www.ogre3d.org/index.php?option=com_content&task=view&id
=413&Itemid=133 [11]. Usar el segundo, se trata de un programa
hecho en Ogre como cualquier otra aplicación que podemos llevar a
cabo.
 Skeleton: ficheros con extensión .skeleton, están relacionados con los
ficheros .mesh para las animaciones.
 Material: extensión .material, se referencian normalmente también
desde los .mesh.
 GPU program: extensiones .program y .asm. Son instrucciones para la
GPU.
 Texture: ficheros de imagen.
 Compositor: extensión .compositor para hacer render de varias pasadas
y permitir hacer efectos.
 Font: los ficheros para las fuentes tienen extensión .fontdef
Todos estos objetos se cargan mediante la clase ResourceManager aunque
disponen de subclases específicas para cada una de ellas. Se suele utilizar esta
clase para generar recursos nuevos en lugar de usar uno existente.
3.3 Escena
En Ogre se disponen varias escenas simultáneas, la clase usada para gestionarlas
es SceneManager. En la escena se tendrán varios nodos que se distribuirán por la
escena SceneNode que se asociarán con Entidades Entity. Estas entidades serán
los elementos de la escena como los personajes. Mediante SceneNode se
realizarán las transformaciones de las Entidades y se permitirá realizar una

3
 J.M. Corchado, JF. De Paz
Versión 1.1

jerarquía de los nodos de la escena al cargar las entidades. Las entidades son
implementaciones de la clase MovableObject.
El funcionamiento habitual, es crear un nodo raíz de la escena, a
continuación se crea un nodo en la escena hijo y es donde se asocia una nueva
entidad, esta nueva entidad que se asocia con el nuevo nodo, puede ser un modelo
3D. En el siguiente código se puede ver un ejemplo:
//cargo el personaje en la escena
entityNinja = mSceneMgr->createEntity("Ninja","ninja.mesh");
entityNinja->setCastShadows(true);
mSceneMgr->getRootSceneNode()->createChildSceneNode()-
>attachObject(entityNinja);
Es fácil de seguir el código, como se puede ver, se crea una nueva entidad
Ninja, posteriormente, se crea una nodo que cuelga del nodo raíz de la escena y se
asocia con el objeto que contiene a la entidad del ninja. Más adelante se verán
ejemplos más básicos.
3.4 Arquitectura de OGRE
Ogre sigue una arquitectura jerárquica en la creación de los entornos tal y como se
puedo ver un poco en apartado de la Visión Global (3). Toda aplicación que se
cree seguirá una estructura similar a la mostrada en la siguiente figura (Fig. 2). En
la figura se puede ver el nodo raíz del árbol que contiene de hijos las posibles
escenas que se tienen en el programa. Las escenas tienen asociadas elementos
como las cámaras y luces. Las escenas están compuesta de un nodo raíz que tiene
a su vez, nodos hijos que se puede apilar jerárquicamente, así el nodo 1.1 es hijo
del nodo 1 que a su vez es hijo del nodo Raiz de la Escena1. Los nodos, están
asociados con entidades que suelen corresponderse con mallas cargadas de
modelos 3D.

4
 OGRE Versión 1.1

Listener
Nodo Raíz (FrameListener
(Root)
Luz 1
(Light)
Luz 2
Camara (Light)
(Camara)

Camara
(Camara)

Escena1 Escena2 Escena3

(SceneManager) (SceneManager) (SceneManager)

Entidad 1
(Entity) Nodo Raiz
(SceneNode)
Entidad 2 Animación
(Entity) (AnimationState)

Nodo 1 Nodo 2
(SceneNode) (SceneNode)
Entidad 1.1
(Entity)

Nodo 1.1
(SceneNode)

Fig. 2. Arquitectura OGRE

3.5 Ficheros de configuración

En Ogre existen diversos ficheros de configuración entre ellos hay que tener en
cuenta los siguientes:
1. Plugin.cfg: Establece la ruta a las DLL que contienen los diferentes
plugins.
2. Resources.cfg: En este fichero se establece la ruta a los diferentes
recursos que usa Ogre, para evitar así tener que usar rutas absolutas.

5
 J.M. Corchado, JF. De Paz
Versión 1.1

4 Primeros pasos
Existen varias posibilidades parar crear una aplicación, lo más fácil es usar la
plantilla por defecto ExampleApplication. La otra alternativa es bastante más
complicada y por ahora no se verá.
Como primer paso se va a crear un nuevo proyecto, para ellos seguimos
los siguientes pasos:
1. Abrimos el Visual Studio, tener en cuenta que si se está trabajando con
Windows Vista es mejor abrirlo como administrador para no tener
problemas con el acceso a disco.
2. Seleccionamos el proyecto Ogre tal y como se puede ver en la
siguiente figura (Fig. 3) y ponemos el nombre del proyecto, en este
caso ejemplo2.

Fig. 3. Proyecto Ogre

3. Sale el formulario (Fig. 4) para crear el proyecto, lo único que hay que
hacer es pulsar en siguiente

6
 OGRE Versión 1.1

Fig. 4. Formulario Ogre

4. En el siguiente cuadro (Fig. 5) se tienen dos alternativas, crear una

aplicación estándar o bien una aplicación mínima.

Fig. 5. Formulario Ogre Standard

5. Una vez pulsado en Finish, se generan las clases con el código

correspondiente que permite crear un pequeño ejemplo que carga un
modelo 3D ”ogrehead.mesh”. Por ahora, no miramos el código y nos
limitamos a ejecutar el código. Una vez ejecutado, se muestra el
siguiente cuadro de diálogo (Fig. 6).

7
 J.M. Corchado, JF. De Paz
Versión 1.1

Fig. 6. Configuración Ogre

6. Cambiamos lo que veamos oportuno, lo más recomendable es quitar la

opción de pantalla completa y le damos a Ok. Las demás opciones,
podemos probar peor mejor no activar demasiadas cosas para que no
vayan muy lentas las aplicaciones al menos en modo Debug. Si se
quiere intercambiar entre DirectX y OpenGL se puede ver que la
aplicación funciona en ambos. Una vez pulsado aceptar, al rato se nos
muestra el modelo 3D que se puede ver en la siguiente figura (Fig. 7).
Si se produce un error en la opción de DirectX que nos indique que nos
encentra la dll d3dx9_42.dll, he probado a descargar la DLL y copiarla
en el directorio debug y release del SDK pero daba un error de
ejecución, con la dll d3dx9_37.dll usada años anteriores funciona
perfectamente así que copiarla y cambiarle el nombre. Otra alternativa
según he leído es instalar las DirectX End-User Runtimes, no lo he
probado porque ocupa demasiado, la mejor alternativa es copiar la dll
http://www.microsoft.com/downloads/details.aspx?displaylang=en&Fa
milyID=04ac064b-00d1-474e-b7b1-442d8712d553 de Microsoft e
instalarlas.

8
 OGRE Versión 1.1

Fig. 7. Modelo 3D Ogre

Analizando un poco el código se puede ver que se tienen dos clases

ejemplo2FrameListener y ejemplo2App, tal y como se puede ver, el wizard
crea todo el código en los .h en lugar de en los .cpp, además genera demasiado
código para empezar por lo a partir de ahora, se crearán proyectos con la opción
de mínimo (Fig. 5), esto ayudará también a entender mejor el motor. Como idea
general, la subclase class ejemplo2FrameListener : public
ExampleFrameListener, es el equivalente a un listener que se usa en Java para
responder a los eventos del usuario, en este caso, se encarga de renderizar la
escena. Parte de una superclase que usa de plantilla. Más adelante, veremos cómo
usar esta clase para animar un personaje.
La otra clase que podemos encontrar es class ejemplo2App : public
ExampleApplication, redefine una serie de métodos de la superclase para
establecer la cámara y en la escena cargar el modelo y la luz de ambiente. Como
se puede ver, está todo definido en el fichero de cabecera, lo que no denota un
buen estilo de programación.
4.1 Ejercicio 1 (EscenaApp1)
El proyecto se llama EscenaApp. En función del ejemplo anterior, crear un nuevo
proyecto cuya clase principal se llame EscenaApp, y que tenga la siguiente
estructura:
#ifndef __EscenaApp_h_
#define __EscenaApp_h_

//no olvidar añadir $(OGRE_HOME)\samples\include en propiedades

de proyecto->C/c++-->general/directorios de inclusion
adicionales
#include "ExampleApplication.h"

9
 J.M. Corchado, JF. De Paz
Versión 1.1

class EscenaApp: public ExampleApplication

{
//datos miembro
protected:
Entity *ent1;
Entity *ent2;
Entity *ent3;

//funciones miembro
public:
EscenaApp();
~EscenaApp();

protected:
void createScene();
};

//si ya se ha incluido antes el .h entonces solo se declara el

nombre para que no de error de compilacion
#else
class EscenaApp;

#endif // #ifndef __EscenaApp_h_

No usar la opción de estándar, seleccionar la opción de mínima en el
cuadro de diálogo de la figura (Fig. 5). En los datos miembros *ent1,… cargar
las entidades correspondientes a modelos 3D que se pueden encontrar en la
carpeta media\models, cada uno que seleccione los tres que prefiera. Todo el
código se debe de incluir dentro de la función miembro createScene. Como
orientación para crear el primer objeto, el código necesario es el siguiente:
//creas un nuevo elemento
ent1 = mSceneMgr->createEntity( "Robot", "robot.mesh" );
//recuperas las posición del nodo principal en la escena y
creas un nodo hijo
SceneNode *node1 = mSceneMgr->getRootSceneNode()-
>createChildSceneNode( "RobotNode" );
//asocias el nodo con la entidad
node1->attachObject( ent1 );
De modo resumido, lo que se hace, es crear una entidad en la escena en
base a la maya robot.mesh, se almacena la dirección al modelo, a continuación
se crea en la escena un nuevo nodo hijo que cuelga del nodo raíz, y en ese nodo,
se asocia la entidad creada. Para los demás personajes, se puede proceder de
manera similar, probar a crear dos nodos más.
4.2 Ejercicio 2
Crear los nodos del ejercicio anterior con la siguiente jerarquía, dos de ellos que
sean hijos del nodo raíz y el otro que sea hijo de uno de los recién creado, el
mismo esquema que el mostrado en la figura (Fig. 2). Una vez hecho esto,
proceder a realizar transformaciones sobre los objetos, en particular sobre el nodo
padre y su hijo y comprobar los efectos.
El objetivo es ver que las transformaciones de un nodo padre afectan por
igual a todos los nodos hijos. Para realizar transformaciones usar los siguientes

10
 OGRE Versión 1.1

métodos de la clase SceneNode, scale, yaw, pitch, roll y translate

(escalado, rotación Y, rotación X, rotación Z, desplazamiento). Una vez hecho
esto, recuperar el ejemplo del apartado 4 (ejemplo2) e intentar interpretarlo. Ahora
ya deberíamos de ser capaces de comprenderlo.
Una vez interpretado el código, acudir a la superclase
ExampleApplication y mirar el flujo de invocación de las funciones miembro.
Ver que en el fichero .cpp que se tiene el método WinMain, se llama a la función
miembro go y analizar sobre todo la secuencia de llamada de las funciones
miembros ver método setup. Esto nos ayudará a comprender la sobrecarga de las
subclases que creemos.

11