Component.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
 
#include "EntityID.hpp"
 
#include "CeresEngine/Concepts.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Any.hpp"
#include "CeresEngine/Foundation/Container/SmallVector.hpp"
#include "CeresEngine/Foundation/Container/Tuple.hpp"
 
#include "CeresEngine/Reflection/Type.hpp"
#include "CeresEngine/Reflection/Box.hpp"
#include "CeresEngine/Reflection/IReflectable.hpp"
 
#include <bitset>
#include <type_traits>
 
namespace CeresEngine {
 
    using ComponentID = unsigned int;
 
    using ComponentMask = std::bitset<128>;
 
    struct CE_SCRIPT_EXPORT(external = true) AbstractComponent {
        CE_REFLECTABLE_CLASS;
 
    public:
        virtual ~AbstractComponent() = default;
 
    public:
        [[nodiscard]] virtual const ComponentType& getComponentType() const noexcept = 0;
    };
 
    template<typename T> struct Component : public AbstractComponent {
    private:
        [[nodiscard]] static ComponentID getComponentID() noexcept;
 
    public:
        CE_SCRIPT_EXPORT()
        static inline const ComponentID componentID = getComponentID();
 
        static inline const ComponentMask mask = []() noexcept { // NOLINT(cert-err58-cpp)
            ComponentMask m;
            m[componentID] = true;
            return m;
        }();
 
        static const ComponentType& componentType;
 
        [[nodiscard]] const ComponentType& getComponentType() const noexcept final { return componentType; }
 
    public: // Accessor
        struct Accessor;
    };
 
    template<typename C> constexpr bool isComponent = std::is_base_of<AbstractComponent, C>::value;
 
    template<typename... Cs> constexpr bool areComponents = (isComponent<Cs> && ...);
 
    template<typename T, typename C> using ifComponent = typename std::enable_if<isComponent<C>, T>::type;
 
    template<typename T, typename... Cs> using ifComponents = typename std::enable_if<areComponents<Cs...>, T>::type;
 
    template<typename T>
    concept CComponent = isComponent<T>;
 
    template<CComponent C> inline constexpr void checkComponent() {
        static_assert(isComponent<C>, "C must be a Component type!");
        static_assert(std::is_final_v<C>, "Components must be final!");
    }
 
    template<typename TC> struct Component<TC>::Accessor {
    public:
        [[no_unique_address]] const Entity& entity;
 
    public:
        CE_FORCE_INLINE
        explicit Accessor(const Entity& entity) : entity(entity) {}
 
    protected:
        using C = TC; // NOLINT
 
        template<typename T> CE_FORCE_INLINE auto mutate(T C::*ptr);
 
        template<typename MutatorFunc, typename T> requires(CInvocable<MutatorFunc, T&>) decltype(auto) mutate(MutatorFunc&& func, T C::*ptr);
 
        template<typename T1, typename T2, typename... Ts>
        CE_FORCE_INLINE Tuple<ComponentFieldMutator<T1, C>, ComponentFieldMutator<T2, C>, ComponentFieldMutator<Ts, C>...> mutate(T1 C::*ptr1, T2 C::*ptr2,
            Ts C::*... ptrs);
 
        template<typename MutatorFunc, typename T1, typename T2, typename... Ts>
        CE_FORCE_INLINE Tuple<ComponentFieldMutator<T1, C>, ComponentFieldMutator<T2, C>, ComponentFieldMutator<Ts, C>...> mutate(MutatorFunc&& func, T1 C::*ptr1, T2 C::*ptr2, Ts C::*... ptr);
 
        template<typename T> CE_FORCE_INLINE auto get(T C::*ptr);
 
        template<typename T1, typename T2, typename... Ts>
        CE_FORCE_INLINE Tuple<ComponentFieldMutator<T1, C>, ComponentFieldMutator<T2, C>, ComponentFieldMutator<Ts, C>...> get(T1 C::*ptr1, T2 C::*ptr2,
            Ts C::*... ptrs);
 
        template<typename T> CE_FORCE_INLINE const T& read(const T C::*ptr) const;
 
        template<typename T1, typename T2, typename... Ts>
        CE_FORCE_INLINE Tuple<const T1&, const T2&, const Ts&...> read(const T1 C::*ptr1, const T2 C::*ptr2, const Ts C::*... ptrs) const;
 
        template<typename T> CE_FORCE_INLINE const T& get(const T C::*ptr) const;
 
        template<typename T1, typename T2, typename... Ts>
        CE_FORCE_INLINE Tuple<const T1&, const T2&, const Ts&...> get(const T1 C::*ptr1, const T2 C::*ptr2, const Ts C::*... ptrs) const;
    };
 
    class ComponentMaskSet {
    private:
        Vector<ComponentMask> mComponentMasks;
 
        static inline constexpr ComponentMask emptyComponentMask = 0;
 
    public:
        [[nodiscard]] const ComponentMask& get(const EntityIndex index) const noexcept {
            if(mComponentMasks.size() < index + 1) {
                return emptyComponentMask;
            }
            return mComponentMasks[index];
        }
 
        [[nodiscard]] bool has(const EntityIndex index, const ComponentMask& mask) const noexcept {
            const ComponentMask& currentMask = get(index);
            return (currentMask & mask) == mask;
        }
 
        const ComponentMask& set(const EntityIndex index, const ComponentMask& mask) noexcept {
            if(mComponentMasks.size() < index + 1) {
                if(mask == 0) {
                    // If the target mask is empty we don't need to resize.
                    return emptyComponentMask;
                }
 
                mComponentMasks.resize(index + 1);
            }
            mComponentMasks[index] = mask;
            return mComponentMasks[index];
        }
 
        const ComponentMask& reset(const EntityIndex index) noexcept { return set(index, 0); }
 
        const ComponentMask& add(const EntityIndex index, const ComponentMask& mask) noexcept {
            if(mComponentMasks.size() < index + 1) {
                mComponentMasks.resize(index + 1);
            }
            mComponentMasks[index] |= mask;
            return mComponentMasks[index];
        }
 
        const ComponentMask& remove(const EntityIndex index, const ComponentMask& mask) noexcept {
            if(mComponentMasks.size() < index + 1) {
                return emptyComponentMask;
            }
            mComponentMasks[index] &= ~mask;
            return mComponentMasks[index];
        }
 
        [[nodiscard]] std::size_t getSize() const noexcept { return mComponentMasks.size(); }
    };
 
    template<typename T> inline void buildComponentMask(ComponentMask& mask) { mask[T::componentID] = true; }
 
    template<typename T, typename T1, typename... Ts> inline void buildComponentMask(ComponentMask& mask) {
        buildComponentMask<T>(mask);
        buildComponentMask<T1, Ts...>(mask);
    }
 
    template<typename... Ts> inline ComponentMask buildComponentMask() {
        ComponentMask mask = 0ul;
        buildComponentMask<Ts...>(mask);
        return mask;
    }
 
    template<CComponent... Cs> struct ComponentSet {
        static_assert(areComponents<Cs...>, "All parameters in Cs must be components.");
 
        template<CComponent C> static inline constexpr bool includes = (std::is_same_v<C, Cs> || ...);
 
        static inline ComponentMask getComponentMask() noexcept { // NOLINT(cert-err58-cpp)
            return (Cs::mask | ...);
        }
 
        //        static inline const ComponentMask mask = getComponentMask();
        //#else
        //        static inline const ComponentMask mask = (Cs::mask | ...);
        //#endif
 
        template<template<typename...> typename T> using Apply = T<Cs...>;
    };
 
    template<> struct ComponentSet<> {
        template<CComponent C> static inline constexpr bool includes = false;
 
        static inline ComponentMask getComponentMask() noexcept { // NOLINT(cert-err58-cpp)
            return ComponentMask();
        }
        //        static inline const ComponentMask mask = ComponentMask();
 
        template<template<typename...> typename T> using Apply = T<>;
    };
 
    struct AbstractComponentListener {
        virtual ~AbstractComponentListener() = default;
 
        [[nodiscard]] virtual ComponentMask mask() const noexcept = 0;
 
        virtual void componentsAdded(const Entity& entity) noexcept = 0;
 
        virtual void componentsRemoved(const Entity& entity) noexcept = 0;
 
        virtual void entityDirtied(const Entity& entity, const EntityChangeSet& changeSet) noexcept {}
    };
 
    template<CComponent... Cs> struct ComponentListener : public AbstractComponentListener {
        [[nodiscard]] ComponentMask mask() const noexcept final { return ComponentSet<Cs...>::getComponentMask(); }
    };
 
    struct ComponentChange final {
        const ClassProperty* property;
    };
 
    struct ComponentChangeSet final {
        SmallVector<ComponentChange, 10> changes;
    };
 
    class ComponentType {
    public:
        const ComponentID componentID;
 
        const ComponentMask componentMask;
 
    protected:
        explicit ComponentType(const ComponentID componentID)
                : componentID(componentID), componentMask([componentID]() {
                      ComponentMask mask;
                      mask[componentID] = true;
                      return mask;
                  }()) {}
 
    public:
        ComponentType(const ComponentType&) = delete;
        ComponentType& operator=(const ComponentType&) = delete;
        ComponentType(ComponentType&&) = delete;
        ComponentType& operator=(ComponentType&&) = delete;
 
    protected: // ComponentID allocation
        static ComponentID nextComponentID;
 
    public: // Reflection
        [[nodiscard]] virtual const Class* getClass() const noexcept = 0;
 
        [[nodiscard]] virtual Type getType() const noexcept = 0;
 
        [[nodiscard]] virtual const Class* getAccessorClass() const noexcept = 0;
 
        [[nodiscard]] virtual Type getAccessorType() const noexcept = 0;
 
        [[nodiscard]] virtual Box getAny(AbstractComponent& component) const noexcept = 0;
        [[nodiscard]] virtual Box getAny(const AbstractComponent& component) const noexcept = 0;
 
        virtual void setAny(AbstractComponent& component, const Box& any) const noexcept = 0;
        virtual void setAny(AbstractComponent& component, Box&& any) const noexcept = 0;
 
    public: // Standard events
        virtual void emitComponentAdded(const Entity& entity) const = 0;
        virtual void emitComponentRemoved(const Entity& entity) const = 0;
 
    public:
        friend bool operator==(const ComponentType& lhs, const ComponentType& rhs) noexcept {
            // NOTE: This is safe as we only ever create a single instance for
            //       any given component type.
            //
            return &lhs == &rhs;
        }
 
        friend bool operator!=(const ComponentType& lhs, const ComponentType& rhs) noexcept { return !(lhs == rhs); }
 
    public:
        template<typename C> static const TComponentType<C>& get() noexcept;
    };
 
    template<typename C> class TComponentType : public ComponentType {
    private:
        friend class ComponentType;
 
        explicit TComponentType() : ComponentType(getComponentID()) {}
 
    protected: // Component ID generation & retrieval
        [[nodiscard]] static ComponentID getComponentID() noexcept {
            static const ComponentID id = nextComponentID++;
            return id;
        }
 
    public: // Reflection
        [[nodiscard]] const Class* getClass() const noexcept final { return getType().getClass(); }
 
        [[nodiscard]] Type getType() const noexcept final { return CeresEngine::getType<C>(); }
 
        [[nodiscard]] const Class* getAccessorClass() const noexcept final { return getAccessorType().getClass(); }
 
        [[nodiscard]] Type getAccessorType() const noexcept final { return CeresEngine::getType<typename C::Accessor>(); }
 
        [[nodiscard]] Box getAny(AbstractComponent& component) const noexcept final { return std::ref(static_cast<C&>(component)); }
 
        [[nodiscard]] Box getAny(const AbstractComponent& component) const noexcept final { return std::ref(static_cast<const C&>(component)); }
 
        void setAny(AbstractComponent& component, const Box& value) const noexcept final {
            if constexpr(std::is_copy_assignable_v<C>) {
                static_cast<C&>(component) = value.template cref<C>();
            }
            // TODO: Throw if not assignable.
        }
 
        void setAny(AbstractComponent& component, Box&& value) const noexcept final {
            if constexpr(std::is_copy_assignable_v<C>) {
                static_cast<C&>(component) = std::move(value).template rref<C>();
            }
            // TODO: Throw if not assignable.
        }
 
    public: // Standard events
        void emitComponentAdded(const Entity& entity) const final;
 
        void emitComponentRemoved(const Entity& entity) const final;
    };
 
    template<typename C> inline const TComponentType<C>& ComponentType::get() noexcept {
        static const TComponentType<C> instance;
        return instance;
    }
 
    template<typename C> [[nodiscard]] ComponentID Component<C>::getComponentID() noexcept { return ComponentType::get<C>().componentID; }
 
    template<typename C> const ComponentType& Component<C>::componentType = ComponentType::get<C>();
 
#define CE_EXTERN_COMPONENT_BASE(T, EXTERN)                 \
    EXTERN template struct ::CeresEngine::Component<T>;     \
    EXTERN template class ::CeresEngine::TComponentType<T>; \
    EXTERN template class ::CeresEngine::ComponentStore<T>
#define CE_EXTERN_COMPONENT(T) CE_EXTERN_COMPONENT_BASE(T, extern);
#define CE_EXTERN_COMPONENT_IMPL(T) CE_EXTERN_COMPONENT_BASE(T, );
} // namespace CeresEngine
 
template<typename C> struct std::hash<CeresEngine::Component<C>> {
    size_t operator()(const CeresEngine::Component<C>& component) const { return std::hash<C>{}(static_cast<const C&>(component)); }
};
 
template<> struct std::hash<CeresEngine::ComponentType> {
    size_t operator()(const CeresEngine::ComponentType& type) const { return std::hash<const void*>{}(&type); }
};
 
template<typename C> struct std::hash<CeresEngine::TComponentType<C>> : std::hash<CeresEngine::ComponentType> {};
 
#include "ComponentStore.hpp"