Cogs.Core
Public Member Functions | Private Types | List of all members
Cogs::Core::ComponentSystemWithDataPool< ComponentType, DataType > Class Template Reference

Component system with parallel data per component stored in a pool similar to how the components themselves are stored. More...

#include <ComponentSystem.h>

Inheritance diagram for Cogs::Core::ComponentSystemWithDataPool< ComponentType, DataType >:
Cogs::Core::ComponentSystemWithDataPools< ComponentType, DataType > Cogs::Core::ComponentSystem< ComponentType > Cogs::Core::ComponentSystemBase Cogs::Core::CollisionSystem< BoxCollisionComponent > Cogs::Core::CollisionSystem< CapsuleCollisionComponent > Cogs::Core::CollisionSystem< CylinderCollisionComponent > Cogs::Core::CollisionSystem< EmptyCollisionComponent > Cogs::Core::CollisionSystem< MeshCollisionComponent > Cogs::Core::CollisionSystem< PlaneCollisionComponent > Cogs::Core::CollisionSystem< SphereCollisionComponent > Cogs::Core::ConstraintSystem< FixedConstraintComponent > Cogs::Core::ConstraintSystem< GenericConstraintComponent > Cogs::Core::ConstraintSystem< HingeConstraintComponent > Cogs::Core::ConstraintSystem< SpringConstraintComponent >

Public Member Functions

 ComponentSystemWithDataPool (Memory::Allocator *allocator, SizeType size=1024)
 
DataType & getData (const ComponentType *component)
 
const DataType & getData (const ComponentType *component) const
 
- Public Member Functions inherited from Cogs::Core::ComponentSystemWithDataPools< ComponentType, DataType >
 ComponentSystemWithDataPools (Memory::Allocator *allocator, SizeType size=1024, MemBlockType componentMemType=MemBlockType::Component, MemBlockType dataMemType=MemBlockType::ComponentData)
 
ComponentHandle createComponent () override
 
void destroyComponent (ComponentHandle component) override
 
T & getData (const ComponentType *component)
 Get the data stored for the given component from the data pool storing objects of the specified template type.
 
const T & getData (const ComponentType *component) const
 Get the const data stored for the given component from the data pool storing objects of the specified template type.
 
- Public Member Functions inherited from Cogs::Core::ComponentSystem< ComponentType >
 ComponentSystem (Memory::Allocator *allocator, SizeType size=16384, MemBlockType componentMemType=MemBlockType::Component)
 
void instrumentedPreUpdate () override
 Provided for tagged engine instrumentation.
 
void instrumentedUpdate () override
 Provided for tagged engine instrumentation.
 
void instrumentedPostUpdate () override
 Provided for tagged engine instrumentation.
 
ComponentHandle createComponent () override
 Create a new component instance.
 
void destroyComponent (ComponentHandle component) override
 Destroy the component held by the given handle.
 
SizeType getComponentIndex (const Component *component) const
 Get the index of the given component in the component pool.
 
size_t size ()
 Returns the number of active components.
 
void clearCarryFlags ()
 Clear carry flags of all active components.
 
void resetFlags ()
 Reset the flags of all active components.
 
void prepareUpdate (Context *) override
 
void postUpdate (Context *) override
 
ComponentHandle getHandle (const ComponentType *component)
 Get a handle to the given Component instance.
 
virtual void addEntitiesWithComponent (std::vector< EntityId > &entities, Reflection::TypeId componentTypeId) override
 Return all entities with a given.
 
- Public Member Functions inherited from Cogs::Core::ComponentSystemBase
virtual ~ComponentSystemBase ()
 Provided for destruction via pointer to base.
 
 ComponentSystemBase (Reflection::TypeId componentType)
 Constructs a ComponentSystemBase to manage components of the given componentType.
 
virtual void initialize (Context *context)
 Initialize the system.
 
void preUpdate ()
 Run the pre-update method of the system.
 
void update ()
 Updates the system state to that of the current frame.
 
void postUpdate ()
 Perform post update logic in the system.
 
virtual void preUpdate (Context *)
 Provided for custom pre update logic in derived systems.
 
virtual void prepareUpdate (Context *)
 Provided for custom update preparation logic in derived systems.
 
virtual void update (Context *)
 Provided for custom update logic in derived systems.
 
virtual void postUpdate (Context *)
 Provided for custom post update logic in derived systems.
 
virtual void instrumentedPreUpdate ()
 Provided for tagged engine instrumentation.
 
virtual void instrumentedUpdate ()
 Provided for tagged engine instrumentation.
 
virtual void instrumentedPostUpdate ()
 Provided for tagged engine instrumentation.
 
virtual void addEntitiesWithComponent (std::vector< EntityId > &, Reflection::TypeId)
 Return all entities with a given.
 
virtual void cleanup (Context *)
 Provided for custom cleanup logic in derived systems.
 
virtual ComponentHandle createComponent ()
 Create a new component instance.
 
virtual void destroyComponent (ComponentHandle)
 Destroy the component held by the given handle.
 
Reflection::TypeId getComponentType () const
 Get the reflected type of the components managed by this system.
 

Private Types

typedef ComponentSystemWithDataPools< ComponentType, DataType > Base
 

Additional Inherited Members

- Public Types inherited from Cogs::Core::ComponentSystem< ComponentType >
typedef ComponentType component_type
 
- Static Public Member Functions inherited from Cogs::Core::ComponentSystem< ComponentType >
static Reflection::TypeId getTypeId ()
 Get the type id of the component type used by the system.
 
- Public Attributes inherited from Cogs::Core::ComponentSystem< ComponentType >
ComponentPool< ComponentType > pool
 Pool of components managed by the system.
 
- Public Attributes inherited from Cogs::Core::ComponentSystemBase
Reflection::TypeId componentType
 The type of components managed by this instance.
 
Contextcontext = nullptr
 Pointer to the Context instance the system lives in.
 

Detailed Description

template<typename ComponentType, typename DataType>
class Cogs::Core::ComponentSystemWithDataPool< ComponentType, DataType >

Component system with parallel data per component stored in a pool similar to how the components themselves are stored.

The data pool is kept up to date in terms of allocation/deallocation relative to the component pool.

Definition at line 364 of file ComponentSystem.h.

Member Typedef Documentation

◆ Base

template<typename ComponentType , typename DataType >
typedef ComponentSystemWithDataPools<ComponentType, DataType> Cogs::Core::ComponentSystemWithDataPool< ComponentType, DataType >::Base
private

Definition at line 366 of file ComponentSystem.h.

Constructor & Destructor Documentation

◆ ComponentSystemWithDataPool()

template<typename ComponentType , typename DataType >
Cogs::Core::ComponentSystemWithDataPool< ComponentType, DataType >::ComponentSystemWithDataPool ( Memory::Allocator allocator,
SizeType  size = 1024 
)
inline

Definition at line 369 of file ComponentSystem.h.

Member Function Documentation

◆ getData() [1/2]

template<typename ComponentType , typename DataType >
DataType & Cogs::Core::ComponentSystemWithDataPool< ComponentType, DataType >::getData ( const ComponentType *  component)
inline

Definition at line 371 of file ComponentSystem.h.

◆ getData() [2/2]

template<typename ComponentType , typename DataType >
const DataType & Cogs::Core::ComponentSystemWithDataPool< ComponentType, DataType >::getData ( const ComponentType *  component) const
inline

Definition at line 373 of file ComponentSystem.h.


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