parameter.h

#pragma once
 
#include "sound_bakery/core/core_include.h"
 
namespace SB::Engine
{
    class NamedParameter;
    class FloatParameter;
    class NamedParameterValue;
 
    template <typename ParameterType>
    class SB_CLASS Parameter : public SB::Core::DatabaseObject
    {
        static_assert(std::is_arithmetic<ParameterType>::value);
 
    public:
        using ParameterProperty = SB::Core::Property<ParameterType>;
 
        using LocalParameter = std::pair<SB_ID, ParameterProperty>;
 
        using LocalParameterValuePair = std::pair<SB_ID, ParameterType>;
 
        Parameter() = default;
 
        Parameter(ParameterType min, ParameterType max)
            : SB::Core::DatabaseObject(), m_property(min, min, max), m_defaultValue(min)
        {
        }
 
        [[nodiscard]] ParameterType get() const { return m_property.get(); }
 
        [[nodiscard]] ParameterType getDefault() const { return m_defaultValue; }
 
        void set(ParameterType value) { m_property.set(value); }
 
        void setDefault(ParameterType value) { m_defaultValue = value; }
 
        [[nodiscard]] typename ParameterProperty::PropertyChangedDelegate& getDelegate()
        {
            return m_property.getDelegate();
        }
 
        [[nodiscard]] LocalParameter createLocalParameterFromThis() const
        {
            return LocalParameter(getDatabaseID(), m_property);
        }
 
    protected:
        ParameterType m_defaultValue;
        SB::Core::Property<ParameterType> m_property;
 
        REGISTER_REFLECTION(Parameter, DatabaseObject)
    };
 
    class SB_CLASS FloatParameter : public Parameter<float>
    {
        REGISTER_REFLECTION(FloatParameter, Parameter)
    };
 
    class SB_CLASS IntParameter : public Parameter<int>
    {
        REGISTER_REFLECTION(IntParameter, Parameter)
    };
 
    class SB_CLASS NamedParameterValue : public SB::Core::DatabaseObject
    {
    public:
        SB::Core::DatabasePtr<NamedParameter> parentParameter;
 
        REGISTER_REFLECTION(NamedParameterValue, DatabaseObject)
    };
 
    class SB_CLASS NamedParameter : public Parameter<SB_ID>
    {
        REGISTER_REFLECTION(NamedParameter, Parameter)
 
    public:
        NamedParameter()
            : m_values(), Parameter((std::numeric_limits<SB_ID>::min)(), (std::numeric_limits<SB_ID>::max)())
        {
        }
 
        SB::Core::DatabasePtr<NamedParameterValue> addNewValue(const std::string_view name)
        {
            SB::Core::DatabasePtr<NamedParameterValue> result;
 
            if (name.empty() == false)
            {
                if (NamedParameterValue* const parameterValue = newDatabaseObject<NamedParameterValue>())
                {
                    parameterValue->setDatabaseName(name);
                    parameterValue->parentParameter = this;
 
                    result = parameterValue;
 
                    m_values.emplace(parameterValue);
                }
            }
 
            return result;
        }
 
        std::unordered_set<SB::Core::DatabasePtr<NamedParameterValue>> getValues()
        {
            if (m_values.empty())
            {
                setSelectedValue(addNewValue("None"));
            }
 
            return m_values;
        }
 
        void setSelectedValue(SB::Core::DatabasePtr<NamedParameterValue> value)
        {
            if (m_values.contains(value))
            {
                set(value.id());
            }
            else
            {
                assert(false);
            }
        }
 
        SB::Core::DatabasePtr<NamedParameterValue> getSelectedValue() const
        {
            SB::Core::DatabasePtr<NamedParameterValue> selected(get());
            selected.lookup();
            return selected;
        }
 
    private:
        std::unordered_set<SB::Core::DatabasePtr<NamedParameterValue>> m_values;
    };
 
    using GlobalFloatParameter = SB::Core::DatabasePtr<FloatParameter>;
    using GlobalIntParameter   = SB::Core::DatabasePtr<NamedParameter>;
 
    struct SB_CLASS GlobalParameterList
    {
        std::unordered_set<GlobalFloatParameter> floatParameters;
        std::unordered_set<GlobalIntParameter> intParameters;
    };
 
    struct SB_CLASS LocalParameterList
    {
        std::unordered_map<GlobalFloatParameter, FloatParameter::ParameterProperty> floatParameters;
        std::unordered_map<GlobalIntParameter, NamedParameter::ParameterProperty> intParameters;
    };
}  // namespace SB::Engine