DynamicComponentSystem.h

#pragma once
 
#include <functional>
#include <memory>
#include <vector>
#include <unordered_map>
#include <unordered_set>
 
#include "../ComponentSystem.h"
 
#include "Components/Core/DynamicComponent.h"
 
namespace Cogs
{
  namespace Core
  {
    class Context;
 
    using MessageId = size_t;
    constexpr MessageId NoMessage = static_cast<MessageId>(-1);
 
    constexpr size_t kMaxDynamicTypes = 1024;
    constexpr size_t kMaxDynamicMethods = 64;
 
    class COGSCORE_DLL_API DynamicComponentSystem : public ComponentSystemBase
    {
      struct DynamicTypeInfo
      {
        ComponentModel::ComponentPoolBase * pool = nullptr;
        size_t messageMask = 0;
        Reflection::TypeId typeId = Reflection::NoType;
 
        std::vector<const Reflection::Method *> methods;
 
        struct MessageDispatcher * dispatcher = nullptr;
      };
 
      struct MessageInfo
      {
        std::string name;
      };
 
      struct DispatchInfo
      {
        ComponentModel::ComponentHandle component;
 
        const Reflection::Method * method;
 
        DynamicTypeInfo * typeInfo;
      };
 
    public:
      DynamicComponentSystem();
 
      void initialize(Context * context) override;
 
      void cleanup(Context * context) override;
 
      void preUpdate(Context * context) override;
 
      void update(Context * context) override;
 
      void postUpdate(Context * context) override;
 
      void instrumentedPreUpdate() override
      {
        CpuInstrumentationScope(SCOPE_SYSTEMS, "DynamicComponentSystem::preUpdate");
 
        preUpdate(context);
      }
 
      void instrumentedUpdate() override
      {
        CpuInstrumentationScope(SCOPE_SYSTEMS, "DynamicComponentSystem::update");
 
        update(context);
      }
 
      void instrumentedPostUpdate() override
      {
        CpuInstrumentationScope(SCOPE_SYSTEMS, "DynamicComponentSystem::postUpdate");
 
        postUpdate(context);
      }
 
      void registerType(Context * context, const Reflection::Type & type);
      void registerType(Context * context, const StringView & name, size_t dispatchMask);
 
      MessageId registerMessage(const StringView & messageName);
      MessageId getMessageId(const StringView & messageName) const;
 
      void sendMessage(Entity * entity, MessageId message);
      void sendMessage(Entity * entity, MessageId message, void * arg);
 
    private:
      using ComponentSystemBase::createComponent;
      using ComponentSystemBase::destroyComponent;
      
      ComponentModel::ComponentHandle createComponent(DynamicTypeInfo * typeInfo);
      void destroyComponent(DynamicTypeInfo * typeInfo, ComponentModel::ComponentHandle component);
 
      ComponentModel::ComponentPoolBase * getPool(const Reflection::TypeId typeId);
 
      std::vector<std::vector<DispatchInfo>> messageHandlers;
      std::vector<MessageInfo> messages;
 
      MessageId initializeMessage;
      MessageId updateMessage;
      MessageId postUpdateMessage;
      MessageId cleanupMessage;
 
      std::unordered_map<Reflection::TypeId, ComponentModel::ComponentPoolBase *> pools;
 
      std::vector<DynamicTypeInfo> dynamicTypes;
    };
  }
}