GameWorld.ixx File

Central game state container for entities, resources, and the active level. More...

Included Headers

#include <cassert> #include <format> #include <helios-engine-config.h> #include <memory> #include <span> #include <string> #include <helios.engine.runtime.world.concepts> #include <helios.engine.runtime.world.EngineWorld> #include <helios.ecs.View> #include <helios.engine.util.log.LogManager> #include <helios.engine.util.log.Logger> #include <helios.engine.util.Guid> #include <helios.engine.runtime.world.Level> #include <helios.engine.runtime.world.Manager> #include <helios.engine.runtime.messaging.command.concepts> #include <helios.engine.runtime.world.types.GameObjectHandle> #include <helios.engine.runtime.world.Session> #include <helios.engine.runtime.world.types.GameObjectId> #include <helios.engine.core.thread.JobSystem> #include <helios.engine.runtime.timing.TimerManager> #include <helios.engine.runtime.world.UpdateContext> #include <helios.ecs.Entity> #include <helios.engine.platform.environment.types> #include <helios.engine.runtime.world.ManagerRegistry> #include <helios.engine.runtime.messaging.command.CommandHandlerRegistry> #include <helios.engine.runtime.world.ResourceRegistry> #include <helios.engine.runtime.messaging.command.CommandBufferRegistry> #include <helios.engine.runtime.world.RuntimeEnvironment> #include <helios.engine.runtime.world.GameObject>

Namespaces Index

namespace	helios
namespace	engine
namespace	runtime
namespace	world

Classes Index

class	GameWorld
	Runtime root object coordinating world domains, resources, and frame services. More...

Macro Definitions Index

#define	HELIOS_LOG_SCOPE   "GameWorld"

Description

Central game state container for entities, resources, and the active level.

Macro Definitions

HELIOS_LOG_SCOPE

#define HELIOS_LOG_SCOPE   "GameWorld"

Definition at line 57 of file GameWorld.ixx.

57#define HELIOS_LOG_SCOPE "GameWorld"

File Listing

The file content with the documentation metadata removed is:

1

5module;

6

7#include <cassert>

8#include <format>

9#include <helios-engine-config.h>

10#include <memory>

11#include <span>

12#include <string>

13

14export module helios.engine.runtime.world.GameWorld;

15

16import helios.engine.runtime.world.Session;

17

18import helios.engine.core.thread.JobSystem;

19

20import helios.engine.runtime.timing.TimerManager;

21

22import helios.ecs.Entity;

23import helios.engine.runtime.world.RuntimeEnvironment;

24import helios.engine.platform.environment.types;

25

26import helios.engine.runtime.messaging.command.CommandHandlerRegistry;

27import helios.engine.runtime.messaging.command.CommandBufferRegistry;

28

29import helios.engine.runtime.world.ManagerRegistry;

30import helios.engine.runtime.world.ResourceRegistry;

31

32import helios.engine.runtime.world.UpdateContext;

33import helios.engine.runtime.world.GameObject;

34import helios.engine.runtime.world.types.GameObjectId;

35import helios.engine.runtime.world.types.GameObjectHandle;

36import helios.engine.runtime.world.Manager;

37

38import helios.engine.util.Guid;

39import helios.engine.util.log.Logger;

40import helios.engine.util.log.LogManager;

41import helios.engine.runtime.world.Level;

42

43import helios.ecs.View;

44

45import helios.engine.runtime.messaging.command.concepts;

46

47import helios.engine.runtime.world.EngineWorld;

48import helios.engine.runtime.world.concepts;

49

50using namespace helios::engine::core::thread;

51using namespace helios::engine::runtime::timing;

52using namespace helios::engine::runtime::messaging::command::concepts;

53using namespace helios::engine::runtime::messaging::command;

54using namespace helios::engine::runtime::world::concepts;

55using namespace helios::engine::platform::environment::types;

56using namespace helios::engine::runtime::world::types;

57#define HELIOS_LOG_SCOPE "GameWorld"

58export namespace helios::engine::runtime::world {

59

68 class GameWorld {

69

70

71

72 protected:

73

74

80 inline static const helios::engine::util::log::Logger& logger_ = helios::engine::util::log::LogManager::loggerForScope(

81 HELIOS_LOG_SCOPE);

82

88 std::unique_ptr<Level> level_ = nullptr;

89

90

98 ResourceRegistry resourceRegistry_;

99

108 CommandHandlerRegistry commandHandlerRegistry_;

109

113 EngineWorld engineWorld_{};

114

118 Session session_;

119

123 RuntimeEnvironment runtimeEnvironment_;

124

128 JobSystem& jobSystem_;

129

130 public:

131

138 explicit GameWorld(JobSystem& jobSystem, const size_t capacity = ENTITY_MANAGER_DEFAULT_CAPACITY)

139 : session_(Session(engineWorld_.add<GameObjectHandle>())),

140 runtimeEnvironment_(RuntimeEnvironment(engineWorld_.add<PlatformHandle>())),

141 jobSystem_(jobSystem)

142 {};

143

147 GameWorld(const GameWorld&) = delete;

148 GameWorld operator=(const GameWorld&) = delete;

149 GameWorld(const GameWorld&&) = delete;

150 GameWorld operator=(const GameWorld&&) = delete;

151

157 [[nodiscard]] Session& session() {

158 return session_;

159 }

160

166 [[nodiscard]] JobSystem& jobSystem() {

167 return jobSystem_;

168 }

169

175 [[nodiscard]] RuntimeEnvironment& runtimeEnvironment() {

176 return runtimeEnvironment_;

177 }

178

179

180

190 GameWorld& init() {

191 for (auto& mgr : resourceRegistry_.managers()) {

192 mgr->init(commandHandlerRegistry_);

193 }

194

195 for (auto& buff : resourceRegistry_.commandBuffers()) {

196 buff->init(commandHandlerRegistry_, resourceRegistry_.managerRegistry());

197 }

198

199 return *this;

200 }

201

207 void setLevel(std::unique_ptr<Level> level) noexcept {

208 level_ = std::move(level);

209 }

210

216 [[nodiscard]] bool hasLevel() const noexcept{

217 return level_ != nullptr;

218 }

219

227 [[nodiscard]] const Level* level() const noexcept{

228 return level_.get();

229 }

230

238 template<typename T>

239 requires IsManagerLike<T>

240 [[nodiscard]] bool hasManager() const {

241 return resourceRegistry_.has<T>();

242 }

243

251 template<typename T>

252 requires IsCommandBufferLike<T>

253 [[nodiscard]] bool hasCommandBuffer() const {

254 return resourceRegistry_.has<T>();

255 }

256

271 template<typename T, typename... Args>

272 requires IsManagerLike<T>

273 T& registerManager(Args&&... args) {

274 return resourceRegistry_.emplace<T>(std::forward<Args>(args)...);

275 }

276

291 template<typename T, typename... Args>

292 requires IsCommandBufferLike<T>

293 T& registerCommandBuffer(Args&&... args) {

294 return resourceRegistry_.emplace<T>(std::forward<Args>(args)...);

295 }

296

306 template<typename T>

307 requires IsManagerLike<T>

308 T& manager() const noexcept {

309 assert(resourceRegistry_.has<T>() && "Manager not registered");

310 return resourceRegistry_.get<T>();

311 }

312

320 template<typename T>

321 requires IsManagerLike<T>

322 T* tryManager() const noexcept {

323 return resourceRegistry_.tryGet<T>();

324 }

325

333 template<typename T>

334 requires IsCommandBufferLike<T>

335 T* tryCommandBuffer() const noexcept {

336 return resourceRegistry_.tryGet<T>();

337 }

338

349 template<typename T>

350 requires IsCommandBufferLike<T>

351 T& commandBuffer() const noexcept {

352 return resourceRegistry_.get<T>();

353 }

354

355

371 template<typename... CommandType, typename OwningT>

372 requires IsCommandHandlerLike<OwningT, CommandType...>

373 void registerCommandHandler(OwningT& owner) {

374 (commandHandlerRegistry_.template registerHandler<CommandType>(owner), ...);

375 }

376

382 [[nodiscard]] CommandHandlerRegistry& commandHandlerRegistry() noexcept {

383 return commandHandlerRegistry_;

384 }

385

386

393 void reset() {

394 for (auto& mgr : resourceRegistry_.managers()) {

395 mgr->reset();

396 }

397

398 session_.reset();

399 }

400

410 ResourceRegistry& resourceRegistry() noexcept {

411 return resourceRegistry_;

412 }

413

417 const ResourceRegistry& resourceRegistry() const noexcept {

418 return resourceRegistry_;

419 }

420

426 [[nodiscard]] PlatformWorld& platformWorld() noexcept{

427 return engineWorld_.platformWorld();

428 }

429

435 [[nodiscard]] RenderResourceWorld& renderResourceWorld() noexcept{

436 return engineWorld_.renderResourceWorld();

437 }

438

444 [[nodiscard]] RenderTargetWorld& renderTargetWorld() noexcept{

445 return engineWorld_.renderTargetWorld();

446 }

447

453 [[nodiscard]] GameObjectWorld& gameObjectWorld() noexcept{

454 return engineWorld_.gameObjectWorld();

455 }

456

457

463 [[nodiscard]] EngineWorld& engineWorld() noexcept{

464 return engineWorld_;

465 }

466

475 template <typename THandle, typename... Components>

476 [[nodiscard]] auto view() {

477 return engineWorld_.view<THandle, Components...>();

478 }

479

489 template<typename THandle>

490 [[nodiscard]] auto find(const THandle handle) noexcept {

491 return engineWorld_.template find<THandle>(handle);

492 }

493

503 template<typename THandle>

504 [[nodiscard]] auto add(const typename THandle::StrongId_type strongId = typename THandle::StrongId_type{}, const bool isActive = true) noexcept {

505 auto entity = engineWorld_.template add<THandle>(strongId);

506 entity.setActive(isActive);

507 return entity;

508 }

509

519 template<typename THandle>

520 [[nodiscard]] auto destroy(const THandle handle) noexcept {

521 return engineWorld_.template destroy<THandle>(handle);

522 }

523

529 helios::engine::runtime::messaging::command::CommandBufferRegistry& commandBufferRegistry() noexcept {

530 return resourceRegistry().commandBufferRegistry();

531 }

532

533

539 ManagerRegistry& managerRegistry() noexcept {

540 return resourceRegistry().managerRegistry();

541 }

542

549 template<typename THandle>

550 auto& entityManager() noexcept {

551 return engineWorld_.template entityManager<THandle>();

552 }

553

554 };

555

556}

557

---

Generated via doxygen2docusaurus 2.0.0 by Doxygen 1.9.8.