FieldSetter.h

// Set of utilities to set field values (and one getField to get valuePtr).
#pragma once
 
#include "BridgeApi.h"
 
#include "Context.h"
#include "Engine.h"
#include "EntityStore.h"
 
#include "Foundation/ComponentModel/Component.h"
#include "Foundation/Reflection/TypeDatabase.h"
 
#include <algorithm>
 
COGSCORE_DLL_API const Cogs::Reflection::Field* getComponentField(
  BridgeContext* ctx,
  EntityId entityId,
  ComponentId componentId,
  FieldId fieldId,
  Cogs::ComponentModel::Component*& component);
 
namespace Cogs
{
  inline void setChanged(Cogs::Core::Context* context, Cogs::ComponentModel::Component * component, Reflection::FieldId fieldId)
  {
    if (!component->isSet(Cogs::ComponentModel::ComponentFlags::DisableTracking)) {
      component->setFieldChanged(fieldId);
    }
    context->engine->setDirty();
  }
 
  template<typename DataType>
  void assignField(Cogs::Core::Context * context, EntityId entityId, const ComponentId componentId, const Cogs::Reflection::FieldId fieldId, const DataType * data, int count)
  {
    using FieldType = std::vector<DataType>;
 
    Cogs::ComponentModel::Component * component;
    auto field = getComponentField(context, entityId, componentId, fieldId, component);
    if (!component || !field) return;
 
    // Make sure the destination type at least has enough storage to receive data from the source.
    assert(Reflection::TypeDatabase::getType(field->getTypeId()).getSize() >= Reflection::TypeDatabase::getType<FieldType>().getSize());
 
    auto fieldPointer = field->getPtr<FieldType>(component);
 
    fieldPointer->assign(data, data + count);
 
    setChanged(context, component, fieldId);
  }
 
  template<typename DataType>
  void assignFieldSubset(Cogs::Core::Context * context, EntityId entityId, const ComponentId componentId, const Cogs::Reflection::FieldId fieldId, const DataType * data, int offset, int count)
  {
    using FieldType = std::vector<DataType>;
 
    Cogs::ComponentModel::Component * component;
    auto field = getComponentField(context, entityId, componentId, fieldId, component);
    if (!component || !field) return;
 
    // Make sure the destination type at least has enough storage to receive data from the source.
    assert(Reflection::TypeDatabase::getType(field->getTypeId()).getSize() >= Reflection::TypeDatabase::getType<FieldType>().getSize());
 
    auto fieldPointer = field->getPtr<FieldType>(component);
 
    count = std::max(0, std::min(count, static_cast<int>(fieldPointer->size()) - offset));
    if (count) {
      std::copy_n(data, count, fieldPointer->begin() + offset);
    }
 
    setChanged(context, component, fieldId);
  }
 
  template<typename FieldType>
  FieldType * getField(Cogs::Core::Context * context, EntityId entityId, const ComponentId componentId, const Cogs::Reflection::FieldId fieldId)
  {
    using FieldValueType = typename std::remove_const_t<typename std::remove_reference_t<FieldType>>;
 
    Cogs::ComponentModel::Component * component;
    auto field = getComponentField(context, entityId, componentId, fieldId, component);
    if (!component || !field) return nullptr;
 
    return field->getPtr<FieldValueType>(component);
  }
 
  template<typename FieldType>
  void setField(Cogs::Core::Context * context, EntityId entityId, const ComponentId componentId, const Cogs::Reflection::FieldId fieldId, FieldType && data)
  {
    using FieldValueType = typename std::remove_const_t<typename std::remove_reference_t<FieldType>>;
 
    Cogs::ComponentModel::Component * component;
    auto field = getComponentField(context, entityId, componentId, fieldId, component);
    if (!component || !field) return;
 
    // Make sure the destination type at least has enough storage to receive data from the source.
    assert(Reflection::TypeDatabase::getType(field->getTypeId()).getSize() >= Reflection::TypeDatabase::getType<FieldValueType>().getSize());
 
    auto fieldPointer = field->getPtr<FieldValueType>(component);
 
    *fieldPointer = std::forward<FieldType>(data);
 
    setChanged(context, component, fieldId);
  }
 
  template<typename FieldType>
  void setVectorField(Cogs::Core::Context * context, EntityId entityId, const ComponentId componentId, const Cogs::Reflection::FieldId fieldId, FieldType && data, size_t index)
  {
    using FieldValueType = typename std::remove_const_t<typename std::remove_reference_t<FieldType>>;
 
    Cogs::ComponentModel::Component * component;
    auto field = getComponentField(context, entityId, componentId, fieldId, component);
    if (!component || !field) return;
 
    // Make sure the destination type at least has enough storage to receive data from the source.
    assert(Reflection::TypeDatabase::getType(field->getTypeId()).getSize() >= Reflection::TypeDatabase::getType<FieldValueType>().getSize());
 
    auto fieldPointer = field->getPtr< std::vector<FieldValueType>>(component);
    assert(fieldPointer->size() > index);
    (*fieldPointer)[index] = std::forward<FieldType>(data);
 
    setChanged(context, component, fieldId);
  }
}