Question

我正在尝试编写一个EntityType类，该类可以接收和存储可变数量的Component类型。

struct Health { int amount; }
struct Position { float x, y; }

EntityType entityType = new EntityType<Health, Position>();

然后，我将稍后将此EntityType类用作为组件分配紧凑包装的内存的蓝图。

EntityManager.BatchCreate(3, entityType);
// Result: Health | Health | Health | Position | Position | Position

创建具有多个参数的类模板很容易，但是：

我如何存储以后用作分配蓝图的类型？
我可以查询EntityType中有哪些类型吗？

我最初想到存储的是元组，但是我不确定。它们采用传入类型的实际值，而不是类型本身。我能以某种方式使用typeid吗？

我基本上是在尝试用C ++复制Unity在{＃3}}中用C＃所做的事情，我相信它正在使用反射。

Answer 1

我如何存储以后用作分配蓝图的类型？

由于知道编译时组件的类型，因此可以使用如下类型的别名：

template<class... Components>
struct Entities {
  /* ... to be implemented ... */
};

using HealthsPositions = Entities<Health, Position>;

我可以查询EntityType中有哪些类型吗？

是的，这在编译时也是已知的。看来std命名空间中没有帮助程序来测试类型列表中是否包含类型（请参阅对this question的回答的多样性）。因此，这是解决C ++ 14中此 template-metaprogramming 任务的另一种方法：

template<class Component, class EntitiesCs>
struct IsComponentOf;

template<class Component, class... Cs>
struct IsComponentOf<Component, Entities<Cs...>> {// partial specialization
  static constexpr bool value_() {
    bool ret = false;
    for(bool is_same : {std::is_same<Component, Cs>{}()...}) {
      ret |= is_same;
    }
    return ret;
// C++17 version with fold expression:
//     return (... || std::is_same<Component, Cs>{});
  }

  static constexpr bool value = value_();
  constexpr operator bool() const { return value; }
};

static_assert(IsComponentOf<Health, HealthsPositions>{}, "");
static_assert(IsComponentOf<Position, HealthsPositions>{}, "");
static_assert(not IsComponentOf<int, HealthsPositions>{}, "");

我可以以某种方式使用typeid吗？

是的，但这是我上面描述的另一种方法：上面的内容在编译时有效。 typeid operator来自运行时类型信息（RTTI）领域。不幸的是，std::type_info不能在编译时使用。

然后我将稍后使用此EntityType类作为为组件分配紧凑包装内存的蓝图。
EntityManager.BatchCreate(3, entityType);
// Result: Health | Health | Health | Position | Position | Position

如果您确实希望组件紧密包装，并且希望能够调整“容器”的大小，那么我看不到简单的解决方案。在理想情况下，HealthsPositions存储，例如

第一个Health组件开始的内存的指针状成员，
一个std::size_t（或其他任何成员）成员，用于存储每种类型的组件数，并且
一个std::size_t（或其他任何成员）成员，用于存储每种类型的组件容量。

理想情况下，需要一些自定义内存管理（包括对齐注意事项）。

但是，一个很好的起点可能是这种替代性简单设计：

#include <cstddef>

#include <iostream>
#include <tuple>
#include <type_traits>
#include <vector>

struct Health { int amount; };
struct Position { float x; float y; };

template<class C0, class... Cs>
struct Entities {
  std::tuple<
    std::vector<C0>, std::vector<Cs>...
  > components;

  Entities(std::size_t size)
    : components{size, (0*sizeof(Cs) + size)...}
  {}
};

template<class Component, class... Cs>
constexpr std::vector<Component>& get(Entities<Cs...>& e) {
  using ComponentVector = std::vector<Component>;
  return std::get<ComponentVector>(e.components);
}

template<class Component, class... Cs>
constexpr const std::vector<Component>& get(const Entities<Cs...>& e) {
  using ComponentVector = std::vector<Component>;
  return std::get<ComponentVector>(e.components);
}

////////////////////////////////////////////////////////////////////////////////

using HealthsPositions = Entities<Health, Position>;

constexpr std::size_t expected_size =
  sizeof(std::vector<Health>) + sizeof(std::vector<Position>);

static_assert(sizeof(HealthsPositions) == expected_size, "");

int main() {
  std::size_t entity_count = 7;
  HealthsPositions hps(entity_count);

  get<Health>(hps).at(2).amount = 40;
  get<Position>(hps).at(5) = Position{3.5f, 8.4f};

  std::cout << "health address and value:\n";
  for(auto&& h : get<Health>(hps)) {
    std::cout << &h << "\t" << h.amount << "\n";
  }

  std::cout << "position address and value:\n";
  for(auto&& p : get<Position>(hps)) {
    std::cout << &p << "\t" << p.x << "\t" << p.y << "\n";
  }
}

示例输出：

health address and value:
0x55adba092eb0  0
0x55adba092eb4  0
0x55adba092eb8  40
0x55adba092ebc  0
0x55adba092ec0  0
0x55adba092ec4  0
0x55adba092ec8  0
position address and value:
0x55adba092e70  0   0
0x55adba092e78  0   0
0x55adba092e80  0   0
0x55adba092e88  0   0
0x55adba092e90  0   0
0x55adba092e98  3.5 8.4
0x55adba092ea0  0   0

如何存储模板类型以供以后分配？

1 个答案: