ComponentSystem.h

#pragma once
 
#include "Base.h"
#include "Platform/Instrumentation.h"
#include "Utilities/Tuple.h"
 
#include "Foundation/ComponentModel/ComponentPool.h"
#include "Foundation/ComponentModel/ComponentDataPool.h"
#include "Foundation/ComponentModel/Entity.h"
#include "Foundation/Reflection/TypeDatabase.h"
 
using namespace Cogs::ComponentModel;
 
namespace Cogs
{
  namespace Core
  {
    class Context;
 
    class COGSCORE_DLL_API ComponentSystemBase
    {
    public:
      virtual ~ComponentSystemBase() {}
 
      ComponentSystemBase(Reflection::TypeId componentType) : componentType(componentType) {}
 
      virtual void initialize(Context * context) { this->context = context; }
 
      void preUpdate() { preUpdate(context); }
 
      void update()
      {
        prepareUpdate(context);
 
        update(context);
      }
 
      void postUpdate() { postUpdate(context); }
 
      virtual void preUpdate(Context * /*context*/) {}
 
      virtual void prepareUpdate(Context * /*context*/) {}
 
      virtual void update(Context * /*context*/) {}
 
      virtual void postUpdate(Context * /*context*/) {}
 
      virtual void instrumentedPreUpdate() {}
 
      virtual void instrumentedUpdate() {}
 
      virtual void instrumentedPostUpdate() {}
 
      virtual void addEntitiesWithComponent(std::vector<EntityId>& /*entities*/, Reflection::TypeId /*componentTypeId*/) {}
 
      virtual void cleanup(Context * /*context*/) {}
 
      virtual ComponentHandle createComponent() { return ComponentHandle{}; }
 
      virtual void destroyComponent(ComponentHandle /*component*/) {}
 
      Reflection::TypeId getComponentType() const { return componentType; }
 
      Reflection::TypeId componentType;
 
      Context * context = nullptr;
    };
 
    template<typename ComponentType>
    class ComponentSystem : public ComponentSystemBase
    {
    public:
      typedef ComponentType component_type;
 
      ComponentSystem(Memory::Allocator * allocator, SizeType size = 16384, MemBlockType componentMemType = MemBlockType::Component) :
        ComponentSystemBase(Reflection::TypeDatabase::getType<ComponentType>().getTypeId()),
        pool(allocator, size, componentMemType)
      {
        pool.setFlag(ComponentPoolFlags::AllowGrow);
      }
 
      static Reflection::TypeId getTypeId()
      {
        return Reflection::TypeDatabase::getType<ComponentType>().getTypeId();
      }
 
      void instrumentedPreUpdate() override
      {
        static const std::string scope = std::string(SCOPE_GENNAME(SCOPE_SYSTEMS, "")) + "ComponentSystem::preUpdate" + Reflection::TypeDatabase::getType(getComponentType()).getName().getName();
        CpuInstrumentationScope_(SCOPE_SYSTEMS, scope.c_str());
        ComponentSystemBase::preUpdate();
      }
 
      void instrumentedUpdate() override
      {
        static const std::string scope = std::string(SCOPE_GENNAME(SCOPE_SYSTEMS, "")) + "ComponentSystem::update" + Reflection::TypeDatabase::getType(getComponentType()).getName().getName();
        CpuInstrumentationScope_(SCOPE_SYSTEMS, scope.c_str());
        ComponentSystemBase::update();
      }
 
      void instrumentedPostUpdate() override
      {
        static const std::string scope = std::string(SCOPE_GENNAME(SCOPE_SYSTEMS, "")) + "ComponentSystem::postUpdate" + Reflection::TypeDatabase::getType(getComponentType()).getName().getName();
        CpuInstrumentationScope_(SCOPE_SYSTEMS, scope.c_str());
        ComponentSystemBase::postUpdate();
      }
 
      ComponentHandle createComponent() override { return pool.allocateComponent(); }
 
      void destroyComponent(ComponentHandle component) override { pool.deallocateComponent(component); }
 
      SizeType getComponentIndex(const Component * component) const { return pool.getComponentIndex(component); }
 
      size_t size() { return pool.size(); }
 
      void clearCarryFlags()
      {
        for (auto & component : pool) {
          component.unsetFlag(ComponentFlags::CarryChanged);
        }
      }
 
      void resetFlags()
      {
        for (auto & component : pool) {
          component.resetChanged();
        }
      }
 
      void prepareUpdate(Context *) override { clearCarryFlags(); }
 
      void postUpdate(Context *) override { resetFlags(); }
 
      ComponentHandle getHandle(const ComponentType * component)
      {
        return ComponentHandle{ &pool, getComponentIndex(component), getComponentType(), component->getGeneration() };
      }
 
      virtual void addEntitiesWithComponent(std::vector<EntityId>& entities, Reflection::TypeId componentTypeId) override
      {
        for (auto & comp : pool) {
          if (comp.getTypeId() == componentTypeId) {
            entities.push_back(comp.getContainer()->getId());
          }
        }
      }
 
 
      ComponentPool<ComponentType> pool;
    };
 
    template<typename ComponentType, typename... DataTypes>
    class ComponentSystemWithDataPools : public ComponentSystem<ComponentType>
    {
    public:
      ComponentSystemWithDataPools(Memory::Allocator * allocator, SizeType size = 1024, MemBlockType componentMemType = MemBlockType::Component, MemBlockType dataMemType = MemBlockType::ComponentData) :
        ComponentSystem<ComponentType>(allocator, size, componentMemType),
        datas(ComponentModel::ComponentDataPool<DataTypes>(size, dataMemType)...)
      {}
 
      struct CreateFunctor
      {
        ComponentHandle component;
 
        template<typename Type>
        void operator()(Type && data)
        {
          data.create(component);
        }
      };
 
      struct DestroyFunctor
      {
        ComponentHandle component;
 
        template<typename Type>
        void operator()(Type && data)
        {
          data.destroy(component);
        }
      };
 
      ComponentHandle createComponent() override
      {
        auto component = this->pool.allocateComponent();
 
        CreateFunctor f{ component };
 
        // Initialize allocated data for the component in all pools.
        for_each_in_tuple(datas, f);
 
        return component;
      }
 
      void destroyComponent(ComponentHandle component) override
      {
        DestroyFunctor f{ component };
 
        // Release allocated data for the component in all pools.
        for_each_in_tuple(datas, f);
 
        this->pool.deallocateComponent(component);
      }
 
      template<typename T>
      T & getData(const ComponentType * component)
      {
        // The pool to actually fetch data from is determined by converting the given template type
        // into an index into the tuple. The index gives us the pool and we can then return the data
        // in the pool corresponding to the given component.
        auto & data = Cogs::get<ComponentModel::ComponentDataPool<T>>(datas);
 
        return data[this->getComponentIndex(component)];
      }
 
      template<typename T>
      const T & getData(const ComponentType * component) const
      {
        // The pool to actually fetch data from is determined by converting the given template type
        // into an index into the tuple. The index gives us the pool and we can then return the data
        // in the pool corresponding to the given component.
        auto & data = Cogs::get<ComponentModel::ComponentDataPool<T>>(datas);
 
        return data[this->getComponentIndex(component)];
      }
 
    private:
      std::tuple<ComponentModel::ComponentDataPool<DataTypes>...> datas;
    };
 
    template<typename ComponentType, typename DataType>
    class ComponentSystemWithDataPool : public ComponentSystemWithDataPools<ComponentType, DataType>
    {
      typedef ComponentSystemWithDataPools<ComponentType, DataType> Base;
 
    public:
      ComponentSystemWithDataPool(Memory::Allocator * allocator, SizeType size = 1024) : ComponentSystemWithDataPools<ComponentType, DataType>(allocator, size) {}
 
      DataType & getData(const ComponentType * component) { return Base::template getData<DataType>(component); }
 
      const DataType & getData(const ComponentType * component) const { return Base::template getData<DataType>(component); }
    };
  }
}