Gestor que registra los bodies, detecta colisions y proporciona un sistema de callbacks. Más...
#include <collisionManager.h>
Tipos públicos | |
typedef boost::function< void(Body *, Body *) | CollisionCallback ) |
Métodos públicos | |
CollisionManager () | |
~CollisionManager () | |
void | addBody (Body *body) |
bool | removeBody (Body *body) |
void | removeAllBodies () |
void | addCollisionCallback (int typeA, int typeB, CollisionCallback c) |
bool | removeCollisionCallback (int typeA, int typeB) |
void | removeAllCollisionCallbacks () |
void | checkCollisions () |
Métodos públicos estáticos | |
static CollisionManager & | getSingleton () |
static CollisionManager * | getSingletonPtr () |
Gestor que registra los bodies, detecta colisions y proporciona un sistema de callbacks.
CollisionManager lleva el registro de los elementos colisionables (Body) que componen la escena. Realiza tests de colisión entre dichos bodies y llama al callback oportuno si es que lo hubiese. Sigue el patrón de diseño Singleton, es decir, una única instancia accesible desde todo el sistema. No es un sistema de físicas, sólo detecta colisiones e informa de ellas.
Para que un cuerpo sea considerado como colisionable debe de ser registrado en el CollisionManager. Los cuerpos tienen un tipo determinado (entero) útil para clasificarlos dentro de la gestión de colisiones. Debemos indicarle explícitamente al sistema que detecte e informe de las colisiones entre dos tipos de cuerpos. Esto lo conseguimos a través del sistema de callbacks. Un callback es una función (independiente o miembro de alguna clase) que tiene la siguiente forma:
void collisionCallbacK(Body* bodyA, Body* bodyB);
Para registrar un callback utilizamos boost::bind y boost:funcion y le indicamos al CollisionManager qué tipos de cuerpos estarán asociados. En cada iteración del bucle de juego debemos llamar al método CollisionManager::checkCollisions para detectar las colisiones y llamar a los callbacks. A continuación de muestra de un ejemplo de uso.
// Al comienzo de la aplicación creamos el CollisionManager CollisionManager* collisionManager = new CollisionManager(); ... // Tenemos bodyA, bodyB y bodyC, los registramos en el CollisionManager CollisionManager::getSingleton().addBody(bodyA); CollisionManager::getSingleton().addBody(bodyB); CollisionManager::getSingleton().addBody(bodyC); // Registramos un callback para la colisión entre bodies de tipo 1 y 2 boost::function<bool(Body*, Body*)> callback = boost::bind(&miFuncionCallback, _1, _2); CollisionManager::getSingleton().addCollisionCallback(callback, 1, 2); ... // En el bucle de juego while(!exit) { // Actualizar elementos // Comprobar colisiones CollisionManager::getSingleton().checkCollisions(); // Renderizar } ... // Al cerrar la aplicación, destruimos el CollisionManager delete collisionManager;
typedef boost::function<void(Body*, Body*) CollisionManager::CollisionCallback) |
Objecto función que modela los callback de colisiones: recibe dos cuerpos y no devuelve nada
CollisionManager::CollisionManager | ( | ) |
Constructor
Configura el reparto de colisiones de la clase Shape (ya no es necesario llamar a Shape::configureCollisionDispatching de forma manual).
CollisionManager::~CollisionManager | ( | ) |
Destructor
No libera la memoria ocupada por los cuerpos registrados, debes destruirlos de forma manual. Si el cuerpo está bajo el control de la clase GameObject o derivados no será necesario, ella lo hará de forma automática.
void CollisionManager::addBody | ( | Body * | body | ) |
body | cuerpo a añadir |
Registra un cuerpo en el gestor de colisiones. A partir de ahora será tenido en cuenta en los tests de colisión siempre y cuando haya un callback definido.
void CollisionManager::addCollisionCallback | ( | int | typeA, | |
int | typeB, | |||
CollisionCallback | c | |||
) |
typeA | tipo del primer objeto | |
typeB | tipo del segundo objeto | |
c | objeto función que recibe dos punteros a cuerpos y devuelve un booleano. |
Registra un callback para las colisiones entre objetos de tipo typeA-typeB y viceversa. Cuando se detecte una colisión entre esos tipos se llamará al método encapsulado por c. Si ya existía un callback registrado para esos tipos, se sobreescribe.
void CollisionManager::checkCollisions | ( | ) |
Efectúa todos los tests de colisión oportunos entre los cuerpos registrados y llama a los callbacks pertinentes.
CollisionManager & CollisionManager::getSingleton | ( | ) | [static] |
CollisionManager * CollisionManager::getSingletonPtr | ( | ) | [static] |
void CollisionManager::removeAllBodies | ( | ) |
Elimina todos los cuerpos bajo el conrol del gestor de colisiones. No los destruye, si no estaban bajo el control de objetos GameObject debes hacerlo de forma manual.
void CollisionManager::removeAllCollisionCallbacks | ( | ) |
Elimina todos los callbacks registrados en el gestor de colisiones.
bool CollisionManager::removeBody | ( | Body * | body | ) |
body | cuerpo a borrar del gestor de colisiones. |
Elimina el registro del body en el gestor de colisiones. No elimina el cuerpo, si no estaba bajo la gestión de un GameObject debes hacerlo de forma manual.
bool CollisionManager::removeCollisionCallback | ( | int | typeA, | |
int | typeB | |||
) |
typeA | tipo del primer objeto | |
typeB | tipo del segundo objeto |
Elimina el callback entre objetos de tipos typeA-typeB (y viceversa). Ya no se detectarán colisiones entre dichos tipos.