Как проиндексировать все производные компоненты в списке базовых компонентов в Entity

Question

Я пытаюсь сделать дизайн системы компонентов объекта для моделирования. Вот что меня смущает сейчас. Я пытаюсь сделать класс Entity

Entity.h
class Entity
{
public:
    Entity();
    virtual ~Entity() = 0;
    //---------------------Methods---------------------//
    void AddComponent(const shared_ptr<Component> component);

    template<class T>
    T* GetComponent() const;

    //---------------------Members---------------------//
    vector<shared_ptr<Component>>   m_components;
}

Entity.cpp
template<typename T>
T* Entity::GetComponent() const
{
    Component::component_type_t typeIndex = /*T::component_type*/
    T* returnPtr = dynamic_pointer_cast<T>(m_components[component_type].get());
    return returnPtr;
}

И класс Component выглядит так

class Component
{
public:
    Component();
    virtual ~Component() = 0;
    //---------------------Methods---------------------//

    //---------------------Members---------------------//
    typedef enum component_type_t
    {
        MESH_T,
        RIGIDBODY_T,
        TRANSFORM_T,
        NUM_TYPES
    };
    component_type_t componentType;
};

Они так, как я хочу использовать GetComponent() такой же, как в Unity3D

Transform* t = GetComponent<Transform>()

Но, как вы видите, я пока не могу найти способ сделать это. То, как я это делал, было

class Entity
{
    .....
    Component* GetComponent(Component::component_type_t componentType) const
    {
      return m_components[component_type].get()
    };
}

И я мог использовать его только как

Transform* t = dynamic_pointer_cast<Transform>(GetComponent(Component::component_type_t::TRANSFORM_T));

Очевидно, это утомительно.

Итак, мой вопрос, могу ли я использовать какую-то форму?

class Entity
{
    .....
    template<class T>
    T* GetComponent() const
    {
    Component::component_type_t typeIndex = /*T::component_type*/
    T* returnPtr = dynamic_pointer_cast<T>(m_components[component_type].get());
    return returnPtr;
    };
}

Я чувствую чистоту и скорость, чтобы продолжать использовать std::vector<> для хранения всех моих указателей компонентов, это также допустимый дизайн?

Answer 1

Делал что-то подобное давно. Я думаю, что вы делаете это трудным путем. Вы можете легко изменить приведенный ниже код в соответствии с вашими потребностями. Components наследуются Вы можете удалить наследование и заменить его классом внутри класса или всеми классами компонентов внутри Component учебный класс.

#include <iostream>

struct Vector3
{
    float x, y, z;
    Vector3(float x, float y){}
    Vector3(float x, float y,float z){}
};

template <class T>
class Component
{
public:
    T t;
    void adNewComponent(){

    }
};

class Mesh{
public:
    Mesh(){}
};

class Rigidbody{
public:
    Rigidbody(){}
    void AddForce(float x,float y, float z){}
    void AddForce(Vector3 force){}
};


class Transform{
public:
    Transform(){}
};

class Object{

};

class GameObject:Object,
    Component<Mesh>,
    Component<Rigidbody>,
    Component<Transform>
{
public:
     template <class T>
     T &GetComponent()
    {
        return this->Component<T>::t;
    }

     template <class T>
     T &AddComponent(){
         this->Component<T>::adNewComponent();
         return this->Component<T>::t;
     }
};


int _tmain(int argc, _TCHAR* argv[])
{

    GameObject gameObject;
    gameObject.AddComponent<Rigidbody>();
    Rigidbody rigidBody = gameObject.GetComponent<Rigidbody>();
    rigidBody.AddForce(9,0,0);

    std::cin.get();
    return 0;
}