Component.h

Go to the documentation of this file.

 
#pragma once
 
#include "Entity.h"
#include "ncengine/type/Type.h"
#include "ncengine/utility/Signal.h"
 
#include <any>
#include <concepts>
#include <iosfwd>
#include <type_traits>
 
namespace nc
{
class ComponentBase
{
    public:
        explicit ComponentBase(Entity entity) noexcept
            : m_parentEntity{entity} {}
 
        ComponentBase(const ComponentBase&) = delete;
        ComponentBase(ComponentBase&&) = default;
        ComponentBase& operator=(const ComponentBase&) = delete;
        ComponentBase& operator=(ComponentBase&&) = default;
 
        Entity ParentEntity() const noexcept { return m_parentEntity; }
 
    private:
        Entity m_parentEntity;
};
 
class FreeComponent : public ComponentBase
{
    public:
        explicit FreeComponent(Entity entity) noexcept
            : ComponentBase{entity} {}
 
        virtual ~FreeComponent() = default;
};
 
template<class T>
concept PooledComponent = std::movable<std::remove_const_t<T>> &&
                          !std::derived_from<T, FreeComponent> &&
                          !std::same_as<T, Entity>;
 
template<class T>
concept Component = PooledComponent<T> || std::derived_from<T, FreeComponent>;
 
struct DefaultStoragePolicy
{
    static constexpr bool EnableOnAddCallbacks = false;
 
    static constexpr bool EnableOnCommitCallbacks = false;
 
    static constexpr bool EnableOnRemoveCallbacks = false;
};
 
template<PooledComponent T>
struct StoragePolicy : DefaultStoragePolicy {};
 
struct SerializationContext;
struct DeserializationContext;
 
namespace ui::editor
{
struct EditorContext;
} // namespace ui::editor
 
template<PooledComponent T>
struct ComponentHandler
{
    using Factory_t = std::move_only_function<T(Entity entity,
                                                const std::any& userData)>;
 
    using Serialize_t = std::move_only_function<void(std::ostream& binaryStream,
                                                     const T& component,
                                                     const SerializationContext& ctx,
                                                     const std::any& userData)>;
 
    using Deserialize_t = std::move_only_function<T(std::istream& binaryStream,
                                                    const DeserializationContext& ctx,
                                                    const std::any& userData)>;
 
    using DrawUI_t = std::move_only_function<void(T& component,
                                                  ui::editor::EditorContext& ctx,
                                                  const std::any& userData)>;
 
    size_t id = 0ull;
 
    std::string name = "User Component";
 
    std::any userData = std::any{};
 
    Factory_t factory = nullptr;
 
    Serialize_t serialize = nullptr;
 
    Deserialize_t deserialize = nullptr;
 
    DrawUI_t drawUI = nullptr;
};
} // namespace nc