ParameterSetEditor.cpp

#include <Gui/ParameterSetEditor/ParameterSetEditor.hpp>
 
#include <Engine/Data/Material.hpp>
#include <Gui/Widgets/ControlPanel.hpp>
 
#include <QString>
#include <QWidget>
 
#include <limits>
#include <memory>
#include <type_traits>
 
using json = nlohmann::json;
 
namespace Ra {
using namespace Engine;
namespace Gui {
 
namespace internal {
class RenderParameterUiBuilder
{
  public:
    using types = Engine::Data::RenderParameters::BindableTypes;
 
    RenderParameterUiBuilder( VariableSetEditor* pse, const json& constraints ) :
        m_pse { pse }, m_constraints { constraints } {}
 
    void operator()( const std::string& name, bool& p, Core::VariableSet&& /* params */ ) {
        auto onBoolParameterChanged = [pse = this->m_pse, &p, nm = name]( bool val ) {
            p = val;
            emit pse->parameterModified( nm );
        };
        if ( m_constraints.contains( name ) ) {
            if ( m_constraints[name]["editable"] ) {
                const auto& m           = m_constraints[name];
                std::string description = m.contains( "description" ) ? m["description"] : "";
                std::string nm          = m.contains( "name" ) ? std::string { m["name"] } : name;
                m_pse->addOption( nm, onBoolParameterChanged, p, description );
            }
        }
        else if ( m_pse->showUnspecified() ) {
            m_pse->addOption( name, onBoolParameterChanged, p );
        }
    }
 
    template <typename TParam, std::enable_if_t<std::is_arithmetic<TParam>::value, bool> = true>
    void operator()( const std::string& name, TParam& p, Core::VariableSet&& params ) {
        using namespace Ra::Core::VariableSetEnumManagement;
        if ( getEnumConverter<TParam>( params, name ) ) {
            m_pse->addEnumWidget( name, p, params, m_constraints );
        }
        else {
            // case number
            m_pse->addNumberWidget( name, p, params, m_constraints );
        }
    }
 
    template <typename TParam,
              typename TAllocator,
              std::enable_if_t<std::is_arithmetic<TParam>::value, bool> = true>
    void operator()( const std::string& name,
                     std::vector<TParam, TAllocator>& p,
                     Core::VariableSet&& params ) {
        m_pse->addVectorWidget( name, p, params, m_constraints );
    }
 
    void
    operator()( const std::string& name, Ra::Core::Utils::Color& p, Core::VariableSet&& params ) {
        auto onColorParameterChanged =
            [pse = this->m_pse, &params, nm = name]( const Ra::Core::Utils::Color& val ) {
                params.setVariable( nm, val );
                emit pse->parameterModified( nm );
            };
        if ( m_constraints.contains( name ) ) {
            const auto& m           = m_constraints[name];
            std::string description = m.contains( "description" ) ? m["description"] : "";
            std::string nm          = m.contains( "name" ) ? std::string { m["name"] } : name;
            m_pse->addColorInput( nm, onColorParameterChanged, p, m["maxItems"] == 4, description );
        }
        else if ( m_pse->showUnspecified() ) {
            m_pse->addColorInput( name, onColorParameterChanged, p );
        }
    }
 
    template <template <typename, int...> typename M, typename T, int... dim>
    void operator()( const std::string& name, M<T, dim...>& p, Core::VariableSet&& params ) {
        m_pse->addMatrixWidget( name, p, params, m_constraints );
    }
 
    void operator()( const std::string& /*name*/,
                     Data::RenderParameters::TextureInfo& /*p*/,
                     Core::VariableSet&& /*params*/ ) {
        // textures are not yet editable
    }
 
    void operator()( const std::string& name,
                     Ra::Engine::Data::RenderParameters& p,
                     Core::VariableSet&& /*params*/ ) {
        m_pse->addLabel( name );
        p.visit( *this, p );
    }
 
  private:
    VariableSetEditor* m_pse { nullptr };
    const json& m_constraints;
};
class RenderParameterUiBuilder {…};
} // namespace internal
 
VariableSetEditor::VariableSetEditor( const std::string& name, QWidget* parent ) :
    ControlPanel( name, !name.empty(), parent ) {}
 
void VariableSetEditor::setupUi( Core::VariableSet& params, const nlohmann::json& constraints ) {
 
    internal::RenderParameterUiBuilder uiBuilder { this, constraints };
    params.visit( uiBuilder, params );
    addStretch( 0 );
    setVisible( true );
}
void VariableSetEditor::setupUi( Core::VariableSet& params, const nlohmann::json& constraints ) {…}
 
} // namespace Gui
} // namespace Ra