parametervec.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
 
// Local Includes
#include "mathutils.h"
 
// External Includes
#include <parameter.h>
#include <nap/signalslot.h>
 
namespace nap
{
    template<typename T>
    class ParameterVec : public Parameter
    {
        RTTI_ENABLE(Parameter)
    public:
 
        virtual void setValue(const Parameter& value) override;
 
        void setValue(T value);
 
        void setRange(typename T::value_type minimum, typename T::value_type maximum);
 
    public:
        T                       mValue;                                             
        bool                    mClamp = false;                                     
        typename T::value_type  mMinimum = static_cast<typename T::value_type>(0);  
        typename T::value_type  mMaximum = static_cast<typename T::value_type>(1);  
 
        Signal<T>               valueChanged;                                       
    };
 
 
    // Vector Parameter Type Definitions
 
    using ParameterVec2     = ParameterVec<glm::vec2>;
    using ParameterVec3     = ParameterVec<glm::vec3>;
    using ParameterVec4     = ParameterVec<glm::vec4>;
    using ParameterIVec2    = ParameterVec<glm::ivec2>;
    using ParameterIVec3    = ParameterVec<glm::ivec3>;
    using ParameterIVec4    = ParameterVec<glm::ivec4>;
 
 
    // Template Definitions
 
    template<typename T>
    void ParameterVec<T>::setValue(const Parameter& value)
    {
        const ParameterVec<T>* derived_type = rtti_cast<const ParameterVec<T>>(&value);
        assert(derived_type != nullptr);
        setValue(derived_type->mValue);
    }
 
    template<typename T>
    void ParameterVec<T>::setValue(T value)
    {
        // Clamp& set the components for each element individually
        T oldValue = mValue;
 
        if (mClamp)
        {
            for (int i = 0; i != mValue.length(); ++i)
                mValue[i] = math::clamp(value[i], mMinimum, mMaximum);
        }
        else
        {
            mValue = value;
        }
 
        if (oldValue != mValue)
            valueChanged(mValue);
    }
 
 
    template<typename T>
    void nap::ParameterVec<T>::setRange(typename T::value_type minimum, typename T::value_type maximum)
    {
        mMinimum = minimum;
        mMaximum = maximum;
        setValue(mValue);
    }
}
 
#define DEFINE_VECTOR_PARAMETER(Type)                                                                       \
    RTTI_BEGIN_CLASS(Type)                                                                                  \
        RTTI_PROPERTY("Value",      &Type::mValue,          nap::rtti::EPropertyMetaData::Default)          \
        RTTI_PROPERTY("Clamp",      &Type::mClamp,          nap::rtti::EPropertyMetaData::Default)          \
        RTTI_PROPERTY("Minimum",    &Type::mMinimum,        nap::rtti::EPropertyMetaData::Default)          \
        RTTI_PROPERTY("Maximum",    &Type::mMaximum,        nap::rtti::EPropertyMetaData::Default)          \
        RTTI_FUNCTION("setValue",   static_cast<void (Type::*)(decltype(Type::mValue))>(&Type::setValue))   \
    RTTI_END_CLASS