CollisionManager.h

#ifndef CollisionManager_H
#define CollisionManager_H
 
#include <vector>
#include <list>
 
#include "CollisionTestSelfCommand.h"
#include "CollisionTestPairCommand.h"
#include "CollisionTerrainCommand.h"
#include "CollisionDispatch.h"
#include "CollisionDispatchTerrain.h"
 
class CollidableGroup;
class CollisionTestCommandBase;

class CollisionManager
{
public:
    using PWTypeID = int;

    static const PWTypeID PWID_UNDEFINED = -1;
 
    CollisionManager();
    CollisionManager(const CollisionManager&) = delete;
    CollisionManager& operator=(const CollisionManager&) = delete;
    ~CollisionManager();

    CollidableGroup* GetColGroup(PWTypeID id);

    void ProcessElements();

    template <typename C>
    PWTypeID GetTypeID()
    {
        static PWTypeID myTypeID = TypeIDNextNumber++;
 
        SetGroupForTypeID(myTypeID);
 
        DebugMsg::out("CollisionManager: TypeID %d registered\n", myTypeID);
        return myTypeID;
    }
 
    void UpdateGroupAABBs();
    bool TestGroupCollision(CollidableGroup* g1, CollidableGroup* g2);
    void DebugRender();
 
private:
    const int MAX_COLLISION_GROUP = 64;

    static PWTypeID TypeIDNextNumber;

    using CollidableGroupCollection = std::vector<CollidableGroup*>;

    CollidableGroupCollection ColGroupCollection;

    void SetGroupForTypeID(CollisionManager::PWTypeID ind);

    using CollisionTestCommands = std::list<CollisionTestCommandBase*>;

    CollisionTestCommands colTestCommands;
 
public:
    template <typename C>
    void SetCollisionSelf()
    {
        CollidableGroup* pG = ColGroupCollection[GetTypeID<C>()];
        CollisionDispatch<C, C>* pDispatch = new CollisionDispatch<C, C>();
        colTestCommands.push_back(new CollisionTestSelfCommand(pG, pDispatch));
    }

    template <typename C1, typename C2>
    void SetCollisionPair()
    {
        CollidableGroup* pG1 = ColGroupCollection[GetTypeID<C1>()];
        CollidableGroup* pG2 = ColGroupCollection[GetTypeID<C2>()];
        CollisionDispatch<C1, C2>* pDispatch = new CollisionDispatch<C1, C2>();
        colTestCommands.push_back(new CollisionTestPairCommand(pG1, pG2, pDispatch));
    }
 
    //Terrain
    template <typename Type>
    void SetCollisionTerrain()
    {
        CollidableGroup* pG = ColGroupCollection[GetTypeID<Type>()];
        CollisionDispatchTerrain<Type>* pDispatch = new CollisionDispatchTerrain<Type>();
        colTestCommands.push_back(new CollisionTerrainCommand(pG, pDispatch));
    }
};
 
#endif