实体组件系统和多个组件共享公共基本类型

问题描述 投票：3回答：2

我正在尝试为我的游戏引擎实现一个简单的ECS。我知道我的实现并不是严格的ECS，但我正在重构我的代码，使其更加基于组件。到目前为止，我有以下课程：

Entity：它是组件的容器，因为我希望我的实体具有相同类型的多个组件，所以它将它们存储在std::map<ComponentID,std::vector<std::unique_ptr<Component>>>中。每个组件都有一个唯一的ID（unsigned int），我从网上学到的简单模板技巧中得到：

一个名为GetUniqueComponentID的函数：

using ComponentID = unsigned int;

inline ComponentID GetUniqueComponentID()
{
    static ComponentID id = 0;

    return id++;
}

包含一个简单地生成递增数字的计数器。我从名为GetComponentID的函数模板中调用此函数：

template <typename T>
ComponentID GetComponentID()
{
    static ComponentID id = GetUniqueComponentID();

    return id;
}

此模板为我添加到我的实体的每个组件实例化一个不同的函数，因此需要检索组件的代码可以使用GetComponentId<Component_type>索引地图，具体组件类型作为函数的模板参数。

实体类具有AddComponent和GetComponent等方法，分别创建组件并将其添加到实体，并检索组件（如果存在）：

class Entity
{
public:
    Entity();
    ~Entity();
    template <typename T, typename... TArgs>
    T &AddComponent(TArgs&&... args);
    template <typename T>
    bool HasComponent();
    //template <typename T>
    //T &GetComponent();
    template <typename T> 
    std::vector<T*> GetComponents();
    bool IsAlive() { return mIsAlive; }
    void Destroy() { mIsAlive = false; }
private:
    //std::map<ComponentID, std::unique_ptr<Component>> mComponents;              // single component per type
    std::map<ComponentID, std::vector<std::unique_ptr<Component>>> mComponents;   // multiple components per type
    bool mIsAlive = true;
};


template <typename T, typename... TArgs>
T &Entity::AddComponent(TArgs&&... args)
{
    T *c = new T(std::forward<TArgs>(args)...);
    std::unique_ptr<Component> component(c);
    component->SetEntity(this);
    mComponents[GetComponentID<T>()].push_back(std::move(component));
    return *c;
}

template <typename T>
bool Entity::HasComponent()  // use bitset (faster)
{
    std::map<ComponentID, std::vector<std::unique_ptr<Component>>>::iterator it = mComponents.find(GetComponentID<T>());
    if (it != mComponents.end())
        return true;
    return false;
}

template <typename T>
std::vector<T*> Entity::GetComponents()
{
    std::vector<T*> components;
    for (std::unique_ptr<Component> &component : mComponents[GetComponentID<T>()])
        components.push_back(static_cast<T*>(component.get()));

    return components;
}

由于我想存储多个相同类型的组件，我将它们存储在std::map<ComponentID,std::vector<std::unique_ptr<Component>>>中。

现在我的问题是：

我需要为一种组件创建一个组件层次结构：我有一个ForceGenerator组件，它是各种具体ForceGenerators（Springs，Gravity等）的（抽象）基类。所以我需要创建具体的组件，但我需要通过指向基类的指针多态地使用它们：我的物理子系统只需要关注指向基础ForceGenerator的指针，调用它的Update（）方法来处理更新力。

我不能使用当前的方法，因为每次创建特定的ForceGenerator组件时我都会使用不同的类型调用AddComponent，而我需要将它们存储在同一个数组中（映射到基本ForceGenerator的组件ID）。

我怎么能解决这个问题？

c++ game-engine game-physics entity-component-system
2个回答
1
投票

你可以使用这样的默认模板参数：

class Entity
{
template <typename T,typename StoreAs=T, typename... TArgs>
    T &Entity::AddComponent(TArgs&&... args);
};
template <typename T,typename StoreAs, typename... TArgs>
T &Entity::AddComponent(TArgs&&... args)
{
     T *c = new T(std::forward<TArgs>(args)...);
     std::unique_ptr<Component> component(c);
     component->SetEntity(this);
     mComponents[GetComponentID<StoreAs()].push_back(std::move(component));
     return *c;
}

被称为

 entity.AddComponent<T>(...)//Will instatiate AddComponent<T,T,...>
 entity.AddComponent<T,U>(...)//Will instatiate AddComponent<T,U,...>

您甚至可以更进一步使用一些SFINAE来仅在组件可以存储为该类型时启用此功能:(可能或可能实际上不会改进错误消息）

template <typename T,typename StoreAs, typename... TArgs>
std::enable_if_t<std::is_base_of_v<StoreAs,T>,T&> //Return type is `T&`
Entity::AddComponent(TArgs&&... args)
{
     T *c = new T(std::forward<TArgs>(args)...);
     std::unique_ptr<Component> component(c);
     component->SetEntity(this);
     mComponents[GetComponentID<StoreAs>()].push_back(std::move(component));
     return *c;
}

我假设Component是所有组件的基类。如果你有一组有限的，已知的组件，你可以将它们存储在std::variant<List types here>而不是唯一的指针。

编辑：显然clang抱怨：“模板参数重新定义默认参数”。 Gcc不介意，但只是为了正确，把StoreAs初始化StoreAs=T只在Entity类中，而不是实现。我编辑了源代码。

1
投票

新提案

看看另一个答案我得到了一个想法，你可以继承另一个CRTP基类来定义存储位置（仅当使用映射存储时）。

例：

//Just for check class
struct StoreAs {};


//Give the store type
template<typename T>
struct StoreAsT : public StoreAs {
    using store_as_type = T;
};

//Some components
struct ComponentA {    };

struct ComponentC {    };

struct ComponentB : public StoreAsT<ComponentC> {    };


//Dummy add
template<typename T>
void Add(T&& cmp) {
    if constexpr(std::is_base_of_v<StoreAs, T>) {
        std::cout << "Store as (remap)" << GetComponentID<typename T::store_as_type>() << std::endl;
    } else {
        std::cout << "Store as " << GetComponentID<T>() << std::endl;
    }
}

//Example add
int main() {

    Add(ComponentA {});
    Add(ComponentB {});
    Add(ComponentC {});

    return 0;
}

输出：

Store as 0
Store as (remap)1
Store as 1

旧提案：

作为一种简单的方法，但非常详细，而不是通用解决方案，您可以扩展您的ID生成技巧：

template <typename T>
ComponentID GetComponentID()
{
    static ComponentID id = GetUniqueComponentID();

    return id;
}

至

template <typename T>
struct ComponentIDGenerator {
    static ComponentID GetComponentID() {
        static ComponentID id = GetUniqueComponentID();

        return id;
    }
};

现在，您需要使用ComponenteIDGenerator :: GetComponentID（），而不是使用GetComponentID，但现在您可以创建特定的特化。

因此，您可以专门重新映射一些ID：

template<>
struct ComponentIDGenerator<SomeForce1> {
    static ComponentID GetComponentID() {
        return ComponentIDGenerator<NotRemappedForceType>::GetComponentID();
    }
};
template<>
struct ComponentIDGenerator<SomeForce2> {
    static ComponentID GetComponentID() {
        return ComponentIDGenerator<NotRemappedForceType>::GetComponentID();
    }
};

现在两个（SomeFroce1和SomeForce2）都返回“NotRemappedForceType”的id

并在最后恢复原来的功能：

template<typename T>
ComponentID GetComponentID() {
    return ComponentIDGenerator<T>::GetComponentID();
}
最新问题
© www.soinside.com 2019 - 2024. All rights reserved.