tracktion_AutomatableParameter.h

Go to the documentation of this file.

 /*
    ,--.                     ,--.     ,--.  ,--.
  ,-'  '-.,--.--.,--,--.,---.|  |,-.,-'  '-.`--' ,---. ,--,--,      Copyright 2024
  '-.  .-'|  .--' ,-.  | .--'|     /'-.  .-',--.| .-. ||      \   Tracktion Software
    |  |  |  |  \ '-'  \ `--.|  \  \  |  |  |  |' '-' '|  ||  |       Corporation
    `---' `--'   `--`--'`---'`--'`--' `---' `--' `---' `--''--'    www.tracktion.com
 
    Tracktion Engine uses a GPL/commercial licence - see LICENCE.md for details.
*/
 
namespace tracktion { inline namespace engine
{
 
class AutomatableParameter   : public juce::ReferenceCountedObject,
                               public Selectable,
                               private juce::ValueTree::Listener
{
public:
    AutomatableParameter (const juce::String& paramID,
                          const juce::String& name,
                          AutomatableEditItem&,
                          juce::NormalisableRange<float> valueRange);
 
    ~AutomatableParameter() override;
 
    using Ptr   = juce::ReferenceCountedObjectPtr<AutomatableParameter>;
    using Array = juce::ReferenceCountedArray<AutomatableParameter>;
 
    const juce::String paramID;
    const juce::NormalisableRange<float> valueRange;
    AutomatableEditItem& automatableEditElement;
 
    juce::Range<float> getValueRange() const               { return valueRange.getRange(); }
    Plugin* getPlugin() const                              { return plugin; }
 
    Engine& getEngine() const noexcept;
    Edit& getEdit() const noexcept;
    Track* getTrack() const noexcept;
 
    AutomationCurve& getCurve() const noexcept;
 
    void attachToCurrentValue (juce::CachedValue<float>&);
    void attachToCurrentValue (juce::CachedValue<int>&);
    void attachToCurrentValue (juce::CachedValue<bool>&);
    void updateFromAttachedValue();
    void detachFromCurrentValue();
 
    //==============================================================================
    virtual juce::String getParameterName() const               { return paramName; }
    virtual juce::String getParameterShortName (int) const      { return paramName; }
    virtual juce::String getLabel()                             { return {}; }
 
    // returns a string "pluginname / paramname"
    virtual juce::String getPluginAndParamName() const;
 
    // returns "track / pluginname / paramname"
    virtual juce::String getFullName() const;
 
    Selectable* getOwnerSelectable() const;
 
    EditItemID getOwnerID() const;
 
    //==============================================================================
    float getCurrentValue() const noexcept                      { return currentValue; }
    float getCurrentNormalisedValue() const noexcept            { return valueRange.convertTo0to1 (currentValue); }
 
    virtual juce::String valueToString (float value)            { return valueToStringFunction (value); }
    virtual float stringToValue (const juce::String& s)         { return stringToValueFunction (s); }
 
    virtual juce::String getCurrentValueAsString()              { return valueToString (getCurrentValue()); }
    juce::String getCurrentValueAsStringWithLabel();
 
    std::function<juce::String(float)> valueToStringFunction;
    std::function<float(const juce::String&)> stringToValueFunction;
 
    virtual void beginParameterChangeGesture() {}
    virtual void endParameterChangeGesture() {}
 
    // should be called to change a parameter when a user is actively moving it
    void setParameter (float value, juce::NotificationType);
    void setNormalisedParameter (float value, juce::NotificationType);
    void updateToFollowCurve (TimePosition);
 
    void parameterChangeGestureBegin();
 
    void parameterChangeGestureEnd();
 
    bool hasAutomationPoints() const noexcept                   { return getCurve().getNumPoints() > 0; }
 
    //==============================================================================
    struct ModifierSource
    {
        ModifierSource() = default;
        virtual ~ModifierSource();
 
    private:
        juce::WeakReference<ModifierSource>::Master masterReference;
        friend class juce::WeakReference<ModifierSource>;
    };
 
    struct ModifierAssignment : public juce::ReferenceCountedObject
    {
        using Ptr = juce::ReferenceCountedObjectPtr<ModifierAssignment>;
 
        ModifierAssignment (Edit&, const juce::ValueTree&);
 
        virtual bool isForModifierSource (const ModifierSource&) const = 0;
 
        Edit& edit;
        juce::ValueTree state;
        juce::CachedValue<float> value, offset, curve;
        juce::CachedValue<float> inputStart, inputEnd;
    };
 
    ModifierAssignment::Ptr addModifier (ModifierSource&, float value = 1.0f, float offset = 0.0f, float curve = 0.5f);
 
    void removeModifier (ModifierAssignment&);
 
    void removeModifier (ModifierSource&);
 
    bool hasActiveModifierAssignments() const;
 
    juce::ReferenceCountedArray<ModifierAssignment> getAssignments() const;
 
    juce::Array<ModifierSource*> getModifiers() const;
 
    //==============================================================================
    float getCurrentExplicitValue() const                       { return currentParameterValue; }
 
    float getCurrentBaseValue() const                           { return currentBaseValue; }
 
    float getCurrentModifierValue() const                       { return currentModifierValue; }
 
    //==============================================================================
    bool isAutomationActive() const;
 
    void updateStream();
 
    void updateFromAutomationSources (TimePosition);
 
    //==============================================================================
    virtual bool isParameterActive() const                          { return true; }
    virtual bool isDiscrete() const                                 { return false; }
    virtual int getNumberOfStates() const                           { return 0; }
    virtual float getValueForState (int) const                      { return 0; }
    virtual int getStateForValue (float) const                      { return 0; }
    virtual std::optional<float> getDefaultValue() const;
 
    virtual bool hasLabels()  const                                 { return false; }
    virtual juce::String getLabelForValue (float) const             { return {}; }
    virtual float snapToState (float val) const                     { return val; }
    virtual juce::StringArray getAllLabels() const                  { return {}; }
 
    //==============================================================================
    bool isCurrentlyRecording() const                               { return isRecording; }
 
    void resetRecordingStatus();
 
    //==============================================================================
    // called by ParameterControlMappings
    void midiControllerMoved (float newPosition);
    void midiControllerPressed();
 
    //==============================================================================
    void curveHasChanged();
 
    //==============================================================================
    juce::String getSelectableDescription() override    { return TRANS("Automation Parameter"); }
 
    const juce::String paramName;
    juce::ValueTree parentState;
 
    //==============================================================================
    struct Listener
    {
        virtual ~Listener() {}
 
        virtual void curveHasChanged (AutomatableParameter&) = 0;
 
        virtual void currentValueChanged (AutomatableParameter&) {}
 
        virtual void parameterChanged (AutomatableParameter&, float /*newValue*/) {}
        virtual void parameterChangeGestureBegin (AutomatableParameter&) {}
        virtual void parameterChangeGestureEnd (AutomatableParameter&) {}
    };
 
    void addListener (Listener* l)              { listeners.add (l); }
    void removeListener (Listener* l)           { listeners.remove (l); }
 
protected:
    struct AttachedValue;
    struct AttachedFloatValue;
    struct AttachedIntValue;
    struct AttachedBoolValue;
    std::unique_ptr<AttachedValue> attachedValue;
    juce::ListenerList<Listener> listeners;
 
    SafeSelectable<Edit> editRef;
    Plugin* plugin = nullptr;
    Modifier* modifierOwner = nullptr;
    MacroParameterList* macroOwner = nullptr;
    std::unique_ptr<AutomationCurveSource> curveSource;
    std::atomic<float> currentValue { 0.0f }, currentParameterValue { 0.0f },  currentBaseValue { 0.0f }, currentModifierValue { 0.0f };
    std::atomic<bool> isRecording { false };
    bool updateParametersRecursionCheck = false;
    AsyncCaller parameterChangedCaller { [this] { listeners.call (&Listener::currentValueChanged, *this); } };
 
    juce::ValueTree modifiersState;
    struct AutomationSourceList;
    mutable std::unique_ptr<AutomationSourceList> automationSourceList;
 
    AutomationSourceList& getAutomationSourceList() const;
 
    void setParameterValue (float value, bool isFollowingCurve);
 
    void valueTreePropertyChanged (juce::ValueTree&, const juce::Identifier&) override;
    void valueTreeChildAdded (juce::ValueTree&, juce::ValueTree&) override;
    void valueTreeChildRemoved (juce::ValueTree&, juce::ValueTree&, int) override;
    void valueTreeChildOrderChanged (juce::ValueTree&, int, int) override;
    void valueTreeParentChanged (juce::ValueTree&) override;
    void valueTreeRedirected (juce::ValueTree&) override;
 
    virtual void parameterChanged (float, bool /*byAutomation*/) {}
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AutomatableParameter)
};
 
 
//==============================================================================
template<typename AssignmentType>
juce::ReferenceCountedArray<AssignmentType> getAssignmentsOfType (const AutomatableParameter& ap)
{
    juce::ReferenceCountedArray<AssignmentType> assignments;
 
    for (auto ass : ap.getAssignments())
        if (auto type = dynamic_cast<AssignmentType*> (ass))
            assignments.add (type);
 
    return assignments;
}
 
template<typename ModifierType>
juce::Array<ModifierType*> getModifiersOfType (const AutomatableParameter& ap)
{
    juce::Array<ModifierType*> mods;
 
    for (auto mod : ap.getModifiers())
        if (auto type = dynamic_cast<ModifierType*> (mod))
            mods.add (type);
 
    return mods;
}
 
template<typename AssignmentType, typename ModifierSourceType, typename EditType>
juce::ReferenceCountedArray<AssignmentType> getAssignmentsForSource (EditType& edit, const ModifierSourceType& source)
{
    TRACKTION_ASSERT_MESSAGE_THREAD
    juce::ReferenceCountedArray<AssignmentType> assignments;
 
    edit.visitAllAutomatableParams (true, [&] (AutomatableParameter& param)
    {
        for (auto* ass : param.getAssignments())
            if (auto* m = dynamic_cast<AssignmentType*> (ass))
                if (m->isForModifierSource (source))
                    assignments.add (m);
    });
 
    return assignments;
}
 
AutomatableParameter::ModifierSource* getSourceForAssignment (const AutomatableParameter::ModifierAssignment&);
 
juce::ReferenceCountedArray<AutomatableParameter> getAllParametersBeingModifiedBy (Edit&, AutomatableParameter::ModifierSource&);
 
AutomatableParameter* getParameter (AutomatableParameter::ModifierAssignment&);
 
//==============================================================================
inline int getIntParamValue (const AutomatableParameter& ap)
{
    return juce::roundToInt (ap.getCurrentValue());
}
 
inline bool getBoolParamValue (const AutomatableParameter& ap)
{
    return getIntParamValue (ap) == 1;
}
 
template<typename Type>
inline Type getTypedParamValue (const AutomatableParameter& ap)
{
    return static_cast<Type> (getIntParamValue (ap));
}
 
//==============================================================================
class AutomationDragDropTarget   : public juce::DragAndDropTarget
{
public:
    AutomationDragDropTarget();
    ~AutomationDragDropTarget() override;
 
    //==============================================================================
    virtual bool hasAnAutomatableParameter() = 0;
 
    // this will only be called when actually dropped, so if there are multiple params,
    // it should show UI to choose one and then invoke the callback asynchronously
    virtual void chooseAutomatableParameter (std::function<void(AutomatableParameter::Ptr)> handleChosenParam,
                                             std::function<void()> startLearnMode) = 0;
 
    // start the process for learning a parameter and call the callback when one is chosen
    virtual void startParameterLearn (std::function<void(AutomatableParameter::Ptr)>) {}
 
    // the subclass can call this so it knows to draw itself differently when dragging over
    bool isAutomatableParameterBeingDraggedOver() const;
 
    bool isInterestedInDragSource (const SourceDetails& details) override;
    void itemDragEnter (const SourceDetails& dragSourceDetails) override;
    void itemDragExit (const SourceDetails& dragSourceDetails) override;
    void itemDropped (const SourceDetails& dragSourceDetails) override;
 
    static const char* automatableDragString;
 
private:
    bool isAutoParamCurrentlyOver = false;
};
 
 
//==============================================================================
class ParameterisableDragDropSource
{
public:
    ParameterisableDragDropSource() {}
    virtual ~ParameterisableDragDropSource() {}
 
    // just to say that the user has used the drag function
    virtual void draggedOntoAutomatableParameterTargetBeforeParamSelection() = 0;
 
    // this is called if they actually choose a param
    virtual void draggedOntoAutomatableParameterTarget (const AutomatableParameter::Ptr& param) = 0;
};
 
 
//==============================================================================
// A pre-rendered set of interpolated points along a curve, with a cursor which moves through it.
struct AutomationIterator
{
    AutomationIterator (const AutomatableParameter&);
 
    bool isEmpty() const noexcept               { return points.size() <= 1; }
 
    void setPosition (TimePosition) noexcept;
    float getCurrentValue() noexcept            { return currentValue; }
 
private:
    void interpolate (const AutomatableParameter&);
    void copy (const AutomatableParameter&);
    int updateIndex (TimePosition newTime);
    
    void setPositionHiRes (TimePosition newTime) noexcept;
    void setPositionInterpolated (TimePosition newTime) noexcept;
    
    struct AutoPoint
    {
        TimePosition time = 0_tp;
        float value = 0.0f;
        float curve = 0.0f;
    };
    
    juce::Array<AutoPoint> points;
    int currentIndex = -1;
    float currentValue = 0.0f;
    bool hiRes = false;
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AutomationIterator)
};
 
}} // namespace tracktion { inline namespace engine