Gestor que registra los bodies, detecta colisions y proporciona un sistema de callbacks. Más...
#include <collisionManager.h>
Tipos públicos | |
enum | CallbackType { BEGINCOLLISION, COLLIDING, ENDCOLLISION, ALL } |
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 callback, CallbackType callbackType=BEGINCOLLISION) |
bool | removeCollisionCallback (int typeA, int typeB, CallbackType callbackType=ALL) |
void | removeAllCollisionCallbacks (CallbackType type=ALL) |
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:
bool 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 devuelve un boolean
Tipo de callback. Según el tipo de callback se llamará en un momento u otro:
BEGINCOLLISION: iteración del game loop en el que dos cuerpos entran en contacto. COLLIDING: iteraciones posteriores en las que los cuerpos siguen en contacto. ENDCOLLISION: iteración en el que cuerpos que estaban colisionando dejan de hacerlo.
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 | callback, | |||
CallbackType | callbackType = BEGINCOLLISION | |||
) |
typeA | tipo del primer objeto | |
typeB | tipo del segundo objeto | |
callback | objeto función que recibe dos punteros a cuerpos y devuelve un booleano. | |
callbackType | tipo de callback (begin, in o end) |
Registra un callback que será llamado cuando dos cuerpos de los tipos dados colisionen. Dependiendo del tipo de callback la llamada se producirá en un momento u otro: al comienzo, durante o al final de la colisión.
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 | ( | CallbackType | type = ALL |
) |
type | tipo de callback a eliminar. |
Elimina todos los callbacks registrados en el gestor de colisiones del tipo indicado. Si se pasa ALL, se eliminan todos los callbacks.
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, | |||
CallbackType | callbackType = ALL | |||
) |
typeA | tipo del primer objeto | |
typeB | tipo del segundo objeto | |
callbackType | tipo de callback que se va a eliminar |
Elimina el tipo de callback entre objetos de tipos typeA-typeB (y viceversa). Ya no se detectarán colisiones entre dichos tipos.