Component.h

#pragma once
 
#include "../Reflection/Name.h"
 
#include <cstdint>
 
namespace Cogs
{
  namespace Reflection
  {
    class Type;
  }
 
  using ComponentIndex = uint32_t;
 
  using SizeType = ComponentIndex;
 
  namespace ComponentModel
  {
    struct ComponentFlags
    {
      enum EComponentFlags : uint32_t
      {
        None = 0x00,
        Active = 0x01,
 
        Changed = 0x02,
 
        DisableTracking = 0x04,
 
        CarryChanged = 0x08,
 
        OverflowFieldChange = 0x10,
 
        FieldChange = 0x100,
 
        AllFieldChanged = ~(FieldChange-1u) | OverflowFieldChange
      };
    };
 
    struct ComponentHandle
    {
      ComponentHandle() = default;
 
      ComponentHandle(const ComponentHandle & other) = default;
 
      ComponentHandle& operator=(const ComponentHandle& rhs) = default;
 
      constexpr ComponentHandle(class ComponentPoolBase* pool, ComponentIndex index, Reflection::TypeId typeId, uint16_t generation)
        : pool(pool), index(index), typeId(typeId), generation(generation)
      {
      }
 
 
      COGSFOUNDATION_API class Component * resolve() const;
 
      template<typename ComponentType>
      inline ComponentType * resolveComponent() const
      {
        return static_cast<ComponentType *>(resolve());
      }
 
      explicit operator bool() const { return resolve() != nullptr; }
 
      static ComponentHandle Empty()
      {
        return ComponentHandle{ nullptr, 0, 0, 0 };
      }
 
      class ComponentPoolBase * pool = nullptr;
      ComponentIndex index = 0;
      Reflection::TypeId typeId = Reflection::NoType;
      uint16_t generation = 0;
    };
 
    [[nodiscard]] constexpr bool operator==(const ComponentHandle & a, const ComponentHandle & b)
    {
      return a.pool == b.pool && a.index == b.index && a.typeId == b.typeId;
    }
 
    class Component
    {
    public:
      Component() = default;
 
      COGSFOUNDATION_API static void registerType();
 
      class Entity * getContainer() const { return container; }
 
      void setContainer(class Entity * container) { this->container = container; }
 
      template<typename ComponentType>
      ComponentType * getComponent() const
      {
        static Reflection::TypeId id(getComponentTypeId(::getName<ComponentType>()));
 
        return static_cast<ComponentType *>(getComponent(id));
      }
 
      COGSFOUNDATION_API Component * getComponent(const Reflection::Name & name) const;
 
      COGSFOUNDATION_API  Component * getComponent(const Reflection::TypeId & id) const;
 
      template<typename ComponentType>
      ComponentHandle getComponentHandle() const
      {
        static Reflection::TypeId id(getComponentTypeId(::getName<ComponentType>()));
 
        return getComponentHandle(id);
      }
 
      COGSFOUNDATION_API ComponentHandle getComponentHandle(const Reflection::Name & name) const;
 
      COGSFOUNDATION_API ComponentHandle getComponentHandle(const Reflection::TypeId & id) const;
 
      void setActive() { setFlag(ComponentFlags::Active); }
 
      bool isActive() const { return isSet(ComponentFlags::Active); }
 
      void setChanged() { setFlag(ComponentFlags::Changed | ComponentFlags::AllFieldChanged | ComponentFlags::CarryChanged); }
 
      void setChangedTransient() { setFlag(ComponentFlags::Changed | ComponentFlags::AllFieldChanged); }
 
      void setFieldChanged(const Reflection::FieldId fieldId)
      {
        const uint32_t fieldBit = leftShift(ComponentFlags::FieldChange, fieldId);
        setFlag((fieldBit ? fieldBit : ComponentFlags::OverflowFieldChange) |
          ComponentFlags::Changed |
          ComponentFlags::CarryChanged);
      }
 
      template<typename ClassType, typename FieldType>
      void setFieldChanged(FieldType ClassType::* field)
      {
        return this->setFieldChanged(getFieldId(field));
      }
 
      void setFieldChangedTransient(const Reflection::FieldId fieldId)
      {
        const uint32_t fieldBit = leftShift(ComponentFlags::FieldChange, fieldId);
        setFlag((fieldBit ? fieldBit : ComponentFlags::OverflowFieldChange) |
          ComponentFlags::Changed);
      }
 
      bool hasChanged() const { return isSet(ComponentFlags::Changed); }
 
      bool hasAnyfieldChanged() const { return flags & ComponentFlags::AllFieldChanged; }
 
      bool hasFieldChanged(const Reflection::FieldId fieldId) const
      {
        const uint32_t fieldBit = leftShift(ComponentFlags::FieldChange, fieldId);
        return fieldBit ? isSet(fieldBit) : isSet(ComponentFlags::OverflowFieldChange);
      }
 
      template<typename ClassType, typename FieldType>
      bool hasFieldChanged(FieldType ClassType::* field) const
      {
        return hasFieldChanged(getFieldId(field));
      }
 
      void resetCarryChanged()
      {
        unsetFlag(ComponentFlags::CarryChanged);
      }
 
      void resetChanged()
      {
        if (!isSet(ComponentFlags::CarryChanged)) {
          unsetFlag(ComponentFlags::Changed);
          resetFieldsChanged();
        }
      }
 
      template<typename ClassType, typename FieldType>
      Reflection::FieldId getFieldId(FieldType ClassType::* field) const
      {
        return getFieldIdFromOffset(memberOffset(field));
      }
 
      void resetFieldsChanged() { unsetFlag(ComponentFlags::AllFieldChanged); }
 
      void resetFieldChanged(const Reflection::FieldId fieldId)
      {
        const uint32_t fieldBit = leftShift(ComponentFlags::FieldChange, fieldId);
        // If Field is Overflow flags the fieldBit will be zero -> not resetting any flags.
        unsetFlag(fieldBit);
      }
 
      template<typename ClassType, typename FieldType>
      void resetFieldChanged(FieldType ClassType::* field)
      {
        return resetFieldChanged(getFieldId(field));
      }
 
      constexpr void setFlags(const uint32_t flags) { this->flags = flags; }
 
      constexpr void setFlag(const uint32_t flag) { this->flags |= flag; }
 
      constexpr void unsetFlag(const uint32_t flag) { this->flags &= ~flag; }
 
      [[nodiscard]] constexpr bool isSet(const uint32_t flag) const { return (flags & flag) == flag; }
 
      constexpr void setTypeId(const Reflection::TypeId typeId) { this->typeId = typeId; }
 
      [[nodiscard]] constexpr Reflection::TypeId getTypeId() const { return typeId; }
 
      [[nodiscard]] COGSFOUNDATION_API const Reflection::Type & getType() const;
 
      [[nodiscard]] COGSFOUNDATION_API static Reflection::TypeId getComponentTypeId(const StringView & name);
 
      constexpr void setIndex(const ComponentIndex index) { this->index = index; }
 
      [[nodiscard]] constexpr ComponentIndex getIndex() const { return index; }
 
      constexpr void setGeneration(uint16_t generation) {
        this->generation = generation;
      }
 
      [[nodiscard]] constexpr uint16_t getGeneration() const {
        return generation;
      }
 
      [[nodiscard]] size_t hash(size_t hashValue = Cogs::hash()) const {
        hashValue = Cogs::hash(reinterpret_cast<intptr_t>(container), hashValue);
        hashValue = Cogs::hash(index, hashValue);
        hashValue = Cogs::hash(flags, hashValue);
        hashValue = Cogs::hash(typeId, hashValue);
        hashValue = Cogs::hash(generation, hashValue);
 
        return hashValue;
      }
 
    private:
      // Must avoid shifting too long. C++ undefined behavior (GCC Unix problem)
      [[nodiscard]] static constexpr uint32_t leftShift(const uint32_t value, const uint32_t fieldId)
      {
        return fieldId >= 32 ? 0u : (value << fieldId);
      }
 
      [[nodiscard]] COGSFOUNDATION_API Reflection::FieldId getFieldIdFromOffset(size_t offset) const;
 
      class Entity * container = nullptr;
      ComponentIndex index = 0;
      uint32_t flags = ComponentFlags::Changed | ComponentFlags::AllFieldChanged | ComponentFlags::CarryChanged;
      Reflection::TypeId typeId = Reflection::NoType;
      uint16_t generation = 0;
    };
  }
}
 
template<> inline Cogs::StringView getName<Cogs::ComponentModel::Component>() { return "Component"; }