TypedHandleWorld.ixx File

Multi-domain entity world with compile-time handle-to-manager dispatch. More...

Included Headers

#include <ostream> #include <tuple> #include <utility> #include <vector> #include <type_traits> #include <optional> #include <cstddef> #include <helios.ecs.Entity> #include <helios.ecs.View>

Namespaces Index

namespace	helios
namespace	ecs

Classes Index

struct	HandleToManager<THandle, THead, TTail...>
struct	HandleToManager<THandle, THead>
struct	HandleToManager<THandle>
class	TypedHandleWorld<TEntityManagers>
	A multi-domain entity world that dispatches operations to the correct EntityManager based on the handle type. More...

Description

Multi-domain entity world with compile-time handle-to-manager dispatch.

File Listing

The file content with the documentation metadata removed is:

1

5module;

6

7

8#include <ostream>

9#include <tuple>

10#include <utility>

11#include <vector>

12#include <type_traits>

13#include <optional>

14#include <cstddef>

15

16export module helios.ecs.TypedHandleWorld;

17

18import helios.ecs.View;

19import helios.ecs.Entity;

20

21

32template<typename THandle, typename... TEntityManagers>

33struct HandleToManager;

34

35template<typename THandle, typename THead, typename ...TTail>

36struct HandleToManager<THandle, THead, TTail...> {

37 static constexpr size_t value = [] {

38 if constexpr (std::is_same_v<typename THead::Handle_type, THandle>) {

39 return size_t{0};

40 } else {

41 return size_t{1} + HandleToManager<THandle, TTail...>::value;

42 }

43 }();

44};

45

46template<typename THandle, typename THead>

47struct HandleToManager<THandle, THead> {

48 static_assert(

49 std::is_same_v<typename THead::Handle_type, THandle>,

50 "No EntityManager found for the given handle type."

51 );

52 static constexpr size_t value = 0;

53};

54

55

56template <typename THandle>

57struct HandleToManager<THandle> {

58 static_assert(sizeof(THandle) == 0, "No EntityManager found for the given handle type.");

59};

60

61export namespace helios::ecs {

62

63

120 template<typename... TEntityManagers>

121 class TypedHandleWorld {

122

123

124 public:

125

126 using EntityManager_types = std::tuple<TEntityManagers...>;

127

139 template<typename THandle>

140 auto& entityManager() {

141 constexpr size_t idx = HandleToManager<THandle, TEntityManagers...>::value;

142 return std::get<idx>(entityManagers_);

143 }

144

153 template<typename THandle>

154 const auto& entityManager() const {

155 constexpr size_t idx = HandleToManager<THandle, TEntityManagers...>::value;

156 return std::get<idx>(entityManagers_);

157 }

158

159

170 template<typename THandle>

171 [[nodiscard]] auto addEntity(typename THandle::StrongId_type strongId) {

172 auto& em = entityManager<THandle>();

173

174 auto handle = em.create(strongId);

175

176 return Entity{handle, &em};

177 }

178

186 template<typename THandle>

187 [[nodiscard]] auto addEntity() {

188 auto& em = entityManager<THandle>();

189

190 auto handle = em.create();

191

192 return Entity{handle, &em};

193 }

194

207 template<typename THandle>

208 bool destroy(THandle handle) {

209 auto& em = entityManager<THandle>();

210

211 return em.destroy(handle);

212 }

213

226 template<typename THandle>

227 [[nodiscard]] auto findEntity(THandle handle) {

228 auto& em = entityManager<THandle>();

229

230 using EM = std::remove_reference_t<decltype(em)>;

231 using Entity_type = Entity<EM>;

232

233 if (!em.isValid(handle)) {

234 return std::optional<Entity_type>{std::nullopt};

235 }

236

237 return std::optional<Entity_type>{std::in_place, handle, &em};

238 }

239

252 template<typename THandle>

253 [[nodiscard]] auto cloneEntity(THandle source) noexcept {

254 auto& em = entityManager<THandle>();

255

256 auto entity = addEntity<THandle>();

257

258 em.clone(source, entity.handle());

259

260 return entity;

261 }

262

277 template<typename THandle, typename ...TComponents>

278 [[nodiscard]] auto view() {

279 auto& em = entityManager<THandle>();

280 using EM = std::remove_reference_t<decltype(em)>;

281 return View<EM, TComponents...>(&em);

282 }

283

284 private:

285

286 EntityManager_types entityManagers_;

287 };

288

289}

290

---

Generated via doxygen2docusaurus 2.0.0 by Doxygen 1.9.8.