Reconsiderando el camino

Como dijimos en la página de presentación de FKT, somos un pequeño grupo de personas (2) que queremos aprender a desarrollar videojuegos de forma autodidacta y sin ánimo de lucro, con la intención también de transmitir a través del blog nuestros pocos conocimientos que vamos adquiriendo, sin embargo, hemos tenido que pararnos a replantearnos la dirección que estábamos tomando ya que solo hemos encontrado problemas tras problemas en nuestro día a día en el apredizaje y nos hemos divertido bastante poco en el proceso, ya que, aunque estamos aprendiendo, también queremos ver que nuestros esfuerzos se transforman en algo tangible y nos divirtamos con lo que hacemos ya que esto lo hacemos principalmente por y para nosotros, y si no nos divertimos en ello... mal vamos.

Por eso mismo, hemos pensado que quizás para nuestros pocos conocimientos y siendo primerizos hemos intentado matar moscas a cañonazos y hemos tomado un camino un tanto complicado, lo siento por aquellos que nos seguíais por los tutoriales de Ogre3D pero vamos a dejar este framework apartado durante un tiempo indefinido y hemos decidido estudiar uno que a priori parece más fácil de aprender, y además la documentación oficial en la web parece un poco más fácil de comprender, y es lo que buscamos ahora mismo, aprender y ver que lo que aprendemos nos da resultados. En un futuro, cuando nuestros conocimientos en estos campos sean más amplios y se huna la experiencia, valoraremos si volver a rompernos la cabeza con Ogre3D o no (según los resultados que obtengamos con este nuevo framework).

Para los que nos sigáis simplemente por el gusto de aprender al igual que nosotros, espero que también disfruten con los tutoriales que iremos colgando de este nuevo camino que tomaremos. Sin más dilación os comunico que a partir de este momento seguiremos nuestras andaduras utilizando Panda3D. En su web podéis encontrar toda la información sobre este framework.

Nos apena la decisión tomada, pero como he dicho al principio, era matar moscas a cañonazos y estamos ahora mismo en proceso de aprendizaje autodidacta y aunque demos por hecho que nos encontraremos problemas, no queremos que estos sean mayor número que los éxitos.

Bueno, deciros que el framework es de código libre como Ogre3D, también se puede integrar con PhysX, se puede desarrollar tanto en c++ como en python (con soporte oficial del equipo de desarrollo del framework y no con un port como en Ogre3D) y la documentación en su web parece bastante más completa y actualizada que la que hay actualmente de Ogre3D en su respectiva web.

Espero que al menos, el nuevo framework elegido os anime a continuar con nosotros.

PD: Se me olvidaba comentar que una de las características más atractivas de Panda3D es la capacidad de incrustar en código html los juegos que se hacen y poder jugarlos desde un navegador web.

Tutorial 3 NxOgre : Kinematics

En primer lugar vamos a explicar que son y para que sirven los Kinematics, son objetos donde no le afectan el estado de fisica de otros objetos, imaginate un ascensor en un videojuegos, puedes dispararle tirarle cosas, pero en verdad no se mueve, podriamos hacer el mismo ascensor, con Volumen, pero tendriamos que controlar, si un objeto ha entrado o ha salido. Poriamos crear un body, pero a este tipo de objeto si le afecta la fisica de su entorno.

Pongo traducido un trozo del texto bastante interesante de la Wiki NxOgre:

Nota: Como siempre en NxOgre, hay que distinguir entre un cuerpo y un actor. Un actor es sólo la representación física de un objeto físico y no es visible, mientras que un cuerpo es un actor más una visualización (por ejemplo, a través de Entitys Ogre). Lo mismo se aplica para un KinematicActor y KinematicBody una.

Este se aplica a casi todo en NxOgre, un actor es la representación fisica de un objeto, el body es el objto visual en si, unido con un SceneNode de Ogre.

Para crear objetos Kinematics, se realiza así:

mKB = mRenderSystem->createKinematicBody(new NxOgre::Box(20, 2, 20), NxOgre::Vec3(0, 12, 0), "CuboF.mesh");

Le pasamos un Shape, una posición y la malla del objeto.

Voy a pasar el codigo del ejemplo construido, para que veais lo que ocurrre. SRC BloodyMessTutorial5

En este ejemplo me he encontrado dos problemas, uno que sacando la SceneNode para crear otro Kinematics, no he podido rotar dicho objeto, he tenido realizar dicha rotación con mKB->setGlobalOrientation(Quaternion), no consiguiendo del todo la rotación y tampoco uqe ningun objeto colisione, con dicho objeto una vez rotado.

Y el segundo problema y menos comprensible, si cojemos la camara del objeto la movemos y la ponemos en la parte superior del ascensor y miramos hacia abajo como si estuvieramos colgados del techo, pulsamos la tecla espacio para lanzar cubos, alguno cubos colisionan contra el ascensor y otros se escapan, es un efecto bastante curioso y no sabemos si es por cula de la poca comprensión de esta fantastica libreria o tiene errores.

Si alguien nos pudera echar una mano estariamos encantandos.

Hasta la proxima.....

Tutorial 2 NxOgre: Volumes y Triggers

Como en anteriores tutoriales, vamos a exponer una aplicacion para descargar, que es una ligera modificación de tutorial 4 de la wiki de nxOgre. SRC NxOgre_tutorial2

Lo pimero que vamos hacer es explicar que es un volumen:

Es un tipo de objeto con sus propiedades de posición, orientación entre otras, que a la vista es invisible, pero cuando algun objeto lo atraviesa, se pueden recojer algunos eventos, para realizar alguna operación. En el ejemplo original de la wiki de nxOgre, se ve como aplicando un impulso a un cubo se ve como hace botes encima de un panel. En nuestro ejemplo hemos modificado dicho codigo, para ver el funcionamiento de dicho volumen y hemos puesto dos uno encima del otro y cada vez que toca arriba creará un cubo nuevo, así hasta 20 cubos.

El trigger no es mas que una clase que hereda de CallBack, que es la encargada de recojer los eventos. No vamos a explicar aqui todo el codigo, por que eso ya lo hicimos en anteriores post, aqui solo vamos a explicar lo que mas nos interesa.

mVolume = mScene->createVolume(new NxOgre::Box(NxOgre::Vec3(100,1,200)), NxOgre::Matrix44(NxOgre::Vec3(0, 0, 0)), this, NxOgre::Enums::VolumeCollisionType_All);

Este es el comando encargado de crear este volumen, con su Shape (como explicamos anteriormente es la envoltura), su posición, el objeto que hereda de CallBack y la ultima partes le estamos diciendo que tipo de eventos queremos recojer, en este caso son todos. Este es el metodo encargado de recojer el evento, en este caso lo tenemos en la misma clase.

void NxOgre_tutorial2::onVolumeEvent(NxOgre::Volume* volume, NxOgre::Shape* volumeShape, NxOgre::RigidBody* rigidBody, NxOgre::Shape* rigidBodyShape, unsigned int collisionEvent)
{
if(collisionEvent == NxOgre::Enums::VolumeCollisionType_OnEnter)
{
OGRE3DBody* body = static_cast(rigidBody);


float y = (9.81 * body->getMass()) // counteract gravity
+ (-body->getLinearVelocity().y * body->getMass()) // counteract vertical velocity
+ (10 - body->getGlobalPosition().y * body->getMass()); // Add some force to move it to the top


body->addForce(NxOgre::Vec3(0, y, 0), NxOgre::Enums::ForceMode_Impulse);
}
}

Como vemos aqui se pasan como parametros algunos tipo normalmente usados en este tipo de eventos. Recogemos el Volumen que ha recibido el evento, con su Shape, tambien recibimos el rigidBody, que es el objeto que ha colisionado, con su Shape y el tipo de colisión. Recordar que el OGRE3Dbody es una combinación de SceneNode(Ogre) y Actor(NxOgre).

Los tipos de colisiones mas importantes son:

• NxOgre::Enums::VolumenCollision_Type_OnEnterOrExit - Para cuando sale o entra dentro del volumen
• NxOgre::Enums::VolumenCollision_Type_OnEnter - Cuando ha entado el objeto dentro del volumen
• NxOgre::Enums::VolumenCollision_Type_OnExit - Cuando ha salido del volumen
• NxOgre::Enums::VolumenCollision_Type_OnPresence - Cuando esta completamente dentro del volumen

Este objeto nos vale para infinadad de cosas, por ejemplo podemos hacer que cuando un objeto pase por algun detrminado lugar, empieze algun sonido o musica, o por ejemplo mostrar un mensaje mmientras un objeto está dentro. Infinidad de cosas.

Seguiremos colocando tutoriales sobre esta fantastica libreria. Hasta la proxima.

Tutorial NxOgre : Primer contacto

Este tutorial va acompañado e una aplicación con algunas modificaciones del segundo tutorial de la Wiki de NxOgre, interacción con estos cubos y su física y adaptación del los proyectos de la Wiki NxOgre con el BaseApplicaction que genera el OgreWizard del Vc9. En este tutorial abarcaremos el funcionamiento basico de NxOgre, para darle física a nuestros proyectos y así conseguir unos resultados mas llamativos.

• SVN NxOgre_tutorial

Mientras explicamos como funciona brevemente las clases basicas de NxOgre, es coveniente bajar el proyecto del SVN para tener una mayor comprensión de lo que aqui exponemos. El funcionamineto de la aplicación es el siguiente, pulsar los botones:

• V: Matener pulsado para avanzar en la animación de los cubos
• P: Para generar mas cubos
• B: Para que la función del boton Pse pueda borrar y crear dos cubos nuevos o generar cubos, si borrar los anteriores

En este ejmplo tan básico, lo que vemos en como crear un mundo, configurarlo y soltar varios cubos para que tenga un comportamiento acorde a la configuración. Para crear el mundo :

mWorld = NxOgre::World::createWorld();

Para darle configuración:

NxOgre::SceneDescription sceneDesc;
sceneDesc.mGravity = NxOgre::Vec3(0, -9.8f, 0);
sceneDesc.mName = "DemostrSacion FKT";

Una vez creado el mWorld y el SceneDescription, creamos la mScene
mScene = mWorld->createScene(sceneDesc);

//Configuramos el material de la escena
mScene->getMaterial(0)->setStaticFriction(0.5);
mScene->getMaterial(0)->setDynamicFriction(0.5);
mScene->getMaterial(0)->setRestitution(0.1);

Segun wikipedia la frincción es:

Se define como fuerza de rozamiento o fuerza de fricción entre dos superficies en contacto a la fuerza que se opone al movimiento de una superficie sobre la otra (fuerza de fricción dinámica) o a la fuerza que se opone al inicio del movimiento (fuerza de fricción estática).

Según entiendo despues de leer esto, que la StaticFrinction es el rozamiento que tendrá al principio del choque entre dos objetos y la DynamicFriction es el rozamiento durente todo el movimiento del choque.

Restitución:

En una colisión frontal alineada de dos esferas sólidas (como las que experimentan las bolas de billar) las velocidades después del choque están relacionadas con las velocidades antes del choque.

En definitiva es la velocidad con la que se despiden los objetos despues del choque.

// Ahora creamos el systema de renderizado, para entenderlo de alguna manera es la clase que crearemos los objetos de Ogre y todo lo demas relazionado con el.
mRenderSystem = new OGRE3DRenderSystem(mScene);

En los siguientes codigos vemos como crearemos los cubos, pasandole el BoundingBox que envolvera al objetos, la posición y el fichero .mesh. Si queremos obtener un SceneNode de un OGRE3DBody, simplemente haremos esto: mCube->getScebeNode() -> esto que devuelve el un Nodo de Ogre.

mCube = mRenderSystem->createBody(new NxOgre::Box(1,1,1), NxOgre::Vec3(0, 40, 0), "cube.1m.mesh");
mCubeTwo = mRenderSystem->createBody(new NxOgre::Box(1, 1, 1), NxOgre::Vec3(20, 45, 0), "cube.1m.mesh");
mCubeTwo->addForce(NxOgre::Vec3(-800, -200, 0), NxOgre::Enums::ForceMode_Force);

Esta es la parte mas curiosa de esta libreria, creamos un plano con BloodyMesh, pero luego dicho plano lo representamos con Ogre, si comentamos la  parte del codigo de mPlaneNode->... , veremos que el efeco de suelo sigue estando pero sin el objeto vista plano creado.

// (BloodyMess)
mScene->createSceneGeometry(new NxOgre::PlaneGeometry(0, NxOgre::Vec3(0, 1, 0)), Matrix44_Identity);


// (Ogre)
Ogre::MovablePlane *plane = new Ogre::MovablePlane("Plane");
plane->d = 0;
plane->normal = Ogre::Vector3::UNIT_Y;
Ogre::MeshManager::getSingleton().createPlane("PlaneMesh",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
*plane, 120, 120, 1, 1, true, 1, 3, 3, Ogre::Vector3::UNIT_Z);
Ogre::Entity *planeEnt = mSceneMgr->createEntity("PlaneEntity", "PlaneMesh");
planeEnt->setMaterialName("Examples/GrassFloor");


Ogre::SceneNode* mPlaneNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
mPlaneNode->attachObject(planeEnt);

Aqui terminamos explicando lo basico de esta libreria, en los proximos tutoriales explicaremos colisiones con NxOgre.

Hasta la proxima.

NVIDIA PhysX, Instalando NxOgre

PhysX es un chip y un kit de desarrollo diseñados para llevar a cabo cálculos físicos muy complejos. Conocido anteriormente como la SDK de NovodeX, fue originalmente diseñada por AGEIA y tras la adquisición de AGEIA, es actualmente desarrollado por Nvidia e integrado en sus chip gráficos más recientes. (Fuente Wikipedia)

Para poder utilizar el SDK de PhysX en nuestros desarrollos en Ogre3D utilizaremos una librería intermedia que facilita su uso llamada NxOgre.

Primero necesitamos compilar las fuentes de NxOgre para generar las librerías que utilizaremos en nuestro proyecto, para ello necesitamos tener instalado el SDK y el System Software de nVidia. A continuación descargamos NxOgre BloodyMess que es la versión estable.

Tras instalar el SDK, el System Software y descomprimir NxOgre tenemos todo lo necesario para compilar las librerías (tengo en cuenta de que disponemos del SDK de Ogre3D también en el sistema). Accedemos a la carpeta \build\msvc donde encontraremos dos proyectos preparados, para Visual Studio 2005 y 2008.

Debemos crear una variable de sistema llamada PHYSX_DIR que apuntará a la carpeta donde se instaló el SDK de PhysX.

Para compilar el proyecto debemos configurar las librerías que utilizará visual studio para compilar el proyecto. Accedemos al menú Tools y a la opcion Options...

En el apartado Projects and Solutions, en la sección VC++ Directories debemos indicar las librerías de Ogre3D necesarias para compilar el proyecto. En Include files debemos indicar la carpeta Include de Ogre3D, la carpeta Include de Samples\Commons\Include también de ogre y la carpeta boost dentro de boost_1_42 también en Ogre3D. En Executable files indicamos la carpeta bin de Ogre3D y en Library files la carpeta lib de Ogre3D y la que hay dentro de boost_1_42 también en Ogre3D.

Modificaremos las operaciones post-compilado de la librería para que no intente copiar las librerías generadas a los ejemplos Cake y Flour de NxOgre ya que si no los tenemos descargados nos dará un error de compilado que aunque nos generará las librerías correctamente, puede llevar a confusión. Para ello accedemos a las propiedades del proyecto de NxOgre y en la sección Configuration Propeties > Build Events > Post-build Event pulsamos en el botón con tres puntos en el campo Command Line y eliminamos las dos últimas lineas:

• copy "$(SolutionDir)..\..\sdk\NxOgre_Debug.dll" "$(SolutionDir)..\..\..\BloodyCake\application\"
• copy "$(SolutionDir)..\..\sdk\NxOgre_Debug.dll" "$(SolutionDir)..\..\..\BloodyFlour\application\"

Ahora simplemente vamos al menú Build y seleccionamos Build Solution. Según la opción de compilado obtendremos en la carpeta sdk del directorio de NxOgre una librería NxOgre.dll o NxOgre_Debug.dll, las cuales usaremos según la opción de compilado en nuestros proyectos. (Al final indico algunos posibles problemas que pueden surgir al compilar la librería y cómo solucionarlo)

Para utilizar las librerías de NxOgre con nuestro proyecto de Ogre3D debemos incluirlas de la misma forma que para compilar NxOgre. En VC++ Directories incluimos en Include files la carpeta sdk de NxOgre y en Library files también incluímos la carpeta sdk. Para utilizar las dll accedemos a las propiedades de nuestro proyecto Ogre3D y en la sección Input de Configuration Properties > Linker hacemos click en el botón con los tres puntos del campo Additional Dependences y añadimos en el campo de texto superior las siguientes lineas:

• NxOgre.lib
• NxOgreOGRE3D.lib
• Si compilamos en modo Release

• NxOgre_Debug.lib
• NxOgreOGRE3D_Debug.lib
• Si compilamos en modo Debug

Para terminar y poder ejecutar nuestro proyecto compilado de Ogre3D, debemos copiar las librerías NxOgre.dll o NxOgre_Debug.dll (según compilemos el proyecto) en la carpeta donde se genere nuestro ejecutable. En nuestro caso en la carpeta debug y release dentro de la carpeta bin en Ogre3D.

Para poder utilizar todos los ejmeplos que expondremos aqui hará falta el BloodyCake usado en la wiki de NxOgre el enlaze es este: MeshYUtilidades

Posibles problemas:

No deberían de producirse estos problemas si está todo bien configurado, pero por si acaso, aquí tenéis cómo solucionarlos.

• Si al compilar no encuentra el archivo Ogre.h debemos ir a la configuración de las librerías incluidas en VC++ Directories y en Include files debemos indicar las carpetas OGRE y OIS dentro de Include en vez de solo la carpeta principal.
• Si al compilar no encuentra el archivo OgreMain_d.lib actuaremos de la misma forma que en el punto anterior salvo que incluiremos las carpetas debug y release de la carpeta lib en la seccion Library files en vez de la carpeta principal solo.
• Si al compilar no encuentra el archivo tss.hpp debemos copiar la carpeta boost de boos_1_42 a la carpeta Include de Ogre3D e incluirla en Include files de VC++ Directories en Visual Studio.

Espero que os sea de utilidad el tutorial Si os resulta algo difícil de seguir indicadlo en los comentarios o al mail freakteam.mail@gmail.com y le echaremos un vistazo para redactarlo de nuevo.

Primer proyecto FKT ( Pong ATARI )

Una vez leido los tutoriales anteriores, vamos a realizar nuestro primer proyecto del equipo FKT, reuniendo conocimientos.

El codigo fuente del proyecto será publico para cualquier persona que quiera participar.

http://freakteam.svn.sourceforge.net/viewvc/freakteam/trunk/PongTenis/

MOC, Minimal Ogre Collision 1.0

Vamos a intentar explicar, esta librería o utilidad, para realizar colisiones un poco mas complejas en Ogre. No veremos en su totalidad su funcionamiento en este tutorial, pero si lo mas fundamental, para realizar colisiones un poco mas complejas. Lo primero es poner en conocimiento que las imágenes y mayoría de información esta sacada de la Wiki de MOC.

Para empezar vamos a entender la diferencia de la Colisión simple explicada en el tutorial anterior con esta, y del por que de su uso. En la colisión simple por AABB, este método consistía en envolver con una caja de coordenadas la entidad y sobre dicha caja de coordenadas, preguntar sobre colisiones, pero que ocurre si la entidad no tiene la misma forma que la caja de coordenadas, la colisión no sería exacta a la entidad si no sería sobre la caja de coordenadas que la envuelve. Con esta imagen se entederá mejor lo que quiero explicar:

MOC usa el metodo del rayo,  como bien se ve en la imagen de la izquierda. Dicha colision se basa en un rayo que va dede el punto de origen al punto de destino, y colisionando sobre el objeto. Este metodo del rayo está en Raycasting_to_polygon_level. Para saber si el rayo ha colisionado en el objeto y no en su eje, este metodo, tambien necesita del metodo que devuelve la informacion de la entidad, este metodo está en RetrieveVertexData, aqui hay un metodo GetInformationMesh(...) .

Mesh es la malla que esta compuesto cualquier modelo tratado en Ogre. Cuando exportamos un modelo y lo convertimos a un fichero .Mesh, entre otras cosas, lo que se hace en dicha exportación es convertir toda la formación del objeto creado en nuestro 3dstudio, en mallas, con muchos vertices, para así despues poder leerlo. Si no se a entendido lo que he querido explicar (que será lo mas evidente :P ) un dibujo para salir de dudas:

En la imagen el Mesh sería la de la izquierda el resultado de la trasformación del dibujo de la derecha. Retomando lo que queriamos explicar, el metodo GetInformationMesh, basicamente devuelve la cantidad de vertices de un objeto,  un array con la informacion de en coordenadas de los vertices....

Una vez sabido esta informacion es preguntar con el metodo Ogre::Math::intersects, pasandole como parametros el rayo y los puntos Z,Y y Z, para saber si dicho rayo a llegado al objeto. Basicamente preguntariamos por la distancia de este rayo para saber si ha colisionado o no con el objeto.
Una vez explicado como funciona el metodo del Rayo, ya entendemos de manera basica como funciona MOC, para realizar las coslisiones.

Lo primero que debemos hacer es bajar l versión de MOC que viene en la Wiki de MOC, una vez descargada la version 1.0, desmcomprimimos el RAR, y aparece un CollisionTool.H y CollisioTool.CPP, los cojemos y lo colocamos en sus respectivas carpetas de nuestro proyecto, y ya solo con esto podemos empezar a funcionar con MOC. Vamos a intenar explicar un poco sus metodos:

Los metodos mas importantes son ()->raycast(...) y GetInformationMesh, todos los demas metodos del MOC llaman a estos dos, par devolver calculos.

• rayCastFromCamera, -> saca un rayo desde la camara y devuelve una Entidad, con la cual a colisionado, este metodo esta bien para seleccionar objetos de la pantalla, tal cual como un juego de estrategia, que con el raton eliges un objetivo. Este metodo y el showBoundingBox del nodo podemos marcar una entidad u otra.
• CollidesWithEntity-> devuelve un booleano, para saber si ha colisionado con un objeto o no, es un metodo facil, pero no devuelve ninguna otra informacion.
• getTSMHeightAt y calculateY, son metodos usados, con terrenos, para saber la distancia hasta el terreno y calcular la y para saber si la camara esta por encima de un monticulo o no. Lo veremos mas adelante, en otros tutoriales de terreno.

Veamso un ejemplo de colisión con MOC:

//Resultado de la colisión, donde el rayo intercepta los verttices que componen el objeto
Ogre::Vector3 results = Ogre::Vector3::ZERO; 
//El objeto que ha sido colisionado
Ogre::Entity *tmpE = NULL;  
//Distancia hasa la colisión
float distToColl = 0; 
//Este metodo devuelve un boolean, para que sepamos cuando ha colisonado
if(col->raycast(Ogre::Ray(mSceneMgr->getSceneNode("PELOTA")->getPosition(),mSceneMgr->getSceneNode("PARED")->getPosition()),results,tmpE,distToColl,Ogre::SceneManager::ENTITY_TYPE_MASK)){
FKT::TextRenderer::getSingleton().setText("texto","Colision "+tmpE->getName());

}

Todos los demas metodos del MOC, llaman a este para reealizar las operaciones.
Con este tutoral ya podemos saber cuando un objeto  ha colsionado con otro y donde.

Hasta la proxima.

Colisiones Simples AABB

En este tutorial, vamos abarcar la colisión, a mi manera de ver la mas simple que se puede hacer con Ogre, con la AABB, Axis Aligned Bounding Box, el eje de la caja dde coordenadas, toda esta informacion te la puedes encontrar en la Wiki de Ogre, aqui vamos a explicarla un poco y sacarle uso. En el proyecto del TENIS que estamos realizando, no vamos a incluir este tipo de Colisión, ya que utilizaremos MOC, una libreria, que explicaremos en el siguiente Tutorial.

Bueno, la caja de ejes de coordenadas, se genera el cualquier entidad generada en nuestro proyecto, podemos mostrarla para verla, con la propiedad showBoundingBox(true); del nodo asociado a esta entidad. En la sguiente imagen vemos como la caja de coordenadas envuelve a toda la entidad.

Para saber recoger esta caja, el mismo nodo que contiene la entidad nos ofrece un metodo llamado _getWorldAABB(), que nos devuelve un objeto de tipo: AxisAlignedBox, con algunos metodos interesantes

• getMaximun(), getMinimun() -> devuelve un Vector3 con los valores maximos y minimos de esta caja.
• getCenter() -> nos devuelve un Vector3 con el centro de la caja.
• intersection -> pide como parametro otro AABB, y devuelve el resultante, de dicha intersección o colisión.

Ogre::AxisAlignedBox aabResultado = mSceneMgr->getSceneNode("nodo1")->_getWorldAABB().intersection(mSceneMgr->getSceneNode("nodo2")->_getWorldAABB());
if(!aabResultado.isNull())
{


" Ha habido una colision ubicada en"+aabResultado->getMaximun()->getCenter();


}

Realizando calculos, respecto a un eje, podriamos saber donde ha colisionado, por ejemplo en el tenis podriamos saber si ha colisionado en la parte de arriba centro o abajo.

• contains -> Este metodo devuelve true o false para saber si un AABB contiene a otro.

Este metodo es muy util para saber si un objeto se encuentra o se ha encontrado alguna vez dentro de otro en su totalidad. Por ejemplo podriamos saber en el Juego del tenis si la pelota a traspasado la paleta.

En definitiva con el metodo _getWorldAABB() de los nodos, podremos saber de manera simple y facil si ha habido alguna colision entre objetos, para saber mas mirar el ejemplo creado de CuboLoco v2.

FKT Utilidades

/*
-----------------------------------------------------------------------------
Filename: FKT.cpp
-----------------------------------------------------------------------------


This source file is generated by the

Ogre 1.7.x Application Wizard for VC9 (Mayo 2010)
http://www.freakteamdev.tk
-----------------------------------------------------------------------------
*/

Para hacer uso mejor de las utilidades que nos vamos encontrado por la red, vamos a publicar un .H y .CPP,
para reunirlas, con añadidos de otros compañeros que por afición van dejando esos trozos de codigo que en algun momento pueden ser muy utiles. Estará en continuos cambios en funcion del proyecto que estemos abarcando. Aqui os paso el link para la descarga del FKT.h y FKT.cpp, con dos utilidades usadas, en CuboLoco v2. Download FKTUtils

1. EntityUtil, es una clase para recojer esa información que se encuentra en los SceneNode y tenemos que ir guardando en las variables que vamos creando en nuestro codigo, por ejemplo la variable de incremento de escala, o guardar la posicion de algun momento de la aplicacion, o un boolean para darleotro tipo de estado a un nodo o entidad, este EntityUtil se enlaza con el nombre del Nodo.
2. TextRenderer es una utilidad muy util para realizar muestras de texto por pantalla, sin tener que utilizar el log o un label.

Su uso:

Tenemos que declararlo en cualquier parte del codigo, por ejemplo en createScene()

new FKT::TextRenderer(); // Solo lo instanciamos una vez

Y ya podemos usarlo

FKT::TextRenderer::getSingleton().addTextBox("texto","",0,0,100,200,Ogre::ColourValue::Green);

Y asi podemos hacer un Update del texto

FKT::TextRenderer::getSingleton().setText("texto",Ogre::StringConverter::toString(aab.getSize()));

Este texto debes de tener instalado en los archivos OGRE_HOME/media/fonts/sample.fontdef el Font Starwars, es el tipo de letra que usa.

2º Versión del CuboLoco, ahora con colisiones

Aqui presentamos la 2º version del CuboLoco, ahora con colisiones simples, utilizando la AABB, Eje Coordenadas de la Caja Alineados.

Siguientes tutoriales explicaremos colisiones simples....

• SRC CuboLoco: CuboLoco v2

Rotate, position y Scale

Ampliando el tutorial primero de la wiki de Ogre, vamos a realizar un ejercicio de un Cubo, rotando sobre si mismo y chocandose, con las paredes de la ventana, para ir reforzando los tutoriales anteriores con este. Basicamente es un ejemplo de reocjer los enventos de los botones, hacer operaciones basicas sobre un cubo.

En la version de codigo fuente, está la carpeta del projecto en VS2008, mas una carpeta media, que deberis copiar y pegar en OGRE_HOME, que son los modelos, el archivo material y el png del logo.

• Codigo fuente del CuboLoco

En la version ejecutable del ejemplo, se ejecutará solo en modo OpenGL, para verlo en con DirectX, necesitas tener instalada la verson DirectX, la misma que desatives en puglins.cfg.

• Binarios Cubo Loco