DynamicComponentSystem.cpp

#include "DynamicComponentSystem.h"
 
#include <algorithm>
 
#include "Foundation/Logging/Logger.h"
 
#include "Context.h"
#include "MemoryContext.h"
 
#include "EntityStore.h"
#include "EntityDefinition.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("DynamicComponentSystem");
}
 
namespace Cogs
{
  namespace Core
  {
    struct MessageDispatcher
    {
      typedef void UserDataMessageCallback(int messageId, void * userData, const void * data);
 
      void dispatch(DynamicComponent * component, size_t messageId, void * data)
      {
        if (component->userData && component->messageCallback) {
          ((UserDataMessageCallback *)component->messageCallback)((int)messageId, component->userData, data);
        } else if (component->messageCallback) {
          ((MessageCallback *)component->messageCallback)((int)messageId, data);
        } else {
          LOG_ERROR(logger, "Dispatcher callback not registered.");
        }
      }
 
    } dispatcher;
 
    template<typename... Args>
    void * getDispatcherArg(Args... args)
    {
      std::tuple<Args...> store(args...);
 
      if constexpr (std::tuple_size<std::tuple<Args...>>::value != 1) {
        LOG_WARNING(logger, "Tried passing multiple arguments to single value dispatcher. Additional arguments discarded.");
      }
 
      return std::get<0>(store);
    }
 
    void * getDispatcherArg()
    {
      return nullptr;
    }
 
    template<typename Collection, typename... Args>
    void dispatch(const Collection& receivers, size_t messageId, Args... args)
    {
      dispatchRef(receivers, messageId, std::forward<Args>(args)...);
    }
 
    template<typename Collection, typename... Args>
    void dispatchRef(const Collection& receivers, size_t messageId, Args... args)
    {
      for (auto & r : receivers) {
        auto component = r.component.resolve();
 
        if (component->getGeneration() != r.component.generation) {
          continue;
        }
 
        if (r.typeInfo->dispatcher) {
          r.method->call(r.typeInfo->dispatcher, component, messageId, getDispatcherArg(args...));
        } else {
          r.method->call(component, args...);
        }
      }
    }
  }
}
 
Cogs::Core::DynamicComponentSystem::DynamicComponentSystem() :
  ComponentSystemBase(Reflection::NoType)
{
  dynamicTypes.reserve(kMaxDynamicTypes);
 
  initializeMessage = registerMessage("initialize");
  updateMessage = registerMessage("update");
  postUpdateMessage = registerMessage("postUpdate");
  cleanupMessage = registerMessage("cleanup");
}
 
void Cogs::Core::DynamicComponentSystem::initialize(Context * context)
{
  ComponentSystemBase::initialize(context);
}
 
void Cogs::Core::DynamicComponentSystem::cleanup(Context * context)
{
  for (auto & p : pools) {
    Memory::destroy(p.second, context->memory->baseAllocator);
  }
}
 
void Cogs::Core::DynamicComponentSystem::preUpdate(Context * context)
{
  dispatch(messageHandlers[initializeMessage], initializeMessage, context);
 
  messageHandlers[initializeMessage].clear();
}
 
void Cogs::Core::DynamicComponentSystem::update(Context * /*context*/)
{
  dispatch(messageHandlers[updateMessage], updateMessage);
}
 
void Cogs::Core::DynamicComponentSystem::postUpdate(Context * /*context*/)
{
  dispatch(messageHandlers[postUpdateMessage], postUpdateMessage);
 
  for (auto & update : messageHandlers[updateMessage]) {
    auto component = update.component.resolve();
    component->unsetFlag(ComponentModel::ComponentFlags::Changed);
    component->resetFieldsChanged();
  }
}
 
void Cogs::Core::DynamicComponentSystem::registerType(Context * context, const Reflection::Type & type)
{
  this->context = context;
 
  auto id = type.getTypeId();
 
  auto pool = getPool(type.getTypeId());
 
  if (dynamicTypes.size() == kMaxDynamicTypes) {
    LOG_ERROR(logger, "Max number of dynamic types exceeded.");
    return;
  }
 
  dynamicTypes.emplace_back();
  auto typeInfo = &dynamicTypes.back();
 
  typeInfo->pool = pool;
  typeInfo->methods.resize(kMaxDynamicMethods);
 
  for (size_t i = 0; i < messages.size(); ++i) {
    auto messageMethod = type.getMethod(messages[i].name);
 
    if (messageMethod) {
      typeInfo->messageMask |= 1 << i;
      typeInfo->methods[i] = messageMethod;
    }
  }
 
  const size_t typeInfoIndex = dynamicTypes.size() - 1;
 
  ComponentCreator creator = [this, typeInfoIndex]()
  {
    auto component = createComponent(&dynamicTypes[typeInfoIndex]);
 
    component.resolveComponent<DynamicComponent>()->dynamicTypeInfoIndex = typeInfoIndex;
 
    return component;
  };
 
  ComponentDestroyer destroyer = [this, typeInfoIndex](ComponentHandle component)
  {
    destroyComponent(&dynamicTypes[typeInfoIndex], component);
  };
 
  context->store->addSystem(id, creator, destroyer);
}
 
void Cogs::Core::DynamicComponentSystem::registerType(Context * context, const StringView & name, size_t dispatchMask)
{
  auto & newType = Reflection::TypeDatabase::createType(
    name,
    sizeof(DynamicComponent),
    &Reflection::Construction::createInstance<DynamicComponent>,
    &Reflection::Construction::destroyInstance<DynamicComponent>,
    &Reflection::Construction::constructInstance<DynamicComponent>,
    &Reflection::Construction::destructInstance<DynamicComponent>,
    false);
 
  std::vector<Reflection::Method> methods;
 
  for (size_t i = 0; i < messages.size(); ++i) {
    if (dispatchMask & (1 << i)) {
      methods.emplace_back(Reflection::Method(messages[i].name, &MessageDispatcher::dispatch));
    }
  }
 
  newType.setBase<DynamicComponent>().setMethods(methods.data(), methods.size());
 
  registerType(context, newType);
 
  auto & typeInfo = dynamicTypes.back();
 
  typeInfo.dispatcher = &dispatcher;
}
 
Cogs::Core::MessageId Cogs::Core::DynamicComponentSystem::registerMessage(const StringView & messageName)
{
  MessageInfo info = {};
  info.name = messageName.to_string();
 
  messages.emplace_back(info);
  messageHandlers.resize(messages.size());
 
  return messages.size() - 1;
}
 
Cogs::Core::MessageId Cogs::Core::DynamicComponentSystem::getMessageId(const StringView & messageName) const
{
  for (auto & m : messages) {
    if (messageName == m.name) return std::distance(messages.data(), &m);
  }
 
  return NoMessage;
}
 
void Cogs::Core::DynamicComponentSystem::sendMessage(Entity * entity, MessageId messageId)
{
  sendMessage(entity, messageId, nullptr);
}
 
void Cogs::Core::DynamicComponentSystem::sendMessage(Entity * entity, MessageId messageId, void * arg)
{
  std::vector<DispatchInfo> dispatchers;
 
  for (auto & d : messageHandlers[messageId]) {
    if (d.component.resolve()->getContainer() == entity) {
      dispatchers.push_back(d);
    }
  }
 
  if (arg) {
    dispatchRef(dispatchers, messageId, arg);
  } else {
    dispatchRef(dispatchers, messageId);
  }
}
 
Cogs::ComponentModel::ComponentHandle Cogs::Core::DynamicComponentSystem::createComponent(DynamicTypeInfo * typeInfo)
{
  auto component = typeInfo->pool->allocateComponent();
  component.resolve()->setChanged();
 
  for (size_t i = 0; i < messages.size(); ++i) {
    if (typeInfo->messageMask & (1 << i)) {
      messageHandlers[i].push_back(DispatchInfo{ component, typeInfo->methods[i], typeInfo });
    }
  }
 
  return component;
}
 
void Cogs::Core::DynamicComponentSystem::destroyComponent(DynamicTypeInfo * typeInfo, ComponentModel::ComponentHandle handle)
{
  auto component = handle.resolve();
 
  if (typeInfo->messageMask & (1 << cleanupMessage)) {
    // If there is a cleanup method registered, we call it before deallocating the component.
    if (typeInfo->dispatcher) {
      dispatcher.dispatch(static_cast<DynamicComponent *>(component), cleanupMessage, nullptr);
    } else {
      typeInfo->methods[cleanupMessage]->call(component, context);
    }
  }
 
  for (size_t i = 0; i < messages.size(); ++i) {
    if (typeInfo->messageMask & (1 << i)) {
      auto & handler = messageHandlers[i];
 
      auto it = std::remove_if(handler.begin(), handler.end(), [&](const DispatchInfo & u)
      {
        return u.component == handle;
      });
 
      if (it != handler.end()) {
        handler.erase(it);
      }
    }
  }
 
  // Deallocate the actual component, running the destructor and freeing any held resources.
  typeInfo->pool->deallocateComponent(handle);
}
 
Cogs::ComponentModel::ComponentPoolBase * Cogs::Core::DynamicComponentSystem::getPool(const Reflection::TypeId typeId)
{
  auto pIt = pools.find(typeId);
 
  if (pIt == pools.end()) {
    assert(typeId != Reflection::NoType && "Cannot create component pool without valid type.");
 
    auto pool = Memory::create<ComponentModel::ComponentPoolBase>(context->memory->baseAllocator, typeId, 128, context->memory->componentAllocator, MemBlockType::Component);
    pool->setFlag(ComponentPoolFlags::AllowGrow);
 
    pools[typeId] = pool;
 
    return pool;
  } else {
    return pIt->second;
  }
}