parameterblender.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
#include <rtti/rtti.h>
#include <parameternumeric.h>
#include <parametervec.h>
#include <parametercolor.h>
#include <parametersimple.h>
#include <parameterquat.h>
 
namespace nap
{
    // Registration
 
    // Forward Declares
    class BaseParameterBlender;
 
    std::unique_ptr<BaseParameterBlender> NAPAPI getParameterBlender(nap::Parameter& param);
 
    bool NAPAPI registerParameterBlender(rtti::TypeInfo inParameterType, rtti::TypeInfo inBlenderType);
 
 
    // Base Parameter Blender
 
    class NAPAPI BaseParameterBlender
    {
        RTTI_ENABLE()
    public:
        BaseParameterBlender(Parameter& parameter);
 
        // Default destructor
        virtual ~BaseParameterBlender() = default;
 
        void blend(float value);
 
        void setTarget(const Parameter* target);
 
        void clearTarget();
 
        void sync();
 
        bool hasTarget() const;
 
        const Parameter& getTarget() const;
 
        const Parameter& getParameter() const;
 
        template<typename T>
        const T& getTarget() const;
 
        template<typename T>
        T& getParameter();
 
    protected:
        virtual void onBlend(float value) = 0;
 
        virtual void onSync() = 0;
 
        virtual void onTargetSet() = 0;
 
    private:
        Parameter* mParameter = nullptr;
        const Parameter* mTarget = nullptr;
    };
 
 
    // Default Parameter Blender
 
    template<typename ParamType, typename ValueType>
    class ParameterBlender : public BaseParameterBlender
    {
        RTTI_ENABLE(BaseParameterBlender)
    public:
        ParameterBlender(ParamType& parameter);
 
        ParameterBlender(Parameter& parameter);
 
    protected:
        virtual void onBlend(float value) override;
 
        virtual void onSync() override;
 
        virtual void onTargetSet() override;
 
    private:
        ValueType mSourceValue;
    };
 
 
    // Type declarations for all supported (out of the box) parameter blenders
 
    using ParameterFloatBlender     = ParameterBlender<ParameterFloat, float>;
    using ParameterDoubleBlender    = ParameterBlender<ParameterDouble, double>;
    using ParameterVec2Blender      = ParameterBlender<ParameterVec2, glm::vec2>;
    using ParameterVec3Blender      = ParameterBlender<ParameterVec3, glm::vec3>;
    using ParameterVec4Blender      = ParameterBlender<ParameterVec4, glm::vec4>;
    using ParameterRGBAFloatBlender = ParameterBlender<ParameterRGBAColorFloat, RGBAColorFloat>;
    using ParameterRGBFloatBlender  = ParameterBlender<ParameterRGBColorFloat, RGBColorFloat>;
    using ParameterRGBA8Blender     = ParameterBlender<ParameterRGBAColor8, RGBAColor8>;
    using ParameterRGB8Blender      = ParameterBlender<ParameterRGBColor8, RGBColor8>;
    using ParameterBoolBlender      = ParameterBlender<ParameterBool, bool>;
    using ParameterQuatBlender      = ParameterBlender<ParameterQuat, glm::quat>;
 
 
 
    // Template definitions
 
    template<typename T>
    const T& nap::BaseParameterBlender::getTarget() const
    {
        assert(mTarget != nullptr);
        assert(mTarget->get_type().is_derived_from(RTTI_OF(T)));
        return static_cast<const T&>(*mTarget);
    }
 
    template<typename T>
    T& nap::BaseParameterBlender::getParameter()
    {
        assert(mParameter != nullptr);
        assert(mParameter->get_type().is_derived_from(RTTI_OF(T)));
        return static_cast<T&>(*mParameter);
    }
 
    template<typename ParamType, typename ValueType>
    nap::ParameterBlender<ParamType, ValueType>::ParameterBlender(ParamType& parameter) : BaseParameterBlender(parameter)
    {
        this->mSourceValue = parameter.mValue;
    }
 
    template<typename ParamType, typename ValueType>
    nap::ParameterBlender<ParamType, ValueType>::ParameterBlender(Parameter& parameter) : BaseParameterBlender(parameter)
    {
        assert(parameter.get_type().is_derived_from(RTTI_OF(ParamType)));
        this->mSourceValue = this->getParameter<ParamType>().mValue;
    }
 
    template<typename ParamType, typename ValueType>
    void nap::ParameterBlender<ParamType, ValueType>::onBlend(float value)
    {
        ValueType lval = math::lerp<ValueType>(mSourceValue, getTarget<ParamType>().mValue, value);
        getParameter<ParamType>().setValue(lval);
    }
 
    template<typename ParamType, typename ValueType>
    void nap::ParameterBlender<ParamType, ValueType>::onTargetSet()
    {
        onSync();
    }
 
    template<typename ParamType, typename ValueType>
    void nap::ParameterBlender<ParamType, ValueType>::onSync()
    {
        const ParamType& source = getParameter<ParamType>();
        this->mSourceValue = source.mValue;
    }
 
    template<>
    void nap::ParameterBlender<ParameterRGBAColorFloat, RGBAColorFloat>::onBlend(float value);
 
    template<>
    void nap::ParameterBlender<ParameterRGBColorFloat, RGBColorFloat>::onBlend(float value);
 
    template<>
    void nap::ParameterBlender<ParameterRGBAColor8, RGBAColor8>::onBlend(float value);
 
    template<>
    void nap::ParameterBlender<ParameterRGBColor8, RGBColor8>::onBlend(float value);
 
    template<>
    void nap::ParameterBlender<ParameterBool, bool>::onBlend(float value);
 
    template<>
    void nap::ParameterBlender<ParameterQuat, glm::quat>::onBlend(float value);
}