ProceduralComponent.hpp

#pragma once
 
#include <Infinity/api.h>
#include <Infinity/Procedural/ProceduralComponentDescription.hpp>
#include <Infinity/Procedural/ComponentID.hpp>
#include <Infinity/Engine/PRNG.hpp>
#include <Infinity/Util/unordered_dense.h>
#include <Infinity/Types/All.hpp>
 
#include <vector>
#include <string>
#include <memory>
 
namespace Infinity::Procedural
{
 
enum class ProceduralComponentRuntime : int8_t
{
    CPP = 1,
    CSharp = 2,
    Python = 3,
    MIN = CPP,
    MAX = Python
};
 
class ProceduralComponentImpl;
 
class INFINITY_API_PUBLIC ProceduralComponent
{
    public:
        ProceduralComponent(const ProceduralComponentDescription& desc);
 
        virtual ~ProceduralComponent();
 
        Infinity::Engine::PRNG prng; 
 
        uint32_t random();
 
        ComponentID id() const;
 
        ProceduralComponentRuntime runtime();
 
        virtual void execute() = 0;
 
        bool hasIn(const std::string& name) const;
 
        bool hasOut(const std::string& name) const;
 
        template<typename T>
        const T& getIn(const std::string& name) const
        {
            if constexpr (std::is_base_of_v<Infinity::Types::Core::Data, T>)
            {
                return *dynamic_cast<const T*>(getInData(name));
            } else {
                return dynamic_cast<const Infinity::Types::Core::Value<T>*>(getInData(name))->get();
            }
        }
 
        template<typename T>
        void setOut(const std::string& name, T&& val)
        {
            if constexpr (std::is_base_of_v<Infinity::Types::Core::Data, T>)
            {
                setOutData(name, std::make_shared<T>(std::move(val)));
            } else {
                setOutData(name, std::make_shared<Infinity::Types::Core::Value<T>>(val));
            }
        }
 
        template<typename T>
        void setOut(const std::string& name, const T& val)
        {
            if constexpr (std::is_base_of_v<Infinity::Types::Core::Data, T>)
            {
                setOutData(name, std::make_shared<T>(val));
            } else {
                setOutData(name, std::make_shared<Infinity::Types::Core::Value<T>>(val));
            }
        }
 
        template<typename T>
        void setOut(const std::string& name, const T* val)
        {
            setOutData(name, std::make_shared<T>(*val));
        }
 
    protected:
        void forward(const std::string& from, const std::string& to);
 
        void logError(const std::string& msg) const;
 
        void logWarning(const std::string& msg) const;
 
        void logInfo(const std::string& msg) const;
 
        void logDebug(const std::string& msg) const;
 
    private:
        ProceduralComponent() = delete;
 
        const Infinity::Types::Core::Base* getInData(const std::string& name) const;
 
        void setOutData(const std::string& name, std::shared_ptr<const Infinity::Types::Core::Base> data);
 
        std::unique_ptr<ProceduralComponentImpl> _impl;
 
    friend class Infinity::Procedural::ProceduralComponentImpl;
};
 
}