Fireable.h

Go to the documentation of this file.

//
// Created by Dave Smith on 3/20/26.
//
 
#ifndef FIREABLE_H
#define FIREABLE_H
 
#include <Malena/Core/Export.h>
#include <functional>
#include <optional>
#include <unordered_map>
#include "SFML/Window/Event.hpp"
 
#include "Malena/Engine/Events/EventReceiver.h"
#include <Malena/Engine/Events/Callback.h>
#include <Malena/Utilities/EnumKey.h>
 
namespace ml
{
    namespace exports
    {
        struct FireableRegistrar;
    }


    struct PluginTag {};

    class Core;
    class EventReceiver;
    class Fireable
    {
    public:
        enum class DispatchType { FRAME, EVENT };
        Fireable(DispatchType type = DispatchType::EVENT);
 
        virtual ~Fireable() = default;

        virtual bool occurred(const std::optional<sf::Event>& event) { return false; }
        virtual bool occurred() { return false; }
        virtual bool filter(const std::optional<sf::Event>& event, Core* component) { return true; }
 
        template<typename EnumType>
        static void addCallback(EnumType eventEnum,
                                EventReceiver* component,
                                EventCallback callback);
 
        struct Cleanup { ~Cleanup(); };
 
        static void _register(Fireable* f);
        static void _unregister(Fireable* f);
 
        inline static std::vector<Fireable*> _fireables;
        inline static std::vector<Fireable*> _fireables_frame;
        inline static Cleanup               _cleanup;
 
        virtual void fire(const std::optional<sf::Event>& event) = 0;
        virtual void fire() = 0;
 
        friend class AppManager;
        friend class PluginManager;
        friend struct ml::exports::FireableRegistrar;
        template<typename T> friend struct MLExport;
 
    private:
        DispatchType _type;
    };
 
} // namespace ml
 
// ── FireableRegistrar ─────────────────────────────────────────────────────────

 
namespace ml::exports
{
    struct FireableRegistrar
    {
        static void registerFireable(ml::Fireable* f)
        {
            ml::Fireable::_register(f);
        }
    };
}
 
namespace ml::exports
{
    template<typename T, typename = void>
    struct FireableHelper
    {
        static void doRegister() {}
    };
 
    template<typename T>
    struct FireableHelper<T, std::enable_if_t<
        std::is_base_of_v<ml::Fireable, T> &&
        !std::is_base_of_v<ml::PluginTag, T>
    >>
    {
        static void doRegister()
        {
            static bool registered = false;
            if (registered) return;
            registered = true;
            static T dispatcher;
            ml::exports::FireableRegistrar::registerFireable(&dispatcher);
        }
    };
}

 
#include "../../../../src/Engine/Events/Fireable.tpp"
#endif // FIREABLE_H