Event.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 "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Event.hpp"
 
#include <type_traits>
 
namespace CeresEngine {
 
    using EntityEventID = unsigned int;
 
    struct CE_SCRIPT_EXPORT(external = true) AbstractEntityEvent {
        friend class EntityEventManager;
 
    protected:
        EntityManager* mEntityManager = nullptr;
 
        EntityEventManager* mEventManager = nullptr;
 
    public:
        virtual ~AbstractEntityEvent() = default;
    };
 
    template<typename T> struct EntityEvent : public AbstractEntityEvent {
    private:
        [[nodiscard]] static EntityEventID getEventID() noexcept;
 
    public:
        using Signal = CeresEngine::Event<void(const Entity&, const T&)>;
 
        CE_SCRIPT_EXPORT()
        static inline const EntityEventID eventID = getEventID();
    };
 
    template<typename E> constexpr bool isEntityEvent = std::is_base_of<AbstractEntityEvent, E>::value;
 
    template<typename... Es> constexpr bool areEntityEvents = (isEntityEvent<Es> && ...);
 
    template<typename T, typename E> using ifEntityEvent = typename std::enable_if<isEntityEvent<E>, T>::type;
 
    template<typename T>
    concept CEntityEvent = isEntityEvent<T>;
 
    template<CEntityEvent E> inline constexpr void checkEvent() {
        static_assert(isEntityEvent<E>, "E must be an Event type!");
        static_assert(std::is_final_v<E>, "Events must be final!");
    }
 
    template<CEntityEvent E> class EntityEventListener;
 
    template<CEntityEvent... Es> struct EntityEventSet {
        static_assert(areEntityEvents<Es...>, "All parameters in Es must be events.");
 
        template<CEntityEvent E> static inline constexpr bool includes = (std::is_same_v<E, Es> || ...);
    };
 
    template<> struct EntityEventSet<> {
        template<CEntityEvent E> static inline constexpr bool includes = false;
    };
 
    class EntityEventType {
    public:
        const EntityEventID eventID;
 
    protected:
        explicit EntityEventType(const EntityEventID eventID) : eventID(eventID) {}
 
    public:
        EntityEventType(const EntityEventType&) = delete;
        EntityEventType& operator=(const EntityEventType&) = delete;
        EntityEventType(EntityEventType&&) = delete;
        EntityEventType& operator=(EntityEventType&&) = delete;
 
    protected: // EntityEventID allocation
        static inline EntityEventID nextEventID = 0;
 
    public:
        friend bool operator==(const EntityEventType& lhs, const EntityEventType& rhs) noexcept {
            // NOTE: This is safe as we only ever create a single instance for
            //       any given event type.
            //
            return &lhs == &rhs;
        }
 
        friend bool operator!=(const EntityEventType& lhs, const EntityEventType& rhs) noexcept { return !(lhs == rhs); }
 
    public:
        template<typename E> static const EntityEventType& get() noexcept;
    };
 
    template<typename E> class TEntityEventType : public EntityEventType {
    private:
        friend class EntityEventType;
 
        explicit TEntityEventType() : EntityEventType(getEventID()) {}
 
    protected: // EntityEvent ID generation & retrieval
        [[nodiscard]] static EntityEventID getEventID() noexcept {
            static EntityEventID id = nextEventID++;
            return id;
        }
    };
 
    template<typename E> inline const EntityEventType& EntityEventType::get() noexcept {
        static const TEntityEventType<E> instance;
        return instance;
    }
 
    template<typename E> [[nodiscard]] EntityEventID EntityEvent<E>::getEventID() noexcept { return EntityEventType::get<E>().eventID; }
 
#define CE_EXTERN_ENTITY_EVENT_BASE(T, EXTERN)                \
    EXTERN template struct ::CeresEngine::EntityEvent<T>;     \
    EXTERN template class ::CeresEngine::TEntityEventType<T>; \
    EXTERN template const ::CeresEngine::EntityEventType& ::CeresEngine::EntityEventType::get<T>() noexcept;
#define CE_EXTERN_ENTITY_EVENT(T) CE_EXTERN_ENTITY_EVENT_BASE(T, extern)
#define CE_EXTERN_ENTITY_EVENT_IMPL(T) CE_EXTERN_ENTITY_EVENT_BASE(T, )
 
} // namespace CeresEngine