Plugin.hpp

// INFINITY_API_PUBLIC
 
#pragma once
 
#include <Infinity/api.h>
#include <Infinity/Plugin/API.h>
#include <Infinity/Procedural/ProceduralComponent.hpp>
#include <Infinity/Procedural/Registry.hpp>
#include <Infinity/Util/unordered_dense.h>
 
#include <string>
#include <memory>
 
namespace Infinity::Plugin
{
    class ComponentLibrary
    {
        public:
            virtual ~ComponentLibrary() = default;
 
            virtual void registerComponents() = 0;
 
            ankerl::unordered_dense::map<Infinity::Procedural::ComponentID, std::pair<CreateComponentFunction*, DeleteComponentFunction*>> registrants;
 
        protected:
            template<typename T>
            void registerComponent(const std::string& group, const std::string& name)
            {
                registerComponent<T>(Infinity::Procedural::ComponentID(group, name));
            }
 
            template<typename T>
            void registerComponent(const Infinity::Procedural::ComponentID& id)
            {
                static_assert(std::is_base_of<Infinity::Procedural::ProceduralComponent, T>::value,
                    "Registered component type must inherit from Infinity::Procedural::ProceduralComponent");
 
                registrants.emplace(id, std::make_pair<CreateComponentFunction*, DeleteComponentFunction*>(
                    [](const Infinity::Procedural::ProceduralComponentDescription& desc) -> Infinity::Procedural::ProceduralComponent* {
                        return new T(desc);
                    },
                    [](Infinity::Procedural::ProceduralComponent* component) {
                        delete component;
                    }
                ));
            }
    };
}
 
#define INFINITY_PLUGIN(FactoryClass) \
    namespace { \
        std::unique_ptr<FactoryClass> g_factory; \
    } \
    extern "C" { \
        INFINITY_API_PLUGIN int plugin_get_api_version() { return INFINITY_PLUGIN_API_VERSION; } \
        INFINITY_API_PLUGIN PluginHandle* plugin_create() { \
            g_factory = std::make_unique<FactoryClass>(); \
            g_factory->registerComponents(); \
            return reinterpret_cast<PluginHandle*>(dynamic_cast<Infinity::Plugin::ComponentLibrary*>(g_factory.get())); \
        } \
        INFINITY_API_PLUGIN void plugin_destroy(PluginHandle* handle) { \
            g_factory.reset(); \
        } \
    }