RenderParameters.hpp

#pragma once
 
#include <Engine/RaEngine.hpp>
 
#include <vector>
 
#include <nlohmann/json.hpp>
 
#include <Core/Types.hpp>
#include <Core/Utils/Color.hpp>
#include <Core/Utils/EnumConverter.hpp>
#include <Core/Utils/Log.hpp>
#include <Core/Utils/StdOptional.hpp>
 
#include <Core/Containers/VariableSet.hpp>
 
#include <Engine/Data/ShaderProgram.hpp>
 
namespace Ra {
namespace Engine {
namespace Data {
 
class Texture;
 
class RA_ENGINE_API RenderParameters final
{
  public:
    using TextureInfo = std::pair<Data::Texture*, int>;
 
 
    using BindableTypes = Core::Utils::TypeList<bool,
                                                Core::Utils::Color,
                                                int,
                                                uint,
                                                Scalar,
                                                TextureInfo,
                                                std::vector<int>,
                                                std::vector<uint>,
                                                std::vector<Scalar>,
                                                Core::Vector2,
                                                Core::Vector3,
                                                Core::Vector4,
                                                Core::Matrix2,
                                                Core::Matrix3,
                                                Core::Matrix4,
                                                std::reference_wrapper<RenderParameters>,
                                                std::reference_wrapper<const RenderParameters>>;
 
    template <typename T>
    using UniformBindableSet = Core::VariableSet::VariableContainer<T>;
 
    template <typename T>
    using UniformVariable = Core::VariableSet::VariableHandle<T>;
 
    template <typename EnumBaseType>
    void addEnumConverter( const std::string& name,
                           std::shared_ptr<Core::Utils::EnumConverter<EnumBaseType>> converter );
 
    template <typename EnumBaseType>
    Core::Utils::optional<std::shared_ptr<Core::Utils::EnumConverter<EnumBaseType>>>
    getEnumConverter( const std::string& name );
 
    template <typename Enum, typename std::enable_if<std::is_enum<Enum> {}, bool>::type = true>
    std::string getEnumString( const std::string& name, Enum value );
 
    template <typename EnumBaseType>
    std::string
    getEnumString( const std::string& name,
                   EnumBaseType value,
                   typename std::enable_if<!std::is_enum<EnumBaseType> {}, bool>::type = true );
 
    template <typename T>
    void addParameter( const std::string& name,
                       T value,
                       typename std::enable_if<!std::is_class<T> {}, bool>::type = true );
 
    template <typename T, typename std::enable_if<std::is_class<T> {}, bool>::type = true>
    void addParameter( const std::string& name, const T& value );
 
    template <typename T,
              typename std::enable_if<std::is_base_of<Data::Texture, T>::value, bool>::type = true>
    void addParameter( const std::string& name, T* tex, int texUnit = -1 );
 
    void addParameter( const std::string& name, const std::string& value );
    void addParameter( const std::string& name, const char* value );
 
    void addParameter( const std::string& name, RenderParameters& value );
 
    void addParameter( const std::string& name, const RenderParameters& value );
 
    template <typename T>
    bool removeParameter( const std::string& name );
 
    void mergeKeepParameters( const RenderParameters& params );
 
    void mergeReplaceParameters( const RenderParameters& params );
 
    void bind( const Data::ShaderProgram* shader ) const;
 
    template <typename T>
    const UniformBindableSet<T>& getParameterSet() const;
    template <typename T>
    UniformBindableSet<T>& getParameterSet();
 
    template <typename T>
    Core::Utils::optional<UniformBindableSet<T>*> hasParameterSet() const;
 
    template <typename T>
    Core::Utils::optional<UniformVariable<T>> containsParameter( const std::string& name ) const;
 
    template <typename T>
    const T& getParameter( const std::string& name ) const;
    template <typename T>
    T& getParameter( const std::string& name );
 
    template <typename V>
    void visit( V&& visitor ) const;
 
    template <typename V, typename T>
    void visit( V&& visitor, T& userParams ) const;
 
    template <typename V, typename T>
    void visit( V&& visitor, T&& userParams ) const;
 
    const Core::VariableSet& getStorage() const { return m_parameterSets; }
    Core::VariableSet& getStorage() { return m_parameterSets; }
  private:
    class StaticParameterBinder
    {
      public:
        using types = BindableTypes;
 
        void operator()( const std::string& name,
                         const Ra::Core::Utils::Color& p,
                         const Data::ShaderProgram* shader ) {
            shader->setUniform( name.c_str(), Ra::Core::Utils::Color::VectorType( p ) );
        }
 
        void operator()( const std::string& name,
                         const RenderParameters::TextureInfo& p,
                         const Data::ShaderProgram* shader ) {
            auto [tex, texUnit] = p;
            if ( texUnit == -1 ) { shader->setUniformTexture( name.c_str(), tex ); }
            else { shader->setUniform( name.c_str(), tex, texUnit ); }
        }
 
        template <typename T>
        void operator()( const std::string& /*name*/,
                         const std::reference_wrapper<T>& p,
                         const Data::ShaderProgram* shader ) {
            p.get().bind( shader );
        }
 
        template <typename T>
        void operator()( const std::string& name, const T& p, const Data::ShaderProgram* shader ) {
            shader->setUniform( name.c_str(), p );
        }
    };
 
    static StaticParameterBinder s_binder;
 
    Core::VariableSet m_parameterSets;
};
 
class RA_ENGINE_API ParameterSetEditingInterface
{
  public:
    virtual ~ParameterSetEditingInterface() = default;
 
    virtual nlohmann::json getParametersMetadata() const = 0;
 
    static void loadMetaData( const std::string& basename, nlohmann::json& destination );
};
 
class RA_ENGINE_API ShaderParameterProvider
{
  public:
    virtual ~ShaderParameterProvider() = default;
    virtual RenderParameters& getParameters() { return m_renderParameters; }
    virtual const RenderParameters& getParameters() const { return m_renderParameters; }
    virtual void updateGL() = 0;
 
    virtual void updateFromParameters() {};
 
    virtual std::list<std::string> getPropertyList() const { return {}; };
 
  private:
    RenderParameters m_renderParameters;
};
 
/* --------------- enum parameter management --------------- */
 
template <typename EnumBaseType>
void RenderParameters::addEnumConverter(
    const std::string& name,
    std::shared_ptr<Core::Utils::EnumConverter<EnumBaseType>> converter ) {
    auto converterHandle = m_parameterSets.insertOrAssignVariable( name, converter );
    std::function<void( Core::VariableSet&, const std::string&, const std::string& )>
        convertingFunction = [converter = converterHandle.first]( Core::VariableSet& vs,
                                                                  const std::string& nm,
                                                                  const std::string& vl ) {
            vs.insertOrAssignVariable( nm, converter->second->getEnumerator( vl ) );
        };
    m_parameterSets.insertOrAssignVariable( name, convertingFunction );
}
 
template <typename EnumBaseType>
Core::Utils::optional<std::shared_ptr<Core::Utils::EnumConverter<EnumBaseType>>>
RenderParameters::getEnumConverter( const std::string& name ) {
    auto storedConverter =
        m_parameterSets.existsVariable<std::shared_ptr<Core::Utils::EnumConverter<EnumBaseType>>>(
            name );
    if ( storedConverter ) { return ( *storedConverter )->second; }
    return {};
}
 
template <typename EnumBaseType>
std::string RenderParameters::getEnumString(
    const std::string& name,
    EnumBaseType value,
    typename std::enable_if<!std::is_enum<EnumBaseType> {}, bool>::type ) {
    auto storedConverter =
        m_parameterSets.existsVariable<std::shared_ptr<Core::Utils::EnumConverter<EnumBaseType>>>(
            name );
    if ( storedConverter ) { return ( *storedConverter )->second->getEnumerator( value ); }
    LOG( Ra::Core::Utils::logWARNING ) << name + " is not a registered Enum with underlying type " +
                                              Ra::Core::Utils::demangleType<EnumBaseType>() + ".";
    return "";
}
 
template <typename Enum, typename std::enable_if<std::is_enum<Enum> {}, bool>::type>
std::string RenderParameters::getEnumString( const std::string& name, Enum value ) {
    using EnumBaseType = typename std::underlying_type_t<Enum>;
    return getEnumString( name, EnumBaseType( value ) );
}
 
/* --------------- enum parameter management --------------- */
 
template <typename T>
inline void
RenderParameters::addParameter( const std::string& name,
                                T value,
                                typename std::enable_if<!std::is_class<T> {}, bool>::type ) {
    if constexpr ( std::is_enum<T>::value ) {
        auto v = static_cast<typename std::underlying_type<T>::type>( value );
        m_parameterSets.insertOrAssignVariable( name, v );
    }
    else { m_parameterSets.insertOrAssignVariable( name, value ); }
}
 
template <typename T, typename std::enable_if<std::is_class<T> {}, bool>::type>
inline void RenderParameters::addParameter( const std::string& name, const T& value ) {
    m_parameterSets.insertOrAssignVariable( name, value );
}
 
template <typename T, typename std::enable_if<std::is_base_of<Data::Texture, T>::value, bool>::type>
inline void RenderParameters::addParameter( const std::string& name, T* tex, int texUnit ) {
    addParameter( name, TextureInfo { tex, texUnit } );
}
 
inline void RenderParameters::addParameter( const std::string& name, RenderParameters& value ) {
    m_parameterSets.insertOrAssignVariable( name, std::ref( value ) );
}
 
inline void RenderParameters::addParameter( const std::string& name,
                                            const RenderParameters& value ) {
    m_parameterSets.insertOrAssignVariable( name, std::cref( value ) );
}
 
template <typename T>
bool RenderParameters::removeParameter( const std::string& name ) {
    return m_parameterSets.deleteVariable<T>( name );
}
 
template <typename T>
inline const RenderParameters::UniformBindableSet<T>& RenderParameters::getParameterSet() const {
    return m_parameterSets.getAllVariables<T>();
}
 
template <typename T>
inline RenderParameters::UniformBindableSet<T>& RenderParameters::getParameterSet() {
    return m_parameterSets.getAllVariables<T>();
}
 
template <typename T>
inline Core::Utils::optional<RenderParameters::UniformBindableSet<T>*>
RenderParameters::hasParameterSet() const {
    if constexpr ( std::is_enum<T>::value ) {
        // Do not return
        // m_parameterSets.existsVariableType< typename std::underlying_type< T >::type >();
        // to prevent misuse of this function. The user should infer this with another logic.
        return {};
    }
    else { return m_parameterSets.existsVariableType<T>(); }
}
 
template <typename T>
inline Core::Utils::optional<RenderParameters::UniformVariable<T>>
RenderParameters::containsParameter( const std::string& name ) const {
    if constexpr ( std::is_enum<T>::value ) {
        return m_parameterSets.existsVariable<typename std::underlying_type<T>::type>( name );
    }
    else { return m_parameterSets.existsVariable<T>( name ); }
}
 
template <typename T>
inline const T& RenderParameters::getParameter( const std::string& name ) const {
    if constexpr ( std::is_enum<T>::value ) {
        // need to cast to take into account the way enums are managed in the RenderParameters
        return reinterpret_cast<const T&>(
            m_parameterSets.getVariable<typename std::underlying_type<T>::type>( name ) );
    }
    else { return m_parameterSets.getVariable<T>( name ); }
}
 
template <typename T>
inline T& RenderParameters::getParameter( const std::string& name ) {
    return const_cast<T&>( const_cast<const RenderParameters*>( this )->getParameter<T>( name ) );
}
 
template <typename V>
inline void RenderParameters::visit( V&& visitor ) const {
    m_parameterSets.visit( visitor );
}
 
template <typename V, typename T>
inline void RenderParameters::visit( V&& visitor, T& userParams ) const {
    m_parameterSets.visit( visitor, std::forward<T&>( userParams ) );
}
 
template <typename V, typename T>
inline void RenderParameters::visit( V&& visitor, T&& userParams ) const {
    m_parameterSets.visit( visitor, std::forward<T&&>( userParams ) );
}
 
} // namespace Data
} // namespace Engine
} // namespace Ra