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 te gusta usar .net, puedes hacer que haga algunas tareas en Torque.

Esto es sólo un ejemplo de como usar .net en Torque.

Todo el código fuente es gratis y lo puedes usar bajo tu responsabilidad.

Si necesitas más referencias ve a la página web de MSDN o GarageGames. Alguna información ha sido extraída de esas páginas.

Para este ejemplo se ha usado Visual C# 2005, Visual C++ 2008 y las librerías de Mono (ms 2.0) para la  conexión a PostgreSQL

Vamos a obtener la versión  de la base de datos  que es muy similar a hacer un “select” o un “insert”.

Como primer paso creamos una DLL (ClassLibrary) en C#.

Editamos el código fuente, añadimos el interface público y cambiamos su nombre. Este interface lo usaremos para exponer su métodos a través de COM.

Añadimos también la funcionalidad Postgres, en este caso, sólo un “select version()”.

[sourcecode lang="cpp"]

using Npgsql;

namespace Database
{
public interface IPGDatabase
{
String pgVersion();
}

public class PGDatabase : IPGDatabase
{

conn = new NpgsqlConnection(“Server=192.168.11.150;Port=5432;User Id=user;Password=secret;Database=DBl;”);
conn.Open();

NpgsqlCommand command = new NpgsqlCommand(“select version()”, conn);
String serverversion;

[/sourcecode]

Para exponer el interface com debemos editar el fichero AssemblyInfo.cs y cambiar la línea”[assembly: ComVisible(false)]” por “[assembly: ComVisible(true)]“.

Creamos ahora un nombre fuerte a nuestra DLL. Desde el prompt de Visual Studio teclea “snk.exe -k database.snk”. Copia este fichero al proyecto, edita las propiedades del proyecto y ve a la pestaña de firmar. Pincha sobre “Firmar el ensamblado” y elige el fichero recien creado.

Compila el proyecto para crear la DLL Managed

Vamos a registrar la información de ensamblado de la DLL.

Desde un prompt de Visual Studio, ve al directorio donde esté la DLL y teclea

regasm database.dll /tlb:database.tlb /codebase

Copia este fichero al proyecto Torque

Crea una clase en Torque y prepárala para usarla en la consola como el ejemplo de abajo (si tienes dudas ve a la página web de GarageGames)

[sourcecode lang="cpp"]

class DBVersion: public SimObject
{

…

public:

DECLARE_CONOBJECT( DBVersion );

…

IMPLEMENT_CONOBJECT( DBVersion );

…

ConsoleMethod(DBVersion,getVersion, const char*, 2, 2,”()Returns the postgresql.”)

[/sourcecode]
Importa el fichero .tlb añadiendo la línea “#import “..\game\database.tlb” raw_interfaces_only”, y usa el nuevo espacio de nombres recien creado “using namespace database”

Si todo ha ido bien, tendremos acceso a nuestra dll managed

Creamos el puntero al interface y llamamos a nuestra función

[sourcecode lang="cpp"]

HRESULT hr=CoInitialize(NULL);

IPGDatabasePtr pIDatabase(__uuidof(PGDatabase));

long lResult=0;

pIDatabase->pgVersion(&bstrstring);

CoUninitialize();

[/sourcecode]

Como la DLL está devolviendo una cadena BSTR, necesitaremos hacer una pequeña conversion:

[sourcecode lang="cpp"]

_bstr_t _bstrstring(bstrstring);
strcpy_s(version, (char *)_bstrstring);
return (StringTableEntry) &version[0];
[/sourcecode]

Tiempo de probarlo. Compila el proyecto, ejecuta el motor de juegos torque, abre la consola y teclea:

$a=new DBVersion();
echo($a.getVersion());

Código fuente

¡Disfrútalo!

Notar que esto es sólo un ejemplo. No hay control de errores, el código se puede mejorar,…

Demo en torque del terreno

Nota: esto es sólo una demostración del terreno y para ello se han usado algunos gráficos de Torque.

TGEA 1.7.0 incluye ahora un nuevo sistema de megaterrenos llamado MegaTerrain. Megaterrain nos permite incluir varios terrenos individuales dentro de las misiones de Torque.

Pero nosotros vamos a ver como exportar un terreno para al anterior sistema Atlas 2 usando la herramienta Large 3D Terrain de bundysoft. Decir que la herramienta tiene dos versiones y la que se compra en GarageGames cuesta unos 35$ y lleva el plugin de exportación para Atlas.

Esta herramienta provee un tutorial muy interesante que nos hará un terreno en pocos minutos. Seguidlo y generar un terreno de 1024×1024 pixeles, como se ve en las imágenes.

Una vez finalizado el tutorial grabar el proyecto y usar la opción de exportación File–>Export–>To torque Atlas(garagegames plugin). Este plugin tiene todavia algunos bugs con terrenos grandes.

Con el terreno generado es hora de ponerlo en Torque en nuestro fichero de misión con el siguiente código:

new AtlasInstance(NewTerrain) {
canSaveDynamicFields = “1″;
Enabled = “1″;
position = “0 0 0″;
rotation = “1 0 0 0″;
scale = “1 1 1″;
atlasFile = “scriptsAndAssets/data/export/miterreno.atlas”;
lightmapDimension = “256″;
};

Truco: si no veis el terreno, seleccionadlo con “World Editor inspector” y haceis un drop selection.

Hoy voy a hablar sobre desarrollos comerciales cuyos códigos fuentes han sido liberados a toda la comunidad para su aprendizaje.

El primero de ellos es el simcity (micropolis).

En este blog tenéis toda la información y el código fuente disponible.

Además vamos a hablar de otro de los clásicos por excelencia: Quake III…ni horas que he pasado yo jugando al Quake III… El código fuente está disponible en la página oficial de ID Software en la siguiente URL

Parte de esta información ha sido extraída de una página web que os recomiendo a todos pues habla de Inteligencia Artifical aplicada al desarrollo de juegos.

¡Que lo disfrutéis!