EntityManager Class Template

Manages entities and their associated components. More...

Declaration

template <typename THandle, typename TEntityRegistry, size_t TCapacity> class helios::ecs::EntityManager<THandle, TEntityRegistry, TCapacity> { ... }

Public Member Typedefs Index

template <typename THandle, typename TEntityRegistry, size_t TCapacity>
using	EntityRegistry_type = TEntityRegistry
template <typename THandle, typename TEntityRegistry, size_t TCapacity>
using	Handle_type = THandle
template <typename THandle, typename TEntityRegistry, size_t TCapacity>
using	StrongId_type = Handle_type::StrongId_type
template <typename THandle, typename TEntityRegistry, size_t TCapacity>
using	ComponentTypeId_type = ComponentTypeId< Handle_type >
template <typename THandle, typename TEntityRegistry, size_t TCapacity>
using	ComponentOpsRegistry_type = ComponentOpsRegistry< Handle_type >

Public Constructors Index

template <typename THandle, typename TEntityRegistry, size_t TCapacity>
EntityManager (const EntityManager &)=delete
	Non-copyable: copying an EntityManager is explicitly disabled. More...
template <typename THandle, typename TEntityRegistry, size_t TCapacity>
EntityManager (EntityManager &&) noexcept=default
template <typename THandle, typename TEntityRegistry, size_t TCapacity>
EntityManager (const size_t capacity=TCapacity)
	Constructs an EntityManager with the given capacity. More...
template <typename THandle, typename TEntityRegistry, size_t TCapacity>
EntityManager (EntityRegistry_type &registry, const size_t capacity=TCapacity)
	Constructs an EntityManager with an external registry. More...

Public Operators Index

template <typename THandle, typename TEntityRegistry, size_t TCapacity>
EntityManager &	operator= (const EntityManager &)=delete
template <typename THandle, typename TEntityRegistry, size_t TCapacity>
EntityManager &	operator= (EntityManager &&) noexcept=default

Public Member Functions Index

template <typename THandle, typename TEntityRegistry, size_t TCapacity>
Handle_type	create (StrongId_type strongId=StrongId_type{})
	Creates a new entity. More...
template <typename THandle, typename TEntityRegistry, size_t TCapacity>
bool	isValid (const Handle_type handle) const noexcept
	Checks if an entity handle is valid. More...
template <typename THandle, typename TEntityRegistry, size_t TCapacity>
bool	isValid (const EntityId entityId) const noexcept
	Checks if an entity ID is valid. More...
template <typename THandle, typename TEntityRegistry, size_t TCapacity>
bool	destroy (const Handle_type handle)
	Destroys an entity and invalidates its handle. More...
template <typename T>
T *	get (const Handle_type handle) const
	Retrieves a component for the given entity. More...
template <typename T>
auto	getSparseSet () -> SparseSet< T > *
	Returns the SparseSet for a component type. More...
template <typename T>
auto	getSparseSet () const -> const SparseSet< T > *
	Returns the SparseSet for a component type (const). More...
template <typename T>
bool	has (const Handle_type handle) const
	Checks whether an entity has a specific component. More...
template <typename THandle, typename TEntityRegistry, size_t TCapacity>
bool	has (const Handle_type handle, const ComponentTypeId_type typeId) const
	Checks whether an entity has a component by type ID. More...
template <typename THandle, typename TEntityRegistry, size_t TCapacity>
void	enable (const Handle_type handle, const ComponentTypeId_type typeId) const
	Enables a component by type ID. More...
template <typename THandle, typename TEntityRegistry, size_t TCapacity>
void	disable (const Handle_type handle, const ComponentTypeId_type typeId) const
	Disables a component by type ID. More...
template <typename THandle, typename TEntityRegistry, size_t TCapacity>
void	enable (const Handle_type handle, const ComponentTypeId_type typeId, const bool enable) const
	Enables or disables a component by type ID. More...
template <typename T, typename... Args>
T *	emplace (const Handle_type handle, Args &&...args)
	Constructs and attaches a component to an entity. More...
template <typename T, typename... Args>
T *	emplaceOrGet (const Handle_type handle, Args &&...args)
	Returns existing component or creates a new one. More...
template <typename T>
bool	remove (const Handle_type &handle)
	Removes a specific component from an entity. More...
template <typename TFunc>
void	forEachComponentTypeId (const Handle_type handle, TFunc &&func) const
	Returns a span over all component type IDs attached to an entity. More...
template <typename THandle, typename TEntityRegistry, size_t TCapacity>
void	clone (const Handle_type source, const Handle_type target)
	Clones all components from source entity to target entity. More...
template <typename THandle, typename TEntityRegistry, size_t TCapacity>
void *	raw (const Handle_type handle, const ComponentTypeId_type typeId) const
	Returns raw void pointer to a component. More...
template <typename THandle, typename TEntityRegistry, size_t TCapacity>
Handle_type	handle (const EntityId entityId) const
	Reconstructs an EntityHandle from an EntityId. More...

Private Member Attributes Index

template <typename THandle, typename TEntityRegistry, size_t TCapacity>
std::vector< std::unique_ptr< SparseSetBase > >	components_
	Component storage indexed by type ID. More...
template <typename THandle, typename TEntityRegistry, size_t TCapacity>
EntityRegistry_type	registry_
	Entity registry owned by this EntityManager. More...
template <typename THandle, typename TEntityRegistry, size_t TCapacity>
const size_t	capacity_
	Initial capacity for the underlying sparse sets. More...

Description

Manages entities and their associated components.

EntityManager provides a unified interface for creating entities and attaching/retrieving components. It delegates handle management to an EntityRegistry and stores component data in type-specific SparseSet containers.

Definition at line 73 of file EntityManager.ixx.

Public Member Typedefs

ComponentOpsRegistry_type

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

using helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::ComponentOpsRegistry_type = ComponentOpsRegistry<Handle_type>

Definition at line 82 of file EntityManager.ixx.

82 using ComponentOpsRegistry_type = ComponentOpsRegistry<Handle_type>;

ComponentTypeId_type

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

using helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::ComponentTypeId_type = ComponentTypeId<Handle_type>

Definition at line 81 of file EntityManager.ixx.

81 using ComponentTypeId_type = ComponentTypeId<Handle_type>;

EntityRegistry_type

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

using helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::EntityRegistry_type = TEntityRegistry

Definition at line 78 of file EntityManager.ixx.

78 using EntityRegistry_type = TEntityRegistry;

Handle_type

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

using helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::Handle_type = THandle

Definition at line 79 of file EntityManager.ixx.

79 using Handle_type = THandle;

StrongId_type

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

using helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::StrongId_type = Handle_type::StrongId_type

Definition at line 80 of file EntityManager.ixx.

80 using StrongId_type = Handle_type::StrongId_type;

Public Constructors

EntityManager()

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::EntityManager (const EntityManager &)

delete

Non-copyable: copying an EntityManager is explicitly disabled.

Definition at line 87 of file EntityManager.ixx.

EntityManager()

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::EntityManager (EntityManager &&)

noexcept default

Definition at line 90 of file EntityManager.ixx.

EntityManager()

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::EntityManager (const size_t capacity=TCapacity)

inline explicit

Constructs an EntityManager with the given capacity.

Creates an internally owned EntityRegistry initialized with the specified capacity.

Parameters

capacity

Initial capacity for the registry and sparse sets. Defaults to TCapacity.

Definition at line 102 of file EntityManager.ixx.

102 explicit EntityManager(const size_t capacity = TCapacity)

103 : registry_(EntityRegistry_type{capacity}), capacity_(capacity)

104 {}

EntityManager()

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::EntityManager (EntityRegistry_type & registry, const size_t capacity=TCapacity)

inline explicit

Constructs an EntityManager with an external registry.

Parameters

registry	External EntityRegistry to use for handle allocation.
capacity	Initial capacity for the sparse sets. Defaults to TCapacity.

Definition at line 116 of file EntityManager.ixx.

116 explicit EntityManager(

117 EntityRegistry_type& registry,

118 const size_t capacity = TCapacity)

119 : registry_(registry), capacity_(capacity)

120 {}

Public Operators

operator=()

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

EntityManager & helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::operator= (const EntityManager &)

delete

Definition at line 88 of file EntityManager.ixx.

operator=()

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

EntityManager & helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::operator= (EntityManager &&)

noexcept default

Definition at line 91 of file EntityManager.ixx.

Public Member Functions

clone()

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

void helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::clone (const Handle_type source, const Handle_type target)

inline

Clones all components from source entity to target entity.

Iterates through all components on the source and copies them to the target using the registered clone function. Skips components that already exist on the target.

Parameters

source	The entity to clone from.
target	The entity to clone to.

Definition at line 493 of file EntityManager.ixx.

493 void clone(const Handle_type source, const Handle_type target) {

494

495 if (!registry_.isValid(source)) {

496 return;

497 }

498

499 forEachComponentTypeId(

500 [&](const ComponentTypeId_type typeId) {

501 if (!has(target, typeId)) {

502

503 const auto& ops = ComponentOpsRegistry_type::ops(typeId);

504 const void* sourceCmp = raw(source, typeId);

505

506 if (sourceCmp && ops.clone) {

507 ops.clone(this, sourceCmp, &target);

508 }

509 }

510 }

511 );

512

513 }

References helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::forEachComponentTypeId, helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::has, helios::ecs::ComponentOpsRegistry< THandle >::ops and helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::raw.

create()

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

Handle_type helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::create (StrongId_type strongId=StrongId_type{})

inline

Creates a new entity.

Delegates to the underlying EntityRegistry to allocate a new handle.

Returns

A valid EntityHandle for the newly created entity.

See Also

EntityRegistry::create

Definition at line 131 of file EntityManager.ixx.

131 [[nodiscard]] Handle_type create(StrongId_type strongId = StrongId_type{}) {

132 return registry_.create(strongId);

133 }

destroy()

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

bool helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::destroy (const Handle_type handle)

inline

Destroys an entity and invalidates its handle.

Increments the entity's version in the registry, making all existing handles to this entity stale. Does automatically remove its components from storage.

Parameters

handle

The handle of the entity to destroy.

Returns

true if the entity was destroyed, false if already invalid.

Definition at line 168 of file EntityManager.ixx.

168 [[nodiscard]] bool destroy(const Handle_type handle) {

169

170 if (!registry_.isValid(handle)) {

171 return false;

172 }

173

174 for (size_t i = 0; i < components_.size(); i++) {

175

176 if (!components_[i]) {

177 continue;

178 }

179 const auto typeId = ComponentTypeId_type{i};

180 if (void* rawCmp = raw(handle, typeId)) {

181 if (const auto& ops = ComponentOpsRegistry_type::ops(typeId); ops.onRemove) {

182 ops.onRemove(rawCmp);

183 }

184 }

185

186 components_[i]->remove(handle.entityId);

187 }

188

189 registry_.destroy(handle);

190

191 return true;

192 }

References helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::handle, helios::ecs::types::ComponentOps::onRemove, helios::ecs::ComponentOpsRegistry< THandle >::ops and helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::raw.

disable()

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

void helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::disable (const Handle_type handle, const ComponentTypeId_type typeId)

inline

Disables a component by type ID.

Calls the component's disable() method if registered.

Parameters

handle	The entity whose component to disable.
typeId	The component type identifier.

Definition at line 324 of file EntityManager.ixx.

324 void disable(const Handle_type handle, const ComponentTypeId_type typeId) const {

325 enable(handle, typeId, false);

326 }

References helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::enable and helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::handle.

emplace()

template <typename T, typename... Args>

T * helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::emplace (const Handle_type handle, Args &&... args)

inline

Constructs and attaches a component to an entity.

If the component type has not been registered yet, a new SparseSet is created. The component is constructed in-place with the provided arguments. Returns nullptr if the component already exists or if the handle was invalid.

Template Parameters

T	The component type to emplace.
Args	Constructor argument types.

Parameters

handle	The entity to attach the component to.
args	Arguments forwarded to the component constructor.

Returns

Pointer to the newly created component, or nullptr if the handle is invalid.

Definition at line 372 of file EntityManager.ixx.

372 T* emplace(const Handle_type handle, Args&& ...args) {

373

374 if (!registry_.isValid(handle)) {

375 return nullptr;

376 }

377

378 const auto entityId = handle.entityId;

379

380 const auto typeId = ComponentTypeId_type::template id<T>().value();

381

382 if (typeId >= components_.size()) {

383 components_.resize(typeId + 1);

384 }

385

386 if (!components_[typeId]) {

387 components_[typeId] = std::make_unique<SparseSet<T>>(capacity_);

388 }

389

390 auto* sparseSet = static_cast<SparseSet<T>*>(components_[typeId].get());

391

392 if (sparseSet->contains(entityId)) {

393 return nullptr;

394 }

395

396 return sparseSet->emplace(entityId, std::forward<Args>(args)...);

397 }

References helios::ecs::SparseSet< T >::emplace and helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::handle.

emplaceOrGet()

template <typename T, typename... Args>

T * helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::emplaceOrGet (const Handle_type handle, Args &&... args)

inline

Returns existing component or creates a new one.

Template Parameters

T	The component type.
Args	Constructor argument types.

Parameters

handle	The entity.
args	Arguments forwarded to the constructor if creating.

Returns

Pointer to the existing or newly created component, or nullptr if the handle is invalid.

Definition at line 412 of file EntityManager.ixx.

412 T* emplaceOrGet(const Handle_type handle, Args&& ...args) {

413

414 if (!registry_.isValid(handle)) {

415 return nullptr;

416 }

417

418 auto* raw = emplace<T>(handle, std::forward<Args>(args)...);

419

420 if (!raw) {

421 return get<T>(handle);

422 }

423

424 return raw;

425 }

References helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::handle and helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::raw.

enable()

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

void helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::enable (const Handle_type handle, const ComponentTypeId_type typeId)

inline

Enables a component by type ID.

Calls the component's enable() method if registered.

Parameters

handle	The entity whose component to enable.
typeId	The component type identifier.

Definition at line 312 of file EntityManager.ixx.

312 void enable(const Handle_type handle, const ComponentTypeId_type typeId) const {

313 enable(handle, typeId, true);

314 }

References helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::enable and helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::handle.

Referenced by helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::disable, helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::enable and helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::enable.

enable()

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

void helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::enable (const Handle_type handle, const ComponentTypeId_type typeId, const bool enable)

inline

Enables or disables a component by type ID.

Parameters

handle	The entity whose component to modify.
typeId	The component type identifier.
enable	true to enable, false to disable.

Definition at line 335 of file EntityManager.ixx.

335 void enable(const Handle_type handle, const ComponentTypeId_type typeId, const bool enable) const {

336

337 if (!has(handle, typeId)) {

338 return;

339 }

340

341 void* rawCmp = raw(handle, typeId);

342 if (!rawCmp) {

343 return;

344 }

345 const auto& ops = ComponentOpsRegistry_type::ops(typeId);

346

347 if (enable && ops.enable) {

348 ops.enable(rawCmp);

349 } else if (!enable && ops.disable) {

350 ops.disable(rawCmp);

351 }

352 }

References helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::enable, helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::handle, helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::has, helios::ecs::ComponentOpsRegistry< THandle >::ops and helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::raw.

forEachComponentTypeId()

template <typename TFunc>

void helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::forEachComponentTypeId (const Handle_type handle, TFunc && func)

inline

Returns a span over all component type IDs attached to an entity.

Parameters

handle

The entity to query.

Definition at line 471 of file EntityManager.ixx.

471 void forEachComponentTypeId(const Handle_type handle, TFunc&& func) const {

472 if (!registry_.isValid(handle)) {

473 return;

474 }

475

476 for (size_t i = 0; i < components_.size(); i++) {

477 if (components_[i] && components_[i]->contains(handle.entityId)) {

478 std::forward<TFunc>(func)(ComponentTypeId_type{i});

479 }

480 }

481 }

Reference helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::handle.

Referenced by helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::clone.

get()

template <typename T>

T * helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::get (const Handle_type handle)

inline

Retrieves a component for the given entity.

Template Parameters

T	The component type to retrieve.

Parameters

handle

The entity whose component to retrieve.

Returns

Pointer to the component, or nullptr if the entity is invalid or does not have the requested component.

Definition at line 205 of file EntityManager.ixx.

205 [[nodiscard]] T* get(const Handle_type handle) const {

206 if (!has<T>(handle)) {

207 return nullptr;

208 }

209

210 const auto entityId = handle.entityId;

211 const auto typeId = ComponentTypeId_type::template id<T>().value();

212

213 auto* sparseSet = static_cast<SparseSet<T>*>(components_[typeId].get());

214

215 return sparseSet->get(entityId);

216 }

References helios::ecs::SparseSet< T >::get and helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::handle.

getSparseSet()

template <typename T>

SparseSet< T > * helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::getSparseSet ()

inline

Returns the SparseSet for a component type.

Template Parameters

T	The component type.

Returns

Pointer to the SparseSet, or nullptr if the type has no storage.

Definition at line 226 of file EntityManager.ixx.

226 [[nodiscard]] SparseSet<T>* getSparseSet() {

227

228 const auto typeId = ComponentTypeId_type::template id<T>().value();

229

230 if (typeId >= components_.size()) {

231 return nullptr;

232 }

233

234 return static_cast<SparseSet<T>*>(components_[typeId].get());

235 }

getSparseSet()

template <typename T>

const SparseSet< T > * helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::getSparseSet ()

inline

Returns the SparseSet for a component type (const).

Template Parameters

T	The component type.

Returns

Const pointer to the SparseSet, or nullptr if the type has no storage.

Definition at line 245 of file EntityManager.ixx.

245 [[nodiscard]] const SparseSet<T>* getSparseSet() const {

246

247 const auto typeId = ComponentTypeId_type::template id<T>().value();

248

249 if (typeId >= components_.size()) {

250 return nullptr;

251 }

252

253 return static_cast<SparseSet<T>*>(components_[typeId].get());

254 }

handle()

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

Handle_type helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::handle (const EntityId entityId)

inline

Reconstructs an EntityHandle from an EntityId.

Parameters

entityId

The entity ID.

Returns

EntityHandle with current version from the registry.

Definition at line 538 of file EntityManager.ixx.

538 [[nodiscard]] Handle_type handle(const EntityId entityId) const {

539 return Handle_type{entityId, registry_.version(entityId), registry_.strongId(entityId)};

540 }

Referenced by helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::destroy, helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::disable, helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::emplace, helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::emplaceOrGet, helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::enable, helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::enable, helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::forEachComponentTypeId, helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::get, helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::has, helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::has, helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::isValid, helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::isValid, helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::raw and helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::remove.

has()

template <typename T>

bool helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::has (const Handle_type handle)

inline

Checks whether an entity has a specific component.

Template Parameters

T	The component type to check for.

Parameters

handle

The entity to query.

Returns

true if the entity has the component, false if the handle is invalid or the component is not attached.

Definition at line 267 of file EntityManager.ixx.

267 [[nodiscard]] bool has(const Handle_type handle) const {

268 if (!registry_.isValid(handle)) {

269 return false;

270 }

271

272 const auto typeId = ComponentTypeId_type::template id<T>().value();

273

274 if (typeId < components_.size() && components_[typeId]) {

275 return components_[typeId]->contains(handle.entityId);

276 }

277

278 return false;

279 }

Reference helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::handle.

Referenced by helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::clone, helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::enable and helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::raw.

has()

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

bool helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::has (const Handle_type handle, const ComponentTypeId_type typeId)

inline

Checks whether an entity has a component by type ID.

Parameters

handle	The entity to query.
typeId	The component type identifier.

Returns

true if the entity has the component, false otherwise.

Definition at line 289 of file EntityManager.ixx.

289 [[nodiscard]] bool has(const Handle_type handle,

290 const ComponentTypeId_type typeId) const {

291 if (!registry_.isValid(handle)) {

292 return false;

293 }

294

295 const auto tvalue = typeId.value();

296

297 if (tvalue < components_.size() && components_[tvalue]) {

298 return components_[tvalue]->contains(handle.entityId);

299 }

300

301 return false;

302 }

References helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::handle and helios::ecs::types::ComponentTypeId< THandle >::value.

isValid()

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

bool helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::isValid (const Handle_type handle)

inline noexcept

Checks if an entity handle is valid.

Parameters

handle

The handle to validate.

Returns

true if the handle refers to a living entity.

Definition at line 142 of file EntityManager.ixx.

142 [[nodiscard]] bool isValid(const Handle_type handle) const noexcept {

143 return registry_.isValid(handle);

144 }

Reference helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::handle.

isValid()

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

bool helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::isValid (const EntityId entityId)

inline noexcept

Checks if an entity ID is valid.

Parameters

entityId

The entity ID to validate.

Returns

true if the entity ID refers to a living entity.

Definition at line 153 of file EntityManager.ixx.

153 [[nodiscard]] bool isValid(const EntityId entityId) const noexcept {

154 return registry_.isValid(handle(entityId));

155 }

Reference helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::handle.

raw()

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

void * helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::raw (const Handle_type handle, const ComponentTypeId_type typeId)

inline

Returns raw void pointer to a component.

Parameters

handle	The entity.
typeId	The component type identifier.

Returns

Raw pointer to the component, or nullptr if not found.

Definition at line 523 of file EntityManager.ixx.

523 [[nodiscard]] void* raw(const Handle_type handle, const ComponentTypeId_type typeId ) const {

524 if (!has(handle, typeId)) {

525 return nullptr;

526 }

527

528 return components_[typeId.value()]->raw(handle.entityId);

529 }

References helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::handle, helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::has and helios::ecs::types::ComponentTypeId< THandle >::value.

Referenced by helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::clone, helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::destroy, helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::emplaceOrGet, helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::enable and helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::remove.

remove()

template <typename T>

bool helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::remove (const Handle_type & handle)

inline

Removes a specific component from an entity.

Unlike destroy(), this only removes a single component type while keeping the entity and other components intact.

Template Parameters

T	The component type to remove.

Parameters

handle

The entity whose component to remove.

Returns

true if the component was removed, false if the handle was invalid, the component was not attached, or removal was blocked by onRemove.

See Also

destroy

See Also

SparseSet::remove

Definition at line 445 of file EntityManager.ixx.

445 bool remove(const Handle_type& handle) {

446

447 if (!has<T>(handle)) {

448 return false;

449 }

450

451 const auto typeId = ComponentTypeId_type::template id<T>();

452 void* rawCmp = raw(handle, typeId);

453 if (!rawCmp) {

454 return false;

455 }

456 const auto& ops = ComponentOpsRegistry_type::ops(typeId);

457

458 if (ops.onRemove && !ops.onRemove(rawCmp)) {

459 return false;

460 }

461

462 return components_[typeId.value()]->remove(handle.entityId);

463 }

References helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::handle, helios::ecs::ComponentOpsRegistry< THandle >::ops and helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::raw.

Private Member Attributes

capacity_

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

const size_t helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::capacity_

Initial capacity for the underlying sparse sets.

Definition at line 558 of file EntityManager.ixx.

558 const size_t capacity_;

components_

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

std::vector<std::unique_ptr<SparseSetBase> > helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::components_

Component storage indexed by type ID.

Definition at line 548 of file EntityManager.ixx.

548 std::vector<std::unique_ptr<SparseSetBase>> components_;

registry_

template <typename THandle, typename TEntityRegistry, size_t TCapacity>

EntityRegistry_type helios::ecs::EntityManager< THandle, TEntityRegistry, TCapacity >::registry_

Entity registry owned by this EntityManager.

Definition at line 553 of file EntityManager.ixx.

553 EntityRegistry_type registry_;

---

The documentation for this class was generated from the following file:

• EntityManager.ixx

---

Generated via doxygen2docusaurus 2.0.0 by Doxygen 1.9.8.