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 Core::VariableSet
{
  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,
                                                RenderParameters>;
 
    template <typename T,
              typename std::enable_if<std::is_base_of<Data::Texture, T>::value, bool>::type = true>
    void setTexture( const std::string& name, T* tex, int texUnit = -1 ) {
        setVariable( name, TextureInfo { tex, texUnit } );
    }
    void setTexture( const std::string& name, T* tex, int texUnit = -1 ) {…}
 
    using VariableSet::setVariable;
 
    void setVariable( const std::string& name, RenderParameters& rp ) {
        VariableSet::setVariable( name, std::ref( rp ) );
    }
    void setVariable( const std::string& name, RenderParameters& rp ) {…}
    void setVariable( const std::string& name, const RenderParameters& rp ) {
        VariableSet::setVariable( name, std::cref( rp ) );
    }
 
    void bind( const Data::ShaderProgram* shader ) const {
        visit( StaticParameterBinder {}, shader );
    }
    void bind( const Data::ShaderProgram* shader ) const  {…}
 
  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 ); }
        }
 
        void operator()( const std::string& /*name*/,
                         const RenderParameters& p,
                         const Data::ShaderProgram* shader ) {
            p.bind( shader );
        }
 
        template <typename T>
        void operator()( const std::string& name, const T& p, const Data::ShaderProgram* shader ) {
            shader->setUniform( name.c_str(), p );
        }
    };
};
class RA_ENGINE_API RenderParameters final : public Core::VariableSet {…};
 
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 ParameterSetEditingInterface {…};
 
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;
};
class RA_ENGINE_API ShaderParameterProvider {…};
 
} // namespace Data
} // namespace Engine
} // namespace Ra