La verdad es que la lista en cuestión viene cargada de auténticas novedades.

Disfrutarla y Feliz Año Nuevo!!

Vamos a utilizar Ubuntu Linux 9.10 pero para cualquier sistema operativo los pasos serían similares.

Antes que nada habría que instalar todas las dependencias que nos van a hacer falta:

cmake–> como novedad ogre 1.7 usa ahora cmake para su compilación
libfreeimage3–> librería gratuita para acceder a ficheros gráficos como jpeg o png
libboost –> son opcionales, aunque yo os recomiendo su uso
libzzip-dev–> librería para acceder a ficheros zip. Fundamental si queremos compilar los ejemplos.
subversion–> cliente subversion para poder bajar el código fuente de los repositorios ogre3d

Instalamos todas las dependencias con nuestro gestor de paquetes habitual, aptitude, synaptic, apt-get, etc. y bajamos el código fuente:

cd directorio_donde_queramos_los_fuentes
svn co https://svn.ogre3d.org/svnroot/ogre/trunk ogre

Una vez descargado tenemos dos opciones.

La del impaciente. Vamos al directorio ogre y tecleamos lo siguiente:

cmake -G "Unix Makefiles"
make -j2

El primer comando nos genera los ficheros makefile y el segundo los compila. Recuerda que el número -j2 indica los procesos que quieres usar. Si tienes un dual core. Puedes poner 3 ó 4 por ejemplo.

La siguiente opción sería usar cmake-gui.
Una vez que cargue el frontal cmake, en la parte superior indicaremos el directorio donde tenemos el código fuente.
En la siguiente caja indicaremos donde queremos compilarlo.
Podéis poner el mismo trayecto.

Pinchamos sobre configure y luego sobre generate y ya podríamos compilar con “make”

Las opciones del diálogo tienen su propia ayuda, pero como más destacable vamos a mencionar CMAKE_BUILD_TYPE, en la que podríamos usar los siguientes parámetros:

Debug –> Compila Ogre3D en modo depuración
Release –> Compilación para ejecución óptima
RelWithDebInfo –> Compilación para ejecución óptima pero con información de depuración incluida.
MinSizeRel –> Ejecución óptima pero de mínimo tamaño.

Lo mejor o peor de la situación es que yo no he hecho nada, así que he decidido que no tengo ganas de seguir peleando ni escribiendo, ¿para qué? nadie lo iba a poder leer de todas formas:

Adjunto el listado del mini frame listener para terminar los artículos, si es que hay alguien que me sigue:

class MyFrameListener: public FrameListener {
 
public:
 
	// ctor/dtor
	MyFrameListener(RenderWindow* win) : mWindow(win){
		OIS::ParamList pl;
		size_t windowHnd = 0;
		std::ostringstream windowHndStr;
 
		m_timeElapsed = 0.0f;
 
		win->getCustomAttribute("WINDOW", &windowHnd);
		windowHndStr << windowHnd;
		pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
 
		mInputManager = OIS::InputManager::createInputSystem(pl);
		mKeyboard
				= static_cast<OIS::Keyboard*> (mInputManager->createInputObject(
						OIS::OISKeyboard, false));
	}
	virtual ~MyFrameListener() {
	}
 
	// We will provide some meat to this method override
	virtual bool frameStarted(const FrameEvent &evt);
 
	// We do not need to provide a body for either of these methods, since
	// Ogre provides a default implementation that does just this. However, for
	// the sake of illustration, we'll provide one here.
	virtual bool frameEnded(const FrameEvent &evt) {
		return true;
	}
	virtual bool processUnbufferedKeyInput(const FrameEvent& evt) {
 
		if(mWindow->isClosed()) return false;
		if (mKeyboard->isKeyDown(OIS::KC_ESCAPE)) //si pulsamos escape salimos de la aplicacion
			return false;
 
		return true;
	}
 
	// Override frameRenderingQueued event to process that (don't care about frameEnded)
	bool frameRenderingQueued(const FrameEvent& evt) {
		mKeyboard->capture();
 
		if( !mKeyboard->buffered() )
			if( processUnbufferedKeyInput(evt) == false )
				return false;
 
		return true;
	}
protected:
	OIS::InputManager* mInputManager;
	OIS::Keyboard* mKeyboard;
	RenderWindow* mWindow;
 
private:
	float m_timeElapsed;
};
 
bool MyFrameListener::frameStarted(const FrameEvent &evt) {
 
	m_timeElapsed += evt.timeSinceLastFrame;
 
}

Ogre3D: Paso a paso III

Recordemos que el gestor del escenario es un plugin especializado según el tipo de escenario y pueden ser de los siguientes tipos:

• ST_GENERIC: Escenarios de propósito general
• ST_EXTERIOR_CLOSE: Escenarios de exteriores de visibilidad media
• ST_EXTERIOR_FAR: Practicamente no usado
• ST_EXTERIOR_REAL_FAR: Escenarios de paisajes con grandes terrenos
• ST_INTERIOR: Escenarios de interior, por ejemplo, edificios.

Veamos ya como crearlo:

mRoot->initialise(true, "Mi Ventana");	
 
RenderWindow* window = mRoot->getAutoCreatedWindow();
SceneManager *sceneMgr = mRoot->createSceneManager(ST_GENERIC);

A continuación crearemos la cámara que nos permitirá ver el escenario desde el ángulo y con la profundidad y distancia que queramos:

Camera* cam = sceneMgr->createCamera("Camara");
cam->setNearClipDistance(5);
cam->setFarClipDistance(1000);
cam->setAspectRatio(Real(1.333333));
 
Viewport* vp = window->addViewport(cam,0);
vp->setBackgroundColour(ColourValue(1, 0, 0));

Hemos definido para la cámara los valores de distincia mínima y máxima y su relación entre el tamaño x e y de la ventana que hemos creado, 800/600.

Además hemos añadido un viewport a la cámara con fondo de color rojo. Podremos tener tantos como queramos pero recuerda que se ordenan mediante el parámetro z-order y sólo puede existir uno por cada valor de z-order. Los viewport definen los rectángulos donde se visualizarán el rendererizado de la cámara.

Crearíamos ahora el listener que se encargará del renderizado de los frames:

MyFrameListener listener(window);
mRoot->addFrameListener(&listener);
mRoot->startRendering();

Es importante crear el listener antes de comenzar el renderizado de la aplicación o se nos colgará.

Ogre3D Paso a paso II
Ogre3D Paso a paso (y IV)

Dicho fichero contiene los plugins que el engine 3D Ogre va a cargar en tiempo de ejecución por lo que mi recomendación es la de cargar sólo los que el proyecto vaya a usar.

Veamos el fichero de los ejemplos que vienen con ogre:

# Defines plugins to load
 
# Define plugin folder
PluginFolder=../lib
 
# Define plugins
# Plugin=RenderSystem_Direct3D9
# Plugin=RenderSystem_Direct3D10
 Plugin=RenderSystem_GL
 Plugin=Plugin_ParticleFX
 Plugin=Plugin_BSPSceneManager
 Plugin=Plugin_CgProgramManager
 Plugin=Plugin_PCZSceneManager
 Plugin=Plugin_OctreeZone
 Plugin=Plugin_OctreeSceneManager

Vemos que carga el plugin que gestiona el renderizado OpenGL, el gestor de partículas, y 5 diferentes “Scene manager”, que serán los encargados de visualizar los escenarios y además cada uno está especializado en una forma de hacerlo diferente.

Además la línea pluginfolder indica de que directorios cargará dichos plugins que en este caso serán de la forma de una librería dinámica linux “.so”.

El tercer parámetro es del fichero de log de ogre muy útil para gestionar los posibles fallos de la aplicación que estamos desarrollando.

Si quisiesemos generar nuestro fichero de log sin usar este parámetro podríamos usar el siguiente código incluso antes de la inicialización de Ogre3D:

LogManager* logmanager = new LogManager();
Log* log = LogManager::getSingleton().createLog("logogre.log",true,tru,false);
 
Root* mRoot=new Root("plugins.cfg","ogre.cfg");

…Ogre3D Paso a paso I…
…Ogre3D Paso a paso III…

Aunque CodeBlocks tiene un template para crear tu propio proyecto, lo que pretendemos es ver de forma detallada y comprender un poco mejor como hacerlo.

Yo en mi caso he usado una versión de desarrollo de Ogre3D y una versión de desarrollo también de Codeblocks.

Ambas las he bajado y compilado para poder usarlas, pero valdrían perfectamente el SDK, para el ogre, y el codeblocks que viene integrado en ubuntu.

Desde codeblocks creamos un nuevo proyecto de consola, si queréis el clásico Hello World, eliminamos el cout e incluimos las cabeceras de Ogre y su espacio de nombres.

#include <Ogre.h>;
using namespace Ogre;

El primer paso en cualquier proyecto Ogre es la inicialización de las librerías en la forma

 
Root* mRoot=new Root();
Root* mRoot=new Root("ogre.cfg");
Root* mRoot=new Root("ogre.cfg","plugins.cfg");
Root* mRoot=new Root("ogre.cfg","plugins.cfg","ogre.log");
Root* mRoot=new Root("","");

Cualquiera de las anteriores opciones serían perfectamente válidas, aunque yo en mi caso prefiero usar la de tres parámetros para tener una completa perspectiva de cuales son mis ficheros de configuración en uso.

Veamos ahora el contenido del fichero ogre.cfg, que en mi caso lo tengo de la forma siguiente

Render System=OpenGL Rendering Subsystem
 
[OpenGL Rendering Subsystem]
Display Frequency=50 MHz
FSAA=0
Full Screen=No
RTT Preferred Mode=FBO
VSync=No
Video Mode=1024 x  768
sRGB Gamma Conversion=No

Esta configuración siempre la podemos sobreescribir con una llamada al diálogo de configuración de ogre:

 
if(!mRoot->restoreConfig())
{
  mRoot->showConfigDialog();
  mRoot->saveConfig();
}

Ogre3D Paso a paso II

Si encima hablamos de desarrollo de juegos 3D entonces nos vamos a unos perfiles muy altos en los que el desarrollador debe tener conocimientos muy fuertes de matemáticas 3D y posiblemente un alto nivel de C++ y algún que otro perfil que ahora veremos.

Voy a exponer los libros que me he leído o estoy leyendo, todos ellos en un perfecto inglés, lo que hace que sea otro requisito añadido a nuestro desarrollo.

Existir, existen muchos más, y desde luego cuantos más entendamos pues mejor…

Matemáticas:3D Math Primer for Graphics and Game Development (Fletcher Dunn and Ian Parberry)

Este libro de matemáticas puras orientado a la programación 3D y con algoritmos en C++ es un must-have en vuestra biblioteca. Yo no lo he leído completo, si lo hubiese hecho estaría en la Nasa o algo así… … pero desde luego lo tengo siempre encima de la mesa como referencia.

Bromas aparte este libro es simple de leer, me refiero al inglés, y si no sabéis lo que es un vector, una matriz o un quaternion, vais a tener complicado en lograr algo de éxito en vuestro proyecto, por lo que insisto, es un buen libro para tener en casa.

Inteligencia artificial: Programming AI Game by Example (Matt Buckland)

El título lo dice todo, después de un breve capítulo introductorio de matemáticas aborda temas como el ataque de un bot, algoritmos de trayectos, es decir, como un bot encuentra el camino para darte dos sopapos, o incluso temas de scripting en LUA.

Otro libro a tener en casa.

Ogre: Pro Ogre 3D Programming (Gregory Junker)

Un libro dedicado a la versión Eihort de Ogre que cubre todos los aspectos más destacados de este motor de renderizado 3D.

Este libro no es desarrollo de juegos en sí, sólo habla de todas las capacidades de Ogre y de como exprimirlas.

Como bien sabéis además Ogre se programa en C++ por lo que si sabéis C++ es lo primero que deberías aprender para poder afrontar este libro.

Desarrollo juegos: Game programming GEMS 6 (Varios autores, editado por Michael Dickheiser)

Toda la saga de estos libros, notad el 6, desarrollan en varios artículos y redactados por los mejores desarrolladores de juegos del mundo, cada uno los aspectos de un juego, matemáticas, sonido, inteligencia artificial, red, etc.

Decid que los artículos aparte de un must-have en nuestra biblioteca cubren apartados muy difíciles del desarrollo de  un juego.

Por tanto, ¿es recomendable?, sí, pero requiere un alto nivel que si no se tiene se debería alcanzar antes de meternos con él.

Torque: 3D Game Programming All in One, Second Edition (Kenneth C. Finney)

Este libro está entero dedicado a Torque y a como desarrollar un juego sólo con el scripting que lleva el motor Torque. Decir que el libro son 850 páginas y que es un buenísimo punto de partida para empezar con Torque ya que cubre absolutamente todos los aspectos del desarrollo de un juego con Torque, desde el modelado, pasando por la red, la parte cliente, etc.

Torque: The Game Programmer’s Guide to Torque: Under the Hood of the Torque Game Engine (GarageGames)

Esta es la guía oficial de GarageGames, los chicos de Torque, que hacen sobre su motor.

Decir que más que un libro de como afrontar cosas en Torque es una guía de referencia de su motor, por lo que os recomiendo que antes que comprar este libro comenceis con el anterior.

C++: Esto no es un libro, es un enlac, pero que mínimo que poneros una referencia a como podéis empezar con C++.

Deciros que todos estos libros han sido adquiridos en Amazon, aunque también se pueden adquirir en Agapea.

Sólo me queda mi recomendación de que si queréis afrontar un proyecto tan exigente como estos debéis de estudiar un montón y aquí tenéis un buen comienzo sólo para la parte de desarrollo.

El tema gráfico es otro tema con el que se deben pelear los diseñadores.

¡¡Feliz Año nuevo a todos!!

Blender, como bien sabéis es una herramienta de modelado 3D. Hay gente a la que le gusta mucho, y hay gente a la que no, pero hay que reconocer que una vez aprendes algunos comandos básicos, para ser una herramiente del mundo del software libre, es simplemente una pasada.

Yo como buen desarrollador, tengo la misma pericia dibujando y modelando que pueda tener un camello en mitad del desierto, pero al menos me defiendo con algunos comandos básicos.

Lo primero que debemos tener bien configurado es blender para su funcionamiento con python.

Python es un lenguaje de scripting usado en muchas aplicaciones y como base para los exportadores, importadores, modelados, etc. en blender.

A la hora de redactar este artículo el python que debemos instalar es el 2.5 y la versión 2.45 para blender. En el momento de la ejecución de blender, en la ventana de consola debe salir la siguiente frase que indica que blender ha sido capaz de reconocer la instalación de python:

” Compiled with Python version 2.5.

Checking for installed Python… got it!”

Una vez verificado que tenemos blender instalado y el lenguaje python es hora de descargar la herramienta de exportación de Ogre para blender de aquí.

El fichero que descarguemos lo descomprimimos en el directorio donde están los scripts python de blender, usualmente en: “C:\Archivos de programa\Blender Foundation\Blender\.blender\scripts”

Una vez elaboremos nuestro modelo, esta maravillosa columna con una textura de madera, para exportarla, usando el menú de blender file–>export–>ogre meshes, nos aparecerá el diálogo de exportación. Rellenamos el path donde queremos exportar el modelo, en mi caso c:\temp, activamos la opción de copiar texturas, para que nos exporte también la textura y le damos a exportar.

Antes de que os cortéis las venas como yo casi hago, deciros que antes de exportar desde blender deberéis aplicar las transformaciones que hayáis hecho a vuestro modelo. Para ello, desde el menu objeto de blender pulsar sobre “Apply scale/rotation”, “Apply transformation”, etc. Sino hacéis esto, posiblemente se verá vuestro modelo inicial, en mi caso un cubo.

Si además hubiesemos tenido la precaución de configurar dentro de las preferencias de exportación, la herramienta que convierte el formato XML al formato mesh de Ogre, OgreXMLConverter.exe, nos hubiese exportado directamente dicho mesh. Como no es nuestro caso, nos queda un último paso que sería la exportación a mesh.

Sino tenemos instaladas las Ogre Command line tools, nos la bajamos de aquí y las instalamos.

Abrimos una línea de comandos en nuestro windows xp, y sólo tenemos que ejecutar la herramienta OgreXmlConverter.exe contra el fichero xml para que lo convierta en formato .mesh, tal y como se ve en el dibujo.

Ya tenemos nuestro mesh, nuestro material y texturas preparado para su uso con Ogre.

Si tuvieramos un modelo con animaciones en blender, el proceso sería semejante, pero nos aparecerían más opciones de exportación que os dejo a todos lectores que probéis.