controlnode.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
 
// Std includes
#include <atomic>
 
// RTTI includes
#include <rtti/rtti.h>
 
// Audio includes
#include <audio/utility/rampedvalue.h>
#include <audio/utility/translator.h>
#include <audio/utility/safeptr.h>
#include <audio/core/audionode.h>
#include <audio/core/audionodemanager.h>
 
namespace nap
{
    namespace audio
    {
 
        class NAPAPI ControlNode : public Node
        {
            RTTI_ENABLE(Node)
 
        public:
            ControlNode(NodeManager& manager);
 
            OutputPin output = {this};
 
            void setValue(ControllerValue value);
 
            ControllerValue getValue() const;
 
            ControllerValue getRawValue() const
            { return mCurrentValue; }
 
            void ramp(ControllerValue destination, TimeValue time, RampMode mode = RampMode::Linear);
 
            bool isRamping() const { return mValue.isRamping(); }
 
            void stop();
 
            void setTranslator(SafePtr<Translator<ControllerValue>>& translator) { mTranslator = translator; }
 
            bool hasTranslator() const { return mTranslator != nullptr; }
 
            nap::Signal<ControlNode&> rampFinishedSignal;
 
        private:
            void process() override;
 
            void update();
 
            // Slot called internally when the destination of a ramp has been reached.
            nap::Slot<ControllerValue> mDestinationReachedSlot = {this, &ControlNode::destinationReached};
 
            void destinationReached(ControllerValue value)
            {
                mCurrentValue = value;
                rampFinishedSignal(*this);
            }
 
            std::atomic<ControllerValue> mNewDestination = {0.f};
            std::atomic<int> mNewStepCount = {0};
            std::atomic<RampMode> mNewMode = {RampMode::Linear};
            DirtyFlag mIsDirty;
 
            RampedValue<ControllerValue> mValue = {0.f}; // Current output value of the node.
            std::atomic<ControllerValue> mCurrentValue = {0.f};
            SafePtr<Translator<ControllerValue>> mTranslator = nullptr; // Helper object to apply a translation to the output value.
        };
 
    }
}