Collidable.h

#ifndef Collidable_h
#define Collidable_h
 
#include "CollisionManager.h"
#include "../../Scene/SceneAttorney.h"
#include "../RegistrationState.h"
#include "CollidableGroup.h"
#include "VolumeType.h"
//#include "CollisionVolumeBSphere.h"
 
class CollisionRegistrationCommand;
class CollisionDeregistrationCommand;
class CollisionVolume;
class CollisionVolumeBSphere;
class CollisionVolumeAABB;

class Collidable
{
protected:
    Collidable();
    Collidable(const Collidable&) = delete;
    Collidable& operator=(const Collidable&) = delete;
    virtual ~Collidable();

    template <typename C>
    void SetCollidableGroup()
    {
        myTypeID = SceneAttorney::Registration::GetCollisionManager()->GetTypeID<C>();
    }

    void SubmitCollisionRegistration();

    void SubmitCollisionDeregistration();

    void SetColliderModel(Model* mod, VolumeType v);

    void UpdateCollisionData(const Matrix& mat);

    void VisualizeCollisionVolume(VolumeType t, const Vect& color) const;

    void VisualizeDefaultBSphere(const Vect& color) const;

    void VisualizeGroupAABB(const Vect& color) const;
 
public:
    const CollisionVolume& GetCollisionVolume();

    const CollisionVolumeBSphere& GetDefaultBSphere() const;
 
private:
    friend class CollidableAttorney;

    void SceneRegistration();

    void SceneDeregistration();

    CollidableGroup::CollidableCollectionRef& GetGroupRef();

    CollisionManager::PWTypeID myTypeID = CollisionManager::PWID_UNDEFINED;

    RegistrationState RegStateCurr;

    CollisionRegistrationCommand* ptrColRegistrationCmd;

    CollisionDeregistrationCommand* ptrColDeregistrationCmd;

    CollidableGroup::CollidableCollectionRef pGroupRef;

    CollisionVolume* pColVolume;

    Model* pColModel;

    CollisionVolumeBSphere* defaultBSphere;

    void UpdateDefaultBSphere(const Matrix& mat);
};
 
#endif