sequenceplayercurveadapter.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 "sequenceplayer.h"
#include "sequenceplayeradapter.h"
#include "sequenceplayercurveoutput.h"
#include "sequencetrackcurve.h"
 
// nap includes
#include <nap/logger.h>
#include <parametervec.h>
#include <parameternumeric.h>
 
namespace nap
{
 
    class NAPAPI SequencePlayerCurveAdapterBase : public SequencePlayerAdapter
    {
        friend class SequencePlayerCurveOutput;
    private:
        virtual void setValue() = 0;
    };
 
    template<typename CURVE_TYPE, typename PARAMETER_TYPE, typename PARAMETER_VALUE_TYPE>
    class SequencePlayerCurveAdapter final : public SequencePlayerCurveAdapterBase
    {
    public:
        SequencePlayerCurveAdapter(const SequenceTrack& track, SequencePlayerCurveOutput& output)
                : mParameter(static_cast<PARAMETER_TYPE&>(*output.mParameter.get())), mOutput(output) {
            assert(track.get_type().is_derived_from(RTTI_OF(SequenceTrackCurve<CURVE_TYPE>)));
            mTrack = static_cast<const SequenceTrackCurve<CURVE_TYPE>*>(&track);
 
            if(mOutput.mUseMainThread)
            {
                mSetFunction = &SequencePlayerCurveAdapter::storeParameterValue;
                mOutput.registerAdapter(this);
            } else
            {
                mSetFunction = &SequencePlayerCurveAdapter::setParameterValue;
            }
 
            mStoredValue = mParameter.mValue;
        }
 
 
        void destroy() override
        {
            mOutput.removeAdapter(this);
        }
 
 
        void tick(double time) override
        {
            for(const auto &segment: mTrack->mSegments)
            {
                if(time >= segment->mStartTime && time < segment->mStartTime + segment->mDuration)
                {
                    // get the segment we need
                    assert(segment.get()->get_type().is_derived_from(RTTI_OF(SequenceTrackSegmentCurve<CURVE_TYPE>)));
                    const auto &source = static_cast<const SequenceTrackSegmentCurve<CURVE_TYPE>&>(*segment.get());
 
                    // retrieve the source value
                    CURVE_TYPE source_value = source.getValue((time - source.mStartTime) / source.mDuration);
 
                    // cast it to a parameter value
                    auto value = static_cast<PARAMETER_VALUE_TYPE>(
                        source_value * (mTrack->mMaximum - mTrack->mMinimum) + mTrack->mMinimum);
 
                    // call set or store function
                    (*this.*mSetFunction)(value);
 
                    break;
                }
            }
        }
 
 
    private:
        void setValue() override
        {
            std::unique_lock<std::mutex> l(mMutex);
            mParameter.setValue(mStoredValue);
        }
 
 
        void setParameterValue(PARAMETER_VALUE_TYPE& value)
        {
            mParameter.setValue(value);
        }
 
 
        void storeParameterValue(PARAMETER_VALUE_TYPE& value)
        {
            std::unique_lock<std::mutex> l(mMutex);
            mStoredValue = value;
        }
 
 
        PARAMETER_TYPE& mParameter;
        const SequenceTrackCurve<CURVE_TYPE>* mTrack;
        bool mUseMainThread{};
        SequencePlayerCurveOutput& mOutput;
        std::mutex mMutex;
        PARAMETER_VALUE_TYPE mStoredValue;
 
        void (SequencePlayerCurveAdapter::* mSetFunction)(PARAMETER_VALUE_TYPE& value);
    };
}